Exemplo n.º 1
0
    def test_opts_parsing_m3(prof_m3_class):
        """ Test that M3profile parsing matches profile class
        Check that default values are ok and that values are correctly passed
        """
        # keep 'choices' valid for argparse
        prof_m3_class.choices = profile.ProfileM3.choices
        profilem3 = prof_m3_class.return_value
        parser = profile_parser.parse_options()

        args = ['addm3', '-n', 'name', '-p', 'dc']
        opts = parser.parse_args(args)
        profile_parser._m3_profile(opts)  # pylint: disable=protected-access
        profilem3.set_consumption.assert_called_with(
            period=None, average=None, power=False,
            voltage=False, current=False)
        profilem3.set_radio.assert_called_with(
            mode=None, channels=None, period=None, num_per_channel=0)

        args += ['-period', '140', '-avg', '1',
                 '-power', '-voltage', '-current']
        args += ['-rssi', '-channels', '11', '12', '13',
                 '-num', '1', '-rperiod', '1']
        opts = parser.parse_args(args)
        profile_parser._m3_profile(opts)  # pylint: disable=protected-access
        profilem3.set_consumption.assert_called_with(
            period=140, average=1, power=True, voltage=True, current=True)
        profilem3.set_radio.assert_called_with(
            mode='rssi', channels=[11, 12, 13], period=1, num_per_channel=1)
Exemplo n.º 2
0
    def test_opts_parsing_wsn430(prof_wsn430_class):
        """ Test that WSN430profile parsing matches profile class
        Check that default values are ok and that values are correctly passed
        """
        # keep 'choices' valid for argparse
        prof_wsn430_class.choices = profile.ProfileWSN430.choices
        profilewsn430 = prof_wsn430_class.return_value
        parser = profile_parser.parse_options()

        # pylint: disable=protected-access
        args = ['addwsn430', '-n', 'name', '-p', 'dc']
        opts = parser.parse_args(args)
        profile_parser._wsn430_profile(opts)
        profilewsn430.set_consumption.assert_called_with(
            frequency=None, power=False, voltage=False, current=False)
        profilewsn430.set_radio.assert_called_with(frequency=None)
        profilewsn430.set_sensors.assert_called_with(
            frequency=None, temperature=False, luminosity=False)

        args += ['-cfreq', '70', '-power', '-voltage', '-current']
        args += ['-rfreq', '500']
        args += ['-sfreq', '1000', '-luminosity', '-temperature']
        opts = parser.parse_args(args)
        profile_parser._wsn430_profile(opts)
        profilewsn430.set_consumption.assert_called_with(
            frequency=70, power=True, voltage=True, current=True)
        profilewsn430.set_radio.assert_called_with(frequency=500)
        profilewsn430.set_sensors.assert_called_with(
            frequency=1000, temperature=True, luminosity=True)
Exemplo n.º 3
0
    def test_opts_parsing_wsn430(prof_wsn430_class):
        """ Test that WSN430profile parsing matches profile class
        Check that default values are ok and that values are correctly passed
        """
        # keep 'choices' valid for argparse
        prof_wsn430_class.choices = iotlabcli.profile.ProfileWSN430.choices
        profilewsn430 = prof_wsn430_class.return_value
        parser = profile_parser.parse_options()

        # pylint: disable=protected-access
        args = ['addwsn430', '-n', 'name', '-p', 'dc']
        opts = parser.parse_args(args)
        profile_parser._wsn430_profile(opts)
        profilewsn430.set_consumption.assert_called_with(frequency=None,
                                                         power=False,
                                                         voltage=False,
                                                         current=False)
        profilewsn430.set_radio.assert_called_with(frequency=None)
        profilewsn430.set_sensors.assert_called_with(frequency=None,
                                                     temperature=False,
                                                     luminosity=False)

        args += ['-cfreq', '70', '-power', '-voltage', '-current']
        args += ['-rfreq', '500']
        args += ['-sfreq', '1000', '-luminosity', '-temperature']
        opts = parser.parse_args(args)
        profile_parser._wsn430_profile(opts)
        profilewsn430.set_consumption.assert_called_with(frequency=70,
                                                         power=True,
                                                         voltage=True,
                                                         current=True)
        profilewsn430.set_radio.assert_called_with(frequency=500)
        profilewsn430.set_sensors.assert_called_with(frequency=1000,
                                                     temperature=True,
                                                     luminosity=True)
Exemplo n.º 4
0
    def test_opts_parsing_m3(prof_m3_class):
        """ Test that M3profile parsing matches profile class
        Check that default values are ok and that values are correctly passed
        """
        # keep 'choices' valid for argparse
        prof_m3_class.choices = iotlabcli.profile.ProfileM3.choices
        profilem3 = prof_m3_class.return_value
        parser = profile_parser.parse_options()

        args = ['addm3', '-n', 'name', '-p', 'dc']
        opts = parser.parse_args(args)
        profile_parser._m3_profile(opts)  # pylint: disable=protected-access
        profilem3.set_consumption.assert_called_with(period=None,
                                                     average=None,
                                                     power=False,
                                                     voltage=False,
                                                     current=False)
        profilem3.set_radio.assert_called_with(mode=None,
                                               channels=None,
                                               period=None,
                                               num_per_channel=None)

        # Test for RSSI
        args = ['addm3', '-n', 'name', '-p', 'dc']
        args += [
            '-period', '140', '-avg', '1', '-power', '-voltage', '-current'
        ]
        args += [
            '-rssi', '-channels', '11', '12', '13', '-num', '1', '-rperiod',
            '1'
        ]
        opts = parser.parse_args(args)
        profile_parser._m3_profile(opts)  # pylint: disable=protected-access
        profilem3.set_consumption.assert_called_with(period=140,
                                                     average=1,
                                                     power=True,
                                                     voltage=True,
                                                     current=True)
        profilem3.set_radio.assert_called_with(mode='rssi',
                                               channels=[11, 12, 13],
                                               period=1,
                                               num_per_channel=1)

        # Test for Radio Sniffer only
        args = ['addm3', '-n', 'name', '-p', 'dc']
        args += ['-sniffer', '-channels', '11']
        opts = parser.parse_args(args)
        profile_parser._m3_profile(opts)  # pylint: disable=protected-access
        profilem3.set_consumption.assert_called_with(period=None,
                                                     average=None,
                                                     power=False,
                                                     voltage=False,
                                                     current=False)
        profilem3.set_radio.assert_called_with(mode='sniffer',
                                               channels=[11],
                                               period=None,
                                               num_per_channel=None)
Exemplo n.º 5
0
    def test_opts_parsing_m3(self, prof_m3_class, circuit_mock):
        """ Test that M3profile parsing matches profile class
        Check that default values are ok and that values are correctly passed
        """
        # keep 'choices' valid for argparse
        prof_m3_class.choices = profile.ProfileM3.choices
        profilem3 = prof_m3_class.return_value
        parser = profile_parser.parse_options()

        args = ['addm3', '-n', 'name', '-p', 'dc']
        opts = parser.parse_args(args)
        profile_parser._m3_profile(opts)  # pylint: disable=protected-access
        profilem3.set_consumption.assert_called_with(
            period=None, average=None, power=False,
            voltage=False, current=False)
        profilem3.set_radio.assert_called_with(
            mode=None, channels=None, period=None, num_per_channel=None)
        self.assertEqual(profilem3.mobility, None)

        # Test for RSSI
        args = ['addm3', '-n', 'name', '-p', 'dc']
        args += ['-period', '140', '-avg', '1',
                 '-power', '-voltage', '-current']
        args += ['-rssi', '-channels', '11', '12', '13',
                 '-num', '1', '-rperiod', '1']
        opts = parser.parse_args(args)
        profile_parser._m3_profile(opts)  # pylint: disable=protected-access
        profilem3.set_consumption.assert_called_with(
            period=140, average=1, power=True, voltage=True, current=True)
        profilem3.set_radio.assert_called_with(
            mode='rssi', channels=[11, 12, 13], period=1, num_per_channel=1)
        self.assertEqual(profilem3.mobility, None)

        # Test for Radio Sniffer only
        args = ['addm3', '-n', 'name', '-p', 'dc']
        args += ['-sniffer', '-channels', '11']
        opts = parser.parse_args(args)
        profile_parser._m3_profile(opts)  # pylint: disable=protected-access
        profilem3.set_consumption.assert_called_with(
            period=None, average=None, power=False,
            voltage=False, current=False)
        profilem3.set_radio.assert_called_with(
            mode='sniffer', channels=[11], period=None, num_per_channel=None)
        self.assertEqual(profilem3.mobility, None)

        # Test for mobility only
        # required fields
        circuit = {"site_name": "devgrenoble", "trajectory_name": "Jhall"}
        circuit_mock.return_value = circuit
        args = ['addm3', '-n', 'name', '-p', 'dc']
        args += ['--circuit', 'grenoble,Jhall']
        opts = parser.parse_args(args)

        profile_parser._m3_profile(opts)  # pylint: disable=protected-access
        self.assertEqual(profilem3.mobility, circuit)
Exemplo n.º 6
0
 def test_parser_error(self):
     """ Test some parser errors directly """
     parser = profile_parser.parse_options()
     # Python3 didn't raised error without subcommand
     self.assertRaises(SystemExit, parser.parse_args, [])
Exemplo n.º 7
0
 def test_parser_error(self):
     """ Test some parser errors directly """
     parser = profile_parser.parse_options()
     # Python3 didn't raised error without subcommand
     self.assertRaises(SystemExit, parser.parse_args, [])