def test_add_where(self, queue, factories, db_session, now): matching = [ factories.Annotation(shared=True), factories.Annotation(shared=True), ] # Add some noise factories.Annotation(shared=False) queue.add_where( where=[Annotation.shared.is_(True)], tag="test_tag", priority=1234, schedule_in=ONE_WEEK_IN_SECONDS, ) assert db_session.query(Job).all() == [ Any.instance_of(Job).with_attrs( dict( enqueued_at=Any.instance_of(datetime_.datetime), scheduled_at=now + ONE_WEEK, tag="test_tag", priority=1234, kwargs={ "annotation_id": self.database_id(annotation), "force": False, }, )) for annotation in matching ]
def test_command_parsing_ok(self, executor, ndjson_bytes): """Sanity test that hits most elements of parsing.""" BulkAPI.from_byte_stream(ndjson_bytes, executor=executor, observer=Observer()) executor.configure.assert_called_with( config=Any.instance_of(Configuration)) executor.execute_batch.assert_has_calls([ call( command_type=CommandType.UPSERT, data_type=DataType.USER, batch=[Any.instance_of(DataCommand)], default_config={}, ), call( command_type=CommandType.UPSERT, data_type=DataType.GROUP, batch=[Any.instance_of(DataCommand)], default_config={}, ), call( command_type=CommandType.CREATE, data_type=DataType.GROUP_MEMBERSHIP, batch=[Any.instance_of(DataCommand)], default_config={"on_duplicate": "continue"}, ), ])
def test_it(self, userid, users_annotations, db_session, queue, force, schedule_in): queue.add_users_annotations(userid, tag="test_tag", force=force, schedule_in=schedule_in) assert (db_session.query(Job).all() == Any.list.containing([ Any.instance_of(Job).with_attrs({ "tag": "test_tag", "name": "sync_annotation", "scheduled_at": Any.instance_of(datetime_.datetime), "priority": 100, "kwargs": { "annotation_id": str(uuid.UUID(URLSafeUUID.url_safe_to_hex(annotation.id))), "force": force, }, }) for annotation in users_annotations ]).only())
def test_it(self, annotation_ids, db_session, queue, force): queue.add_annotations_between_times( datetime_.datetime(2020, 9, 9), datetime_.datetime(2020, 9, 11), "test_tag", force, ) assert (db_session.query(Job).all() == Any.list.containing([ Any.instance_of(Job).with_attrs({ "tag": "test_tag", "name": "sync_annotation", "scheduled_at": Any.instance_of(datetime_.datetime), "priority": 1000, "kwargs": { "annotation_id": str(uuid.UUID(URLSafeUUID.url_safe_to_hex(annotation_id))), "force": force, }, }) for annotation_id in annotation_ids ]).only())
def test_it(self, db_session, queue, now): queue.add("test_annotation_id", "test_tag", schedule_in=ONE_WEEK) assert db_session.query(Job).all() == [ Any.instance_of(Job).with_attrs( dict( enqueued_at=Any.instance_of(datetime_.datetime), scheduled_at=now + ONE_WEEK, tag="test_tag", priority=1, kwargs={"annotation_id": "test_annotation_id"}, )), ]
def test_it_can_insert_new_records(self, db_session, commands): reports = GroupMembershipCreateAction(db_session).execute(commands) assert reports == Any.iterable.comprised_of( Any.instance_of(Report)).of_size(3) self.assert_membership_matches_commands(db_session, commands)
def test_we_call_third_parties_correctly(self, call_route_by_content, get_url_details): url = "http://example.com/path%2C?a=b" call_route_by_content(url, params={"other": "value"}) get_url_details.assert_called_once_with( url, Any.instance_of(EnvironHeaders))
def _assert_process_called_with_generator_of_commands( self, CommandProcessor): (generator, ), _ = CommandProcessor.return_value.process.call_args assert isinstance(generator, GeneratorType) assert generator == Any.iterable.comprised_of( Any.instance_of(Command)).of_size(4)
def test_it_calls_bulk_api_correctly(self, pyramid_request, BulkAPI): bulk(pyramid_request) BulkAPI.from_byte_stream.assert_called_once_with( pyramid_request.body_file, executor=Any.instance_of(AuthorityCheckingExecutor), )
def test_it_can_insert_new_records(self, db_session, commands): reports = UserUpsertAction(db_session).execute(commands) assert reports == Any.iterable.comprised_of( Any.instance_of(Report)).of_size(3) self.assert_users_match_commands(db_session, commands)
def test_it_can_match_objects_with_equals(self): class NeverMatches: def __eq__(self, other): # pragma: no cover return False matcher = HostClass.comprised_of(Any.instance_of(NeverMatches)) assert matcher == [NeverMatches()]
def test_it_can_insert_new_records(self, db_session, commands, user): reports = GroupUpsertAction(db_session).execute( commands, effective_user_id=user.id) assert reports == Any.iterable.comprised_of( Any.instance_of(Report)).of_size(3) self.assert_groups_match_commands(db_session, commands)
def test_combo(self): matcher = (Any().list().containing([ Any(), Any.instance_of(ValueError), Any().dict().containing({"a": Any().iterable().containing([2])}), ]).of_size(at_least=2)) assert matcher == [{"a": range(4), "b": None}, None, ValueError()]
def test_it_initializes_sentry_sdk(self, pyramid_config, sentry_sdk): includeme(pyramid_config) sentry_sdk.init.assert_called_once_with( integrations=[Any.instance_of(PyramidIntegration)], send_default_pii=True, before_send=Any.function(), )
def test_from_string(self, nd_json, executor, CommandProcessor): BulkAPI.from_string(nd_json, executor) CommandProcessor.assert_called_once_with( executor=executor, observer=Any.instance_of(Observer)) self._assert_process_called_with_generator_of_commands( CommandProcessor)
def test_execute_batch_returns_an_appropriate_type(self, command_type): results = AutomaticReportExecutor().execute_batch( command_type, sentinel.data_type, sentinel.config, batch=[sentinel.command]) assert results == [Any.instance_of(Report)]
def test_from_models(self, factories): auth_client = factories.AuthClient.build() model = LongLivedAuthClient.from_model(auth_client) assert model == Any.instance_of(LongLivedAuthClient).with_attrs( {"id": auth_client.id, "authority": auth_client.authority} )
def test_from_models(self, factories): group = factories.Group.build() model = LongLivedGroup.from_model(group) assert model == Any.instance_of(LongLivedGroup).with_attrs( {"id": group.id, "pubid": group.pubid} )
def test_reports_are_stored_if_view_is_not_None(self, command_processor, commands, config_command): config_command.body.raw["view"] = "to_be_decided" command_processor.process(commands) assert command_processor.reports == Any.dict.containing( {DataType.USER: [Any.instance_of(Report)]})
def test_it_can_continue_with_existing_records(self, db_session, commands): GroupMembershipCreateAction(db_session).execute(commands) reports = GroupMembershipCreateAction(db_session).execute( commands, on_duplicate="continue" ) assert reports == Any.iterable.comprised_of(Any.instance_of(Report)).of_size(3) self.assert_membership_matches_commands(db_session, commands)
def test_from_input(self, input_data, executor, bulk_method, CommandProcessor): result = bulk_method(input_data, executor) CommandProcessor.assert_called_once_with( executor=executor, observer=Any.instance_of(Observer)) assert result == sentinel.reports self._assert_process_called_with_generator_of_commands( CommandProcessor)
def test_from_models_with_None(self, LongLivedUser, LongLivedAuthClient): identity = Identity.from_models() LongLivedUser.from_model.assert_not_called() LongLivedAuthClient.from_model.assert_not_called() assert identity == Any.instance_of(Identity).with_attrs( {"user": None, "auth_client": None} )
def test_passes_args_including_renderer_to_form_ctor( self, Form, pyramid_request): form.create_form(pyramid_request, mock.sentinel.schema, foo="bar") Form.assert_called_once_with( mock.sentinel.schema, foo="bar", renderer=Any.instance_of(form.Jinja2Renderer), )
def test_it_raises_if_write_permission_is_missing(self, pyramid_request, annotation_data, has_permission): has_permission.return_value = False with pytest.raises(ValidationError): storage.create_annotation(pyramid_request, annotation_data) has_permission.assert_called_once_with( Permission.Group.WRITE, context=Any.instance_of(GroupContext))
def test_it_raises_if_the_response_is_an_error(self, svc, url, status): httpretty.register_uri("GET", url, status=status) with pytest.raises(UnhandledUpstreamException) as exc_info: svc.request("GET", url) assert isinstance(exc_info.value.__cause__, requests.HTTPError) assert exc_info.value.response == Any.instance_of(requests.Response).with_attrs( {"status_code": status} )
def test_it_doesnt_raise_if_the_response_is_an_error_when_disabled( self, svc, url, status ): httpretty.register_uri("GET", url, status=status) response = svc.request("GET", url, raise_for_status=False) assert response == Any.instance_of(requests.Response).with_attrs( {"status_code": status} )
def test_it(self, db_session, factories, queue, now): annotation = factories.Annotation.build() queue.add(annotation.id, "test_tag", schedule_in=ONE_WEEK_IN_SECONDS) assert db_session.query(Job).all() == [ Any.instance_of(Job).with_attrs( dict( enqueued_at=Any.instance_of(datetime_.datetime), scheduled_at=now + ONE_WEEK, tag="test_tag", priority=1, kwargs={ "annotation_id": URLSafeUUID.url_safe_to_hex(annotation.id), "force": False, }, )), ]
def test_execute_batch_generates_fake_ids(self): results = AutomaticReportExecutor().execute_batch( sentinel.command_type, sentinel.data_type, sentinel.config, batch=[sentinel.command, sentinel.command, sentinel.command], ) assert results == Any.list.comprised_of( Any.instance_of(Report)).of_size(3) assert len({report.id for report in results}) == 3
def test_it_can_update_records(self, db_session, commands): update_commands = [ upsert_user_command(i, display_name=f"changed_{i}") for i in range(3) ] action = UserUpsertAction(db_session) action.execute(commands) reports = action.execute(update_commands) assert reports == Any.iterable.comprised_of(Any.instance_of(Report)).of_size(3) self.assert_users_match_commands(db_session, update_commands)
def test_from_models(self, LongLivedUser, LongLivedAuthClient): identity = Identity.from_models( user=sentinel.user, auth_client=sentinel.auth_client ) LongLivedUser.from_model.assert_called_once_with(sentinel.user) LongLivedAuthClient.from_model.assert_called_once_with(sentinel.auth_client) assert identity == Any.instance_of(Identity).with_attrs( { "user": LongLivedUser.from_model.return_value, "auth_client": LongLivedAuthClient.from_model.return_value, } )