Example #1
0
    def test_field_exists(self):
        unit_system = random.randint(1, 10)
        fieldname = ''.join([
            random.choice(string.ascii_letters + string.digits)
            for n in range(32)
        ])
        config_dict = {}
        config_dict['MQTTSubscribeService'] = {
            'archive_field_cache': {
                'fields': {
                    fieldname: {}
                }
            }
        }

        config = configobj.ConfigObj(config_dict)

        with mock.patch('user.MQTTSubscribe.MQTTSubscribe'):
            with mock.patch('user.MQTTSubscribe.RecordCache'):
                # pylint: disable=no-member
                SUT = MQTTSubscribeService(self.mock_StdEngine, config)

                record = {
                    'usUnits': unit_system,
                    'dateTime': time.time(),
                    fieldname: round(random.uniform(1, 100), 2)
                }

                event = test_weewx_stubs.Event(
                    test_weewx_stubs.NEW_ARCHIVE_RECORD, record=record)

                SUT.new_archive_record(event)
                SUT.cache.update_value.assert_called_once()
    def test_packet_is_in_past(self):
        topic = 'foo/bar'
        current_time = int(time.time() + 0.5)
        end_period_ts = (int(current_time / 300) + 1) * 300
        start_ts = end_period_ts - 300
        self.setup_queue_tests(start_ts, end_period_ts)
        self.final_packet_data.update(self.target_data)

        new_loop_packet_event = test_weewx_stubs.Event(
            test_weewx_stubs.NEW_LOOP_PACKET, packet=self.packet_data)

        with mock.patch('user.MQTTSubscribe.MQTTSubscribe') as mock_manager:
            with mock.patch('user.MQTTSubscribe.Logger'):
                # pylint: disable=no-member
                type(
                    mock_manager.return_value
                ).subscribed_topics = mock.PropertyMock(return_value=[topic])
                type(mock_manager.return_value
                     ).get_accumulated_data = mock.Mock(
                         return_value=self.target_data)

                SUT = MQTTSubscribeService(self.mock_StdEngine,
                                           self.config_dict)
                SUT.end_ts = end_period_ts + 10

                SUT.new_loop_packet(new_loop_packet_event)

                SUT.logger.error.assert_called_once()

                SUT.shutDown()
    def test_queue_valid(self):
        topic = 'foo/bar'
        current_time = int(time.time() + 0.5)
        end_period_ts = (int(current_time / 300) + 1) * 300
        start_ts = end_period_ts - 300
        self.setup_queue_tests(start_ts, end_period_ts)
        self.final_packet_data.update(self.target_data)

        new_loop_packet_event = test_weewx_stubs.Event(
            test_weewx_stubs.NEW_LOOP_PACKET, packet=self.packet_data)

        with mock.patch('user.MQTTSubscribe.MQTTSubscribe') as mock_manager:
            type(mock_manager.return_value
                 ).subscribed_topics = mock.PropertyMock(return_value=[topic])
            type(mock_manager.return_value).get_accumulated_data = mock.Mock(
                return_value=self.target_data)

            SUT = MQTTSubscribeService(self.mock_StdEngine, self.config_dict)
            SUT.end_ts = start_ts

            SUT.new_loop_packet(new_loop_packet_event)

            self.assertDictEqual(new_loop_packet_event.packet,
                                 self.final_packet_data)

            SUT.shutDown()
    def test_queue_valid(self):
        topic = 'foo/bar'
        current_time = int(time.time() + 0.5)
        end_period_ts = (int(current_time / 300) + 1) * 300
        start_ts = end_period_ts - 300
        self.setup_archive_queue_tests(start_ts, end_period_ts, topic)
        self.final_record_data.update(self.target_data)

        new_loop_record_event = test_weewx_stubs.Event(
            test_weewx_stubs.NEW_ARCHIVE_RECORD,
            record=self.record_data,
            origin='hardware')

        with mock.patch('user.MQTTSubscribe.MQTTSubscribe') as mock_manager:
            type(mock_manager.return_value
                 ).subscribed_topics = mock.PropertyMock(return_value=[topic])
            type(mock_manager.return_value).get_accumulated_data = mock.Mock(
                return_value=self.target_data)

            SUT = MQTTSubscribeService(self.mock_StdEngine, self.config_dict)
            SUT.end_ts = start_ts

            SUT.new_archive_record(new_loop_record_event)

            self.assertDictEqual(new_loop_record_event.record,
                                 self.final_record_data)

        SUT.shutDown()
Example #5
0
    def test_field_missing(self):
        unit_system = random.randint(1, 10)
        fieldname = ''.join([
            random.choice(string.ascii_letters + string.digits)
            for n in range(32)
        ])
        config_dict = {}
        config_dict['MQTTSubscribeService'] = {
            'archive_field_cache': {
                'fields': {
                    fieldname: {}
                }
            }
        }

        config = configobj.ConfigObj(config_dict)

        with mock.patch('user.MQTTSubscribe.MQTTSubscribe'):
            with mock.patch('user.MQTTSubscribe.RecordCache') as mock_cache:
                value = round(random.uniform(10, 100), 2)
                type(mock_cache.return_value).get_value = mock.Mock(
                    return_value=value)
                # pylint: disable=no-member
                SUT = MQTTSubscribeService(self.mock_StdEngine, config)

                record = {'usUnits': unit_system, 'dateTime': time.time()}

                event = test_weewx_stubs.Event(
                    test_weewx_stubs.NEW_ARCHIVE_RECORD, record=record)

                updated_record = copy.deepcopy(record)
                updated_record.update({fieldname: value})

                SUT.new_archive_record(event)
                SUT.cache.get_value.assert_called_once()
                self.assertEqual(record, updated_record)
    def runit(self, payload, file_pointer, check_results=True):
        test_data = json.load(file_pointer, object_hook=utils.byteify)
        config_dict = configobj.ConfigObj(test_data['config'])
        testruns = test_data['testruns']

        cdict = config_dict['MQTTSubscribeService']
        if not 'message_callback' in config_dict['MQTTSubscribeService']:
            config_dict['MQTTSubscribeService']['message_callback'] = {}
        config_dict['MQTTSubscribeService']['message_callback'][
            'type'] = payload

        unit_system_name = cdict['topics'].get('unit_system',
                                               'US').strip().upper()
        if unit_system_name not in weewx.units.unit_constants:
            raise ValueError("MQTTSubscribe: Unknown unit system: %s" %
                             unit_system_name)
        unit_system = weewx.units.unit_constants[unit_system_name]

        min_config_dict = {
            'Station': {
                'altitude': [0, 'foot'],
                'latitude': 0,
                'station_type': 'Simulator',
                'longitude': 0
            },
            'Simulator': {
                'driver': 'weewx.drivers.simulator',
            },
            'Engine': {
                'Services': {}
            }
        }

        engine = StdEngine(min_config_dict)
        service = MQTTSubscribeService(engine, config_dict)

        host = 'localhost'
        port = 1883
        keepalive = 60

        userdata = {
            'topics': [],
            'connected_flag': False,
        }
        client = mqtt.Client(userdata=userdata)
        client.on_connect = utils.on_connect
        client.connect(host, port, keepalive)
        client.loop_start()

        max_connect_wait = 1  # ToDo - configure
        i = 1
        while not userdata['connected_flag']:
            if i > max_connect_wait:
                self.fail("Timed out waiting for connections.")
            time.sleep(1)
            i += 1

        userdata2 = {
            'topics': cdict['topics'].sections,
            'connected_flag': False,
            'msg': False,
            'max_msg_wait': 1  #ToDo - configure
        }
        client2 = mqtt.Client(userdata=userdata2)
        client2.on_connect = utils.on_connect
        client2.on_message = utils.on_message
        client2.connect(host, port, keepalive)
        client2.loop_start()
        max_connect2_wait = 1  # ToDo - configure
        i = 1
        while not userdata2['connected_flag']:
            if i > max_connect2_wait:
                self.fail("Timed out waiting for connection 2.")
            time.sleep(1)
            i += 1

        max_waits = 10
        for testrun in testruns:
            for topics in testrun['messages']:
                for topic in topics:
                    topic_info = topics[topic]
                    msg_count = utils.send_msg(utils.send_mqtt_msg, payload,
                                               client.publish, topic,
                                               topic_info, userdata2, self)
                    utils.wait_on_queue(service, msg_count, max_waits, 1)

            record = {}
            interval = 300
            current_time = int(time.time() + 0.5)
            end_period_ts = (int(current_time / interval) + 1) * interval

            record['dateTime'] = end_period_ts
            record['usUnits'] = unit_system
            new_loop_packet_event = weewx.Event(weewx.NEW_LOOP_PACKET,
                                                packet=record)
            service.new_loop_packet(new_loop_packet_event)

            records = [record]

            if check_results:
                results = testrun['results']
                result = {}
                found = False
                for result in results:
                    if 'service' in result['test']:
                        if payload in result['payloads']:
                            found = True
                            break
                self.assertTrue(found, "No results for %s" % payload)

                utils.check(self, payload, records, result['records'])
            else:
                for record in records:
                    print(record)

        service.shutDown()
        client.disconnect()
        client2.disconnect()