def test_authenticate_good_key_keyring( local_dandi_api: DandiAPI, mocker: MockerFixture, monkeypatch: pytest.MonkeyPatch) -> None: good_key = local_dandi_api.api_key client_name = local_dandi_api.instance_id app_id = f"dandi-api-{client_name}" backend_mock = mocker.Mock(spec=["set_password"]) keyring_lookup_mock = mocker.patch("dandi.dandiapi.keyring_lookup", return_value=(backend_mock, good_key)) input_spy = mocker.spy(builtins, "input") is_interactive_spy = mocker.spy(dandiapi, "is_interactive") confirm_spy = mocker.spy(click, "confirm") monkeypatch.delenv("DANDI_API_KEY", raising=False) client = DandiAPIClient(local_dandi_api.api_url) assert "Authorization" not in client.session.headers client.dandi_authenticate() assert client.session.headers["Authorization"] == f"token {good_key}" backend_mock.set_password.assert_not_called() keyring_lookup_mock.assert_called_once_with(app_id, "key") input_spy.assert_not_called() is_interactive_spy.assert_not_called() confirm_spy.assert_not_called()
def test_functions_are_called_correctly(self, mocker: MockerFixture) -> None: mocker.patch("panel.tasks.torrent.Client", MockClient) mocker.patch("panel.tasks.torrent.check_and_process_torrent.delay") mocker.patch("panel.tasks.torrent.download_movie_info.delay") remove_category = mocker.spy(panel.tasks.tests.mocks.MockClient, "remove_category") create_category = mocker.spy(panel.tasks.tests.mocks.MockClient, "create_category") mocker.patch("panel.tasks.torrent.check_and_process_torrent.delay") mocker.patch("panel.tasks.torrent.download_movie_info.delay") download_from_link = mocker.spy(panel.tasks.tests.mocks.MockClient, "download_from_link") movie_content: MovieContent = MovieContentFactory() MovieFactory.create(movie_content=[movie_content]) download_torrent(movie_content_id=movie_content.id) remove_category.assert_called_once_with(str(movie_content.id)) create_category.assert_called_once_with(str(movie_content.id)) download_from_link.assert_called_once_with( movie_content.torrent_source, category=str(movie_content.id)) panel.tasks.torrent.check_and_process_torrent.delay.assert_called_once( ) panel.tasks.torrent.download_movie_info.delay.assert_called_once()
def test_set_cert( tester: CommandTester, auth_config_source: DictConfigSource, mocker: MockerFixture, ): mocker.spy(ConfigSource, "__init__") tester.execute("certificates.foo.cert path/to/ca.pem") assert auth_config_source.config["certificates"]["foo"]["cert"] == "path/to/ca.pem"
def test_set_cert( tester: CommandTester, auth_config_source: DictConfigSource, mocker: MockerFixture, value: str, result: str | bool, ): mocker.spy(ConfigSource, "__init__") tester.execute(f"certificates.foo.cert {value}") assert auth_config_source.config["certificates"]["foo"]["cert"] == result
def test_tutorial001(app_runner, mocker: MockerFixture): event = ScheduledEvent(asset_id=0, start_time=0, end_time=0, company_id=0) store_spy = mocker.spy(RedisState, 'store') load_spy = mocker.spy(RedisState, 'load') load_all_spy = mocker.spy(RedisState, 'load_all') app_runner(tutorial001.scheduled_app, event) assert store_spy.call_count == 5 assert load_spy.call_count == 4 assert load_all_spy.call_count == 1
def test__save_session__called_on_session_set(app, mocker: MockerFixture): save_spy = mocker.spy(MongoEngineSessionInterface, "save_session") expiration_spy = mocker.spy(MongoEngineSessionInterface, "get_expiration_time") client = app.test_client() response = client.get("/") call_args, _ = expiration_spy.call_args_list[0] assert response.status_code == 200 assert response.data.decode("utf-8") == "hello session" assert app.session_interface.cls.objects.count() == 1 save_spy.assert_called_once() assert call_args[2].permanent is False # session object
def test_git_clone_default_branch_head( source_url: str, remote_refs: FetchPackResult, remote_default_ref: bytes, mocker: MockerFixture, ): spy = mocker.spy(Git, "_clone") spy_legacy = mocker.spy(Git, "_clone_legacy") with Git.clone(url=source_url) as repo: assert remote_refs.refs[remote_default_ref] == repo.head() spy_legacy.assert_not_called() spy.assert_called()
def test_username_password_parameter_is_not_passed_to_dulwich( mocker: MockerFixture, source_url: str, config: Config) -> None: from poetry.vcs.git import backend spy_clone = mocker.spy(Git, "_clone") spy_get_transport_and_path = mocker.spy(backend, "get_transport_and_path") with Git.clone(url=source_url, branch="0.1") as repo: assert_version(repo, BRANCH_TO_REVISION_MAP["0.1"]) spy_clone.assert_called_once() spy_get_transport_and_path.assert_called_with(location=source_url, ) spy_get_transport_and_path.assert_called_once()
def test_should_rebuild_rebulk_on_advanced_config_change( mocker: MockerFixture): api.reset() rebulk_builder_spy = mocker.spy(api, 'rebulk_builder') string = "some.movie.trfr.mkv" result1 = default_api.guessit(string) assert result1.get('title') == 'some movie trfr' assert 'subtitle_language' not in result1 rebulk_builder_spy.assert_called_once_with(mocker.ANY) rebulk_builder_spy.reset_mock() result2 = default_api.guessit( string, {'advanced_config': { 'language': { 'subtitle_prefixes': ['tr'] } }}) assert result2.get('title') == 'some movie' assert str(result2.get('subtitle_language')) == 'fr' rebulk_builder_spy.assert_called_once_with(mocker.ANY) rebulk_builder_spy.reset_mock()
def test_passing_spot_crops_kwargs(self, adata: AnnData, cont: ImageContainer, mocker: MockerFixture): spy = mocker.spy(cont, "generate_spot_crops") calculate_image_features(adata, cont, mask_circle=True) spy.assert_called_once() call = spy.call_args_list[0] assert call[-1]["mask_circle"]
def test_report_plain_message( mocker: MockerFixture, result: CommandResult, subject: str, body: str, ) -> None: from_addr = Address("Command Reporter", addr_spec="*****@*****.**") to_addrs = [Address("Re Cipient", addr_spec="*****@*****.**")] reporter = CommandReporter( encoding="utf-8", failure_only=False, from_addr=from_addr, mime_type=None, nonempty=False, stderr_encoding="utf-8", stdout_filename=None, to_addrs=to_addrs, utc=False, ) show_argv_spy = mocker.spy(util, "show_argv") msg = reporter.report(result) assert isinstance(msg, DraftMessage) assert attr.asdict(msg) == { "to_addrs": to_addrs, "subject": subject, "from_addr": from_addr, "parts": [body], } show_argv_spy.assert_called_once_with(*result.argv)
def test_delete_instance_mismatch( mocker: MockerFixture, monkeypatch: pytest.MonkeyPatch, text_dandiset: SampleDandiset, ) -> None: monkeypatch.chdir(text_dandiset.dspath) monkeypatch.setenv("DANDI_API_KEY", text_dandiset.api.api_key) instance = text_dandiset.api.instance_id dandiset_id = text_dandiset.dandiset_id delete_spy = mocker.spy(RESTFullAPIClient, "delete") for paths in [ [ "subdir1/apple.txt", f"dandi://dandi/{dandiset_id}/subdir2/coconut.txt", ], [ f"dandi://{instance}/{dandiset_id}/subdir2/coconut.txt", f"dandi://dandi/{dandiset_id}/subdir1/apple.txt", ], ]: with pytest.raises(ValueError) as excinfo: delete(paths, dandi_instance=instance, devel_debug=True, force=True) assert (str(excinfo.value) == "Cannot delete assets from multiple API instances at once") delete_spy.assert_not_called()
def test_reconnect(mockdb: MockMySqlDB, mocker: MockerFixture): db = mockdb.db spy = mocker.spy(db, "connect") mockdb.reconnect() assert db.close.called_once() assert spy.called_once()
def test_get_many_pages_of_assets(mocker: MockerFixture, new_dandiset: SampleDandiset) -> None: new_dandiset.client.page_size = 4 get_spy = mocker.spy(new_dandiset.client, "get") paths: List[str] = [] for i in range(26): p = new_dandiset.dspath / f"{i:04}.txt" paths.append(p.name) p.write_text(f"File #{i}\n") df = dandi_file(p, new_dandiset.dspath) assert isinstance(df, GenericAsset) df.upload(new_dandiset.dandiset, {"description": f"File #{i}"}) assert [ asset.path for asset in new_dandiset.dandiset.get_assets(order="path") ] == paths assert get_spy.call_count == 7 pth = f"{new_dandiset.dandiset.version_api_path}assets/" get_spy.assert_any_call(pth, params={ "order": "path", "page_size": 4 }, json_resp=False) for n in range(2, 8): get_spy.assert_any_call(pth, params={ "order": "path", "page_size": 4, "page": n })
def test_database_connect(mocker: MockerFixture): db = MysqldbDatabase("loc", "user", "password", "database") mocker.patch.object(MySQLdb, "connect") query = mocker.MagicMock() query.return_value = [] mocker.patch.object(db, "query", query) db.connect() MySQLdb.connect.assert_has_calls([ mocker.call( "loc", "user", "password", "database", use_unicode=True, charset="utf8mb4", ) ]) query.assert_has_calls([mocker.call("show", "tables")]) db.close() db.query = lambda a, b: [{"": "foo"}] if a == "show" else [] query_spy = mocker.spy(db, "query") mocker.patch.object(db, "query", query_spy) db.connect() query_spy.assert_has_calls( [mocker.call("show", "tables"), mocker.call("describe", "foo")]) assert "foo" in db.table_names
def test_upload_extant_old_refresh(mocker: MockerFixture, text_dandiset: SampleDandiset) -> None: (text_dandiset.dspath / "file.txt").write_text("This is different text.\n") os.utime(text_dandiset.dspath / "file.txt", times=(0, 0)) iter_upload_spy = mocker.spy(LocalFileAsset, "iter_upload") text_dandiset.upload(existing="refresh") iter_upload_spy.assert_not_called()
def test_calls_functions_correctly(self, mocker: MockerFixture) -> None: mocker.patch("panel.tasks.subtitles.requests", MockRequest) mocker.patch("panel.tasks.tests.mocks.MockRequest.text", "lalala") request_from_api = mocker.spy(panel.tasks.subtitles, "_request_from_api") _file_hash: str = "abc" _file_byte_size: int = 1000 _imdb_id: str = "tt01010101" _file_name: str = "video.mp4" _language: str = "eng" file_byte_size: str = f"/moviebytesize-{_file_byte_size}" file_hash: str = f"/moviehash-{_file_hash}" imdb_id = f"/imdbid-{_imdb_id[2:]}" _encoded_file_name: str = urllib.parse.quote(_file_name) file_name = f"/query-{_encoded_file_name}" language = f"/sublanguageid-{_language}" result = _get_response_from_api( file_hash=_file_hash, file_byte_size=_file_byte_size, imdb_id=_imdb_id, file_name=_file_name, language=_language, ) request_from_api.assert_any_call(OS_URL + imdb_id + language) request_from_api.assert_any_call(OS_URL + file_name + imdb_id + language) request_from_api.assert_any_call(OS_URL + file_byte_size + file_hash + imdb_id + language) assert result is None
def test_delete_nonexistent_asset_folder_skip_missing( mocker: MockerFixture, monkeypatch: pytest.MonkeyPatch, text_dandiset: SampleDandiset, tmp_path: Path, ) -> None: monkeypatch.setenv("DANDI_API_KEY", text_dandiset.api.api_key) instance = text_dandiset.api.instance_id dandiset_id = text_dandiset.dandiset_id delete_spy = mocker.spy(RESTFullAPIClient, "delete") delete( [ f"dandi://{instance}/{dandiset_id}/subdir1/", f"dandi://{instance}/{dandiset_id}/subdir3/", ], dandi_instance=instance, devel_debug=True, force=True, skip_missing=True, ) delete_spy.assert_called() download(text_dandiset.dandiset.version_api_url, tmp_path) assert list_paths(tmp_path) == [ tmp_path / dandiset_id / "dandiset.yaml", tmp_path / dandiset_id / "file.txt", tmp_path / dandiset_id / "subdir2" / "banana.txt", tmp_path / dandiset_id / "subdir2" / "coconut.txt", ]
def test_class_method_spy_autospec_false(mocker: MockerFixture) -> None: class Foo: @classmethod def bar(cls, arg): return arg * 2 spy = mocker.spy(Foo, "bar") spy.fake_assert_method()
def test_instantiating_task( self, profet_train_config: MetaModelConfig, profet_input_dir: Path, tmp_path_factory: TempPathFactory, checkpoint_dir: Path, mocker: MockerFixture, ): """Tests that when instantiating multiple tasks with the same arguments, the meta-model is trained only once. """ # Directory should be empty. assert len(list(checkpoint_dir.iterdir())) == 0 mocked_get_task_network = mocker.spy(profet_train_config, "get_task_network") mocked_load_task_network = mocker.spy(profet_train_config, "load_task_network") assert mocked_get_task_network.call_count == 0 assert mocked_load_task_network.call_count == 0 task_a = self.Task( model_config=profet_train_config, input_dir=profet_input_dir, checkpoint_dir=checkpoint_dir, ) assert mocked_get_task_network.call_count == 1 mocked_get_task_network.assert_called_once_with(input_path=task_a.input_dir) assert mocked_load_task_network.call_count == 0 # Directory should have one file (the trained model checkpoint). assert len(list(checkpoint_dir.iterdir())) == 1 task_b = self.Task( model_config=profet_train_config, input_dir=profet_input_dir, checkpoint_dir=checkpoint_dir, ) assert task_a.configuration == task_b.configuration assert task_a.checkpoint_file == task_b.checkpoint_file assert mocked_get_task_network.call_count == 1 assert mocked_load_task_network.call_count == 1 mocked_load_task_network.assert_called_once_with(task_b.checkpoint_file) # Directory should *still* only have one file (the trained model checkpoint). assert len(list(checkpoint_dir.iterdir())) == 1
def test_system_git_called_when_configured( mocker: MockerFixture, source_url: str, use_system_git_client: None) -> None: spy_legacy = mocker.spy(Git, "_clone_legacy") spy = mocker.spy(Git, "_clone") with Git.clone(url=source_url, branch="0.1") as repo: path = Path(repo.path) assert_version(repo, BRANCH_TO_REVISION_MAP["0.1"]) spy.assert_not_called() spy_legacy.assert_called_once() spy_legacy.assert_called_with( url=source_url, target=path, refspec=GitRefSpec(branch="0.1", revision=None, tag=None, ref=b"HEAD"), )
def test__save_session__called_on_session_set__should_respect_permanent_session_setting( permanent_session_app, mocker: MockerFixture): expiration_spy = mocker.spy(MongoEngineSessionInterface, "get_expiration_time") client = permanent_session_app.test_client() client.get("/") call_args, _ = expiration_spy.call_args_list[0] assert call_args[2].permanent is True # session object
def test_info_setup_complex_disable_build( mocker: MockerFixture, demo_setup_complex: Path ): spy = mocker.spy(VirtualEnv, "run") info = PackageInfo.from_directory(demo_setup_complex, disable_build=True) assert spy.call_count == 0 assert info.name == "demo" assert info.version == "0.1.0" assert info.requires_dist is None
def test_square_rendering(mocker: MockerFixture, renderer: Renderer) -> None: """Draw a square using raster and vector renderers.""" spy_renderer = mocker.spy(renderer, "render_square") square = Square(renderer, 2) square.draw() square.resize(3) square.draw() spy_renderer.assert_has_calls((mock.call(2), mock.call(6))) assert spy_renderer.call_count == 2
def test_upload_extant_neq_overwrite(existing: str, mocker: MockerFixture, text_dandiset: SampleDandiset, tmp_path: Path) -> None: (text_dandiset.dspath / "file.txt").write_text("This is different text.\n") iter_upload_spy = mocker.spy(LocalFileAsset, "iter_upload") text_dandiset.upload(existing=existing) iter_upload_spy.assert_called() download(text_dandiset.dandiset.version_api_url, tmp_path) assert (tmp_path / text_dandiset.dandiset_id / "file.txt").read_text() == "This is different text.\n"
def test_circle_rendering(mocker: MockerFixture, renderer: Renderer) -> None: """Draw a circle using raster and vector renderers.""" spy_renderer = mocker.spy(renderer, "render_circle") circle = Circle(renderer, 5) circle.draw() circle.resize(2) circle.draw() spy_renderer.assert_has_calls((mock.call(5), mock.call(10))) assert spy_renderer.call_count == 2
def test_configured_repository_http_auth( mocker: MockerFixture, source_url: str, config: Config ) -> None: from poetry.vcs.git import backend spy_clone_legacy = mocker.spy(Git, "_clone_legacy") spy_get_transport_and_path = mocker.spy(backend, "get_transport_and_path") config.merge( { "repositories": {"git-repo": {"url": source_url}}, "http-basic": { "git-repo": { "username": GIT_USERNAME, "password": GIT_PASSWORD, } }, } ) dummy_git_config = ConfigFile() mocker.patch( "poetry.vcs.git.backend.Repo.get_config_stack", return_value=dummy_git_config, ) mocker.patch( "poetry.vcs.git.backend.get_default_authenticator", return_value=Authenticator(config=config), ) with Git.clone(url=source_url, branch="0.1") as repo: assert_version(repo, BRANCH_TO_REVISION_MAP["0.1"]) spy_clone_legacy.assert_not_called() spy_get_transport_and_path.assert_called_with( location=source_url, config=dummy_git_config, username=GIT_USERNAME, password=GIT_PASSWORD, ) spy_get_transport_and_path.assert_called_once()
def test_mock_movielens_schema__get_spark_df__data_serialization_default_param( spark, mocker: MockerFixture ): data_size = 3 to_csv_spy = mocker.spy(pandas.DataFrame, "to_csv") df = MockMovielensSchema.get_spark_df(spark, size=data_size) # assertions to_csv_spy.assert_called_once() assert df.count() == data_size
def test_on_envelope_notification(self, mocker: MockerFixture) -> None: # Arrange channel = self.__get_target() notification = Notification(NotificationEvent.CONSUMED) spy = mocker.spy(channel, 'on_notification') # Act channel.on_envelope(notification.to_json()) # Assert spy.assert_called_once_with(notification)
def test_on_envelope_session(self, mocker: MockerFixture) -> None: # Arrange channel = self.__get_target() session = Session(SessionState.FINISHED) spy = mocker.spy(channel, 'on_session') # Act channel.on_envelope(session.to_json()) # Assert spy.assert_called_once_with(session)