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)
