def test_handle_unmapped_vendor_points(self, uow):
        fieldserver_file_handler = FieldserverFileHandler()
        fieldserver_file_handler.date_str = "date"

        unmapped_vendor_points = [{"source": "fieldserver", "fieldserver_site_id": "123456", "fieldserver_offset": 0},
                                  {"source": "fieldserver", "fieldserver_site_id": "123456", "fieldserver_offset": 1},
                                  {"source": "fieldserver", "fieldserver_site_id": "123456", "fieldserver_offset": 2}]

        detupled_keys = [["123456", 0], ["123456", 1], ["123456", 2]]

        db_query_call = uow.return_value.data_mapping.get_unknown_vendor_points_for_fieldserver_site_id_offset
        db_query_call.return_value = [{"source": "fieldserver", "fieldserver_site_id": "123456",
                                       "fieldserver_offset": 0, "date_added": "date"},
                                      {"source": "fieldserver", "fieldserver_site_id": "123456",
                                       "fieldserver_offset": 1, "date_added": "date"}]
        db_insert_call = uow.return_value.data_mapping.insert_unknown_vendor_points

        fieldserver_file_handler.handle_unmapped_vendor_points(unmapped_vendor_points)
        db_query_call_args = db_query_call.call_args[0][0]
        assert sorted(db_query_call_args) == sorted(detupled_keys)

        filtered_unmapped_vendor_points = [{"source": "fieldserver", "fieldserver_site_id": "123456",
                                            "fieldserver_offset": 2, "date_added": "date"}]

        db_insert_call.assert_called_with(filtered_unmapped_vendor_points)
    def test_process_fieldserver_records(self, uow):
        fieldserver_file_handler = FieldserverFileHandler()
        fieldserver_file_handler.logger = Mock()
        fieldserver_file_handler.date_str = Mock()
        fieldserver_file_handler.handle_unmapped_vendor_points = Mock()

        processed_records = ProcessFieldserverRecordsReturn()
        processed_records.good_records = [
            {"name": "record0"},
            {"name": "record1"}
        ]
        processed_records.bad_records = [
            {"name": "record2"},
            {"name": "record3"}
        ]
        processed_records.unmapped_vendor_points = [
            {"name": "record4"},
            {"name": "record5"}
        ]
        processed_records.global_vendor_point_records = [
            {'name': 'record6'},
            {'name': 'record7'}
        ]
        fieldserver_file_handler.get_processed_fieldserver_records = Mock(return_value=processed_records)
        fieldserver_file_handler.make_global_vendor_point_records_unique = Mock(return_value=processed_records.global_vendor_point_records)

        records = [MagicMock(), MagicMock()]
        good_record_file = io.StringIO()
        bad_record_file = io.StringIO()

        rv = fieldserver_file_handler.process_fieldserver_records(records, good_record_file, bad_record_file)

        fieldserver_file_handler.get_processed_fieldserver_records.assert_called_with(records)

        good_record_file.seek(0)
        good_records_written_data = good_record_file.read().strip().split("\n")
        assert len(good_records_written_data) == 2
        assert json.loads(good_records_written_data[0]) == {"name": "record0"}
        assert json.loads(good_records_written_data[1]) == {"name": "record1"}

        bad_record_file.seek(0)
        bad_records_written_data = bad_record_file.read().strip().split("\n")
        assert len(bad_records_written_data) == 2
        assert json.loads(bad_records_written_data[0]) == {"name": "record2"}
        assert json.loads(bad_records_written_data[1]) == {"name": "record3"}

        fieldserver_file_handler.handle_unmapped_vendor_points.assert_called_with(processed_records.unmapped_vendor_points)

        assert rv.num_good_records == 2
        assert rv.num_bad_records == 2
        assert rv.num_unmapped_vendor_points == 2