def test_get_vault_client_vault_token_priority_file_config(
mocker: MockerFixture, monkeypatch: MonkeyPatch,
mock_vault_token_from_file: str) -> None:
"""
.vault-token file should be preferred over value in Config class
"""
class Settings(BaseSettings):
class Config:
vault_url: str = "https://vault.tld"
vault_token: str = "fake-token-from-config"
settings = Settings()
vault_client_mock = mocker.patch(
"pydantic_vault.vault_settings.HvacClient")
_get_authenticated_vault_client(settings)
vault_client_mock.assert_called_once_with("https://vault.tld",
token=mock_vault_token_from_file)
def test_delete_zarr_path(
mocker: MockerFixture,
monkeypatch: pytest.MonkeyPatch,
zarr_dandiset: SampleDandiset,
tmp_path: Path,
) -> None:
monkeypatch.chdir(zarr_dandiset.dspath)
monkeypatch.setenv("DANDI_API_KEY", zarr_dandiset.api.api_key)
instance = zarr_dandiset.api.instance_id
delete_spy = mocker.spy(RESTFullAPIClient, "delete")
delete(["sample.zarr"],
dandi_instance=instance,
devel_debug=True,
force=True)
delete_spy.assert_called()
download(zarr_dandiset.dandiset.version_api_url, tmp_path)
assert list_paths(tmp_path) == [
tmp_path / zarr_dandiset.dandiset_id / "dandiset.yaml"
]
def test_fetch_forecast_group(mocker: MockerFixture) -> None:
requests_mock = mocker.patch('requests.get')
requests_mock.return_value = OpenWeatherResponseGroup()
expected_result = {
'London': {
'main': 'Rain',
'description': 'light rain',
'current_temp': 10.37,
'min_temp': 10,
'max_temp': 11.11,
'feels_like': 8.41,
'humidity': 93,
'pressure': 1015,
'wind_speed': 2.6,
'wind_direction': 220,
'clouds': 75,
'city_name': 'London',
'country': 'GB',
'forecast_time': datetime.datetime(2020, 10, 12, 18, 11, 16, tzinfo=datetime.timezone.utc),
'sunrise_time': datetime.datetime(2020, 10, 12, 6, 19, 46, tzinfo=datetime.timezone.utc),
'sunset_time': datetime.datetime(2020, 10, 12, 17, 13, 44, tzinfo=datetime.timezone.utc)
},
'Boston': {
'main': 'Clouds',
'description': 'overcast clouds',
'current_temp': 12.15,
'min_temp': 11.11,
'max_temp': 12.78,
'feels_like': 4.95,
'humidity': 62,
'pressure': 1027,
'wind_speed': 8.7,
'wind_direction': 70,
'clouds': 90,
'city_name': 'Boston',
'country': 'US',
'forecast_time': datetime.datetime(2020, 10, 12, 18, 13, 51, tzinfo=datetime.timezone.utc),
'sunrise_time': datetime.datetime(2020, 10, 12, 10, 53, 58, tzinfo=datetime.timezone.utc),
'sunset_time': datetime.datetime(2020, 10, 12, 22, 6, 53, tzinfo=datetime.timezone.utc)
}
}
actual_result = get_city_forecast([2643743, 4930956], ForecastType.MULTIPLE)
assert expected_result == actual_result
def test_log_df(basic_df: pd.DataFrame, mocker: MockerFixture) -> None:
@df_log()
def test_fn(foo_df: pd.DataFrame) -> pd.DataFrame:
return basic_df
mock_log = mocker.patch("daffy.decorators.logging.log")
test_fn(basic_df)
mock_log.assert_has_calls([
call(
logging.DEBUG,
("Function test_fn parameters contained a DataFrame: columns: ['Brand', 'Price']"
),
),
call(
logging.DEBUG,
"Function test_fn returned a DataFrame: columns: ['Brand', 'Price']",
),
])
def test_only_inside_image(mocker: MockerFixture):
spy = mocker.MagicMock()
class TestCanvas:
image_extent = (100, 100, 200, 200)
@only_inside_image
def test_method(self, x, y):
spy(x, y)
def canvas_to_image_coordinates(self, xy):
return xy[0] - 100, xy[1] - 100
test_canvas = TestCanvas()
test_canvas.test_method(0, 0)
spy.assert_not_called()
test_canvas.test_method(150, 150)
spy.assert_called_once_with(50, 50)
def test_config_repos_wrong_token(
mock_prompt_inquirer_prompter: MockerFixture,
mock_github_service: MockerFixture,
mock_config_manager: MockerFixture,
runner: CliRunner,
) -> None:
"""It executes _get_github_service with token error."""
mock_config_manager.config_is_empty.return_value = False
mock_prompt_inquirer_prompter.new_repos.return_value = True
mock_github_service.side_effect = AttributeError
result = runner.invoke(
git_portfolio.__main__.configure, ["repos"], prog_name="gitp"
)
assert result.output.startswith(
"Error(s) found during execution:\nWrong GitHub permissions. Please check your"
" token.\n"
)
assert type(result.exception) == SystemExit
def test_process_profile_pia(mocker: MockerFixture) -> None:
"""Test process_profile() with PIA flag."""
process_pia_spy = mocker.patch("paranoid_openvpn.main.process_pia", wraps=process_pia)
test_config = OVPNConfig([Parameter("cipher", "aes-256-cbc")])
process_profile(test_config, TLSVersion.v1_3, ProviderExtensions.PIA)
process_pia_spy.assert_called()
assert (
test_config["tls-cipher"].value
== "TLS-ECDHE-ECDSA-WITH-AES-256-GCM-SHA384:TLS-ECDHE-ECDSA-WITH-CHACHA20-POLY1305-SHA256:TLS-ECDHE-ECDSA-WITH-AES-256-CBC-SHA384" # noqa: E501
)
assert test_config["tls-groups"].value == "secp521r1:X448:secp384r1:secp256r1:X25519"
assert test_config["tls-ciphersuites"].value == "TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256"
assert test_config["tls-version-min"].value == "1.3 or-highest"
assert test_config["cipher"].value == "AES-256-GCM"
assert "ncp-disable" in test_config
assert test_config["data-ciphers"].value == "AES-256-GCM:CHACHA20-POLY1305:AES-256-CBC"
def test_send_login_code(client: GraphQLClient, email: str,
mocker: MockerFixture):
mocker.patch("blog_app.adapters.auth0.Auth0Authenticator.send_login_code"
).return_value = Result(value=None)
result = client.execute(
"""
mutation sendLoginCode($email: String!) {
sendLoginCode(emailAddress: $email) {
... on SendLoginCodeResponse {
emailAddress
}
}
}
""",
variables={"email": email},
)
assert result.get("errors") is None
assert result["data"] == {"sendLoginCode": {"emailAddress": email}}
def test_hourly_actuals_job_fail(mocker: MockerFixture, monkeypatch,
mock_requests_session): # pylint: disable=unused-argument
"""
Test that when the bot fails, a message is sent to rocket-chat, and our exit code is 1.
"""
def mock_get_hourly_readings(self, filename: str):
raise Exception()
monkeypatch.setattr(wfwx_api, 'get_hourly_readings',
mock_get_hourly_readings)
rocket_chat_spy = mocker.spy(hourly_actuals,
'send_rocketchat_notification')
with pytest.raises(SystemExit) as excinfo:
hourly_actuals.main()
# Assert that we exited with an error code.
assert excinfo.value.code == os.EX_SOFTWARE
# Assert that rocket chat was called.
assert rocket_chat_spy.call_count == 1
def test_update_count(
self,
mocker: MockerFixture,
top_button: TopButton,
old_count: int,
new_count: int,
new_count_str: str,
text_color: Optional[str],
) -> None:
top_button.count = old_count
top_button_update_widget = mocker.patch(MODULE +
".TopButton.update_widget")
top_button.update_count(new_count, text_color)
top_button_update_widget.assert_called_once_with(
(top_button.count_style, new_count_str),
text_color,
)
def test_getCsvData(mocker: MockerFixture) -> None:
mocker.patch("tableauscraper.api.getTableauViz",
return_value=tableauVizHtmlResponse)
mocker.patch("tableauscraper.api.getTableauData",
return_value=tableauDataResponse)
mocker.patch("tableauscraper.api.getCsvData",
return_value=tableauDownloadableCsvData)
ts = TS()
ts.loads(fakeUri)
wb = ts.getWorkbook()
data = wb.getCsvData("[WORKSHEET1]")
assert data.shape[0] == 3
assert data.shape[1] == 1
def test_updates_manual_with_failures(update_handler: UpdateHandler,
package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must process through the packages with failure
"""
mocker.patch("pathlib.Path.iterdir", return_value=[package_ahriman.base])
mocker.patch(
"ahriman.core.repository.update_handler.UpdateHandler.packages",
return_value=[])
mocker.patch("ahriman.models.package.Package.load",
side_effect=Exception())
assert update_handler.updates_manual() == []
def test_goToStoryPoint(mocker: MockerFixture) -> None:
mocker.patch("tableauscraper.api.getTableauViz",
return_value=tableauVizHtmlResponse)
mocker.patch("tableauscraper.api.getTableauData",
return_value=tableauDataResponseWithStoryPointsNav)
mocker.patch("tableauscraper.api.setActiveStoryPoint",
return_value=vqlCmdResponse)
ts = TS()
ts.loads(fakeUri)
wb = ts.getWorkbook()
storyWb = wb.goToStoryPoint(storyPointId=1)
assert type(storyWb) is TableauWorkbook
assert len(storyWb.worksheets) == 1
def test_getDownloadableUnderlyingData(mocker: MockerFixture) -> None:
mocker.patch("tableauscraper.api.getTableauViz",
return_value=tableauVizHtmlResponse)
mocker.patch("tableauscraper.api.getTableauData",
return_value=tableauDataResponse)
mocker.patch("tableauscraper.api.getDownloadableUnderlyingData",
return_value=json.loads(tableauDownloadableUnderlyingData))
ts = TS()
ts.loads(fakeUri)
wb = ts.getWorkbook()
data = wb.getWorksheet("[WORKSHEET1]").getDownloadableUnderlyingData()
assert data.shape[0] == 200
assert data.shape[1] == 42
def test_run_with_updates(args: argparse.Namespace, configuration: Configuration, mocker: MockerFixture) -> None:
"""
must run command with updates after
"""
args = _default_args(args)
args.now = True
mocker.patch("pathlib.Path.mkdir")
mocker.patch("ahriman.application.application.Application.add")
application_mock = mocker.patch("ahriman.application.application.Application.update")
updates_mock = mocker.patch("ahriman.application.application.Application.get_updates")
Add.run(args, "x86_64", configuration)
application_mock.assert_called_once()
updates_mock.assert_called_once()
def test_creates_movie_torrent(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")
movie_content: MovieContent = MovieContentFactory()
MovieFactory.create(movie_content=[movie_content])
assert not MovieTorrent.objects.filter(
movie_content=movie_content).exists()
download_torrent(movie_content_id=movie_content.id)
assert MovieTorrent.objects.filter(
movie_content=movie_content).exists()
def test_TableauScraper_loadsWithPlaceholder(mocker: MockerFixture) -> None:
mocker.patch("tableauscraper.api.getTableauViz",
return_value=tableauPlaceHolderData)
mocker.patch("tableauscraper.api.getTableauVizForSession",
return_value=tableauVizHtmlResponse)
mocker.patch("tableauscraper.api.getTableauData",
return_value=tableauDataResponse)
ts = TS()
ts.loads(fakeUri)
assert "vizql_root" in ts.__dict__["tableauData"]
assert "sessionid" in ts.__dict__["tableauData"]
assert "sheetId" in ts.__dict__["tableauData"]
assert ts.__dict__["data"] == data
assert ts.__dict__["info"] == info
def test_call(args: argparse.Namespace, mocker: MockerFixture) -> None:
"""
must call inside lock
"""
args.configuration = Path("")
args.no_log = False
mocker.patch("ahriman.application.handlers.Handler.run")
mocker.patch("ahriman.core.configuration.Configuration.from_path")
enter_mock = mocker.patch("ahriman.application.lock.Lock.__enter__")
exit_mock = mocker.patch("ahriman.application.lock.Lock.__exit__")
assert Handler._call(args, "x86_64")
enter_mock.assert_called_once()
exit_mock.assert_called_once()
def test_report_utc(mocker: MockerFixture) -> None:
from_addr = Address("Command Reporter", addr_spec="*****@*****.**")
to_addrs = [Address("Re Cipient", addr_spec="*****@*****.**")]
result = CommandResult(
argv=["foo", "-x", "bar.txt"],
rc=0,
start=datetime(2020, 3, 10, 15, 0, 28, 123456, w4),
end=datetime(2020, 3, 10, 15, 1, 27, 654321, w4),
stdout=b"This is the output.\n",
stderr=b"",
)
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=True,
)
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":
"[DONE] foo -x bar.txt",
"from_addr":
from_addr,
"parts": [
"Start Time: 2020-03-10 19:00:28.123456Z\n"
"End Time: 2020-03-10 19:01:27.654321Z\n"
"Exit Status: 0\n"
"\n"
"Output:\n"
"> This is the output.\n",
],
}
show_argv_spy.assert_called_once_with(*result.argv)
def test_with_testrun(
self,
test_testrun_view: TestRunView,
mocker: MockerFixture,
column_name: str,
test_feature_id: int,
test_feature_name: str,
) -> None:
assert feature_link_formatter(
view=test_testrun_view,
context=mocker.MagicMock(),
model=db.TestRun(
**{
column_name: test_feature_name,
"scenario": db.Scenario(feature_id=test_feature_id)
} # type: ignore
),
name=column_name,
) == get_feature_link_markup(feature_id=test_feature_id,
feature_name=test_feature_name)
def test_with_draft(
self,
test_draft_view: DraftView,
mocker: MockerFixture,
column_name: str,
test_feature_id: int,
test_feature_name: str,
) -> None:
assert draft_feature_formatter(
view=test_draft_view,
context=mocker.MagicMock(),
model=db.Draft(
**{
column_name: test_feature_id,
"feature": db.Feature(name=test_feature_name)
} # type: ignore
),
name=column_name,
) == get_feature_link_markup(feature_id=test_feature_id,
feature_name=test_feature_name)
def test_getParameterControl(mocker: MockerFixture) -> None:
ts = TS()
mocker.patch("builtins.input", side_effect=["0", "0", ""])
mocker.patch("tableauscraper.api.setParameterValue", return_value=vqlCmdResponse)
tableauDataFrameGroup = parameterControl.get(ts, info, ts.logger)
assert type(tableauDataFrameGroup) is TableauDashboard
assert len(tableauDataFrameGroup.worksheets) == 1
assert tableauDataFrameGroup.worksheets[0].name == "[WORKSHEET1]"
assert tableauDataFrameGroup.worksheets[0].data.shape[0] == 4
assert tableauDataFrameGroup.worksheets[0].data.shape[1] == 2
assert list(tableauDataFrameGroup.worksheets[0].data.columns.values) == [
"[FIELD1]-value",
"[FIELD2]-alias",
]
# no input parameter control
mocker.patch("builtins.input", side_effect=["", "0", ""])
pytest.raises(Exception, parameterControl.get, ts, info, ts.logger)
# no input value
mocker.patch("builtins.input", side_effect=["0", "", ""])
pytest.raises(Exception, parameterControl.get, ts, info, ts.logger)
def test_prune_folder_dry_run_output(mocker: MockerFixture, capsys):
fs = MockFilesystem({"some_path"})
files = {
MetainfoFile({
"info_hash": "aaa",
"name": "some_name"
}, Path("/some_path"))
}
service: PruneService = mocker.Mock(spec=PruneService)
service.get_torrent_hashes.return_value = {"aaa", "bbb"}
command = PruneFolderCommand(service, fs, files)
output = command.dry_run()
output.dry_run_display()
result = capsys.readouterr().out
assert (result == "\n".join([
"The following metainfo files would be removed:",
"some_name at /some_path",
]) + "\n")
def test_handle_parameters(self, mocker: MockerFixture,
runway_context: MockRunwayContext,
tmp_path: Path) -> None:
"""Test handle_parameters."""
mock_update_envvars = mocker.patch(
f"{MODULE}.update_env_vars_with_tf_var_values",
return_value={"result": "success"},
)
obj = Terraform(runway_context.copy(), module_root=tmp_path)
mocker.patch.object(
obj, "auto_tfvars",
MagicMock(exists=MagicMock(side_effect=[True, False])))
assert not obj.handle_parameters()
mock_update_envvars.assert_not_called()
assert not obj.handle_parameters()
mock_update_envvars.assert_called_once_with(runway_context.env.vars,
{})
assert obj.ctx.env.vars == {"result": "success"}
def test_execute_with_filters(
mocker: MockerFixture,
mock_config_manager: MockerFixture,
mock_github_service: MockerFixture,
domain_issues: List[i.Issue],
) -> None:
"""It returns a list of issues."""
repo = mocker.Mock()
config_manager = mock_config_manager.return_value
github_service = mock_github_service.return_value
github_service.list_issues_from_repo.return_value = domain_issues
qry_filters = {"state__eq": "open"}
request = il.build_list_request(filters=qry_filters)
response = li.GhListIssueUseCase(config_manager,
github_service).execute(request, repo)
assert bool(response) is True
assert response.value == domain_issues
def test_execute_handles_bad_request(
mocker: MockerFixture,
mock_config_manager: MockerFixture,
mock_github_service: MockerFixture,
) -> None:
"""It returns a parameters error."""
repo = mocker.Mock()
config_manager = mock_config_manager.return_value
github_service = mock_github_service.return_value
request = il.build_list_request(filters=5) # type: ignore
response = li.GhListIssueUseCase(config_manager,
github_service).execute(request, repo)
assert bool(response) is False
assert response.value == {
"type": res.ResponseTypes.PARAMETERS_ERROR,
"message": "filters: Is not iterable",
}
def test_allergy_transform(dir: TempDirectory, mocker: MockerFixture) -> None:
""" Tests the allergy transform """
with open("tests/resources/allergy.csv") as f_csv, open(dir.getpath("allergy.json"), "w") as f_json:
allergyToJson = AllergyToJson()
spy = mocker.spy(allergyToJson, 'transform')
allergyToJson.csv_to_json(f_csv, f_json)
assert spy.spy_return
assert spy.spy_return["patient"]["birth_date"] == "19500701143000"
assert len(spy.spy_return["allergys"]) == 1
assert spy.spy_return["allergys"][0]["onset"] == "20180724"
with open(dir.getpath("allergy.json")) as f_json:
lines = f_json.readlines()
assert len(lines) == 1
_json = json.loads(lines[0])
assert _json["patient"]["birth_date"] == "19500701143000"
assert _json["allergys"][0]["onset"] == "20180724"
def test_problem_transform(dir: TempDirectory, mocker: MockerFixture) -> None:
""" Tests the problem transform """
with open("tests/resources/problem.csv") as f_csv, open(dir.getpath("problem.json"), "w") as f_json:
problemToJson = ProblemToJson()
spy = mocker.spy(problemToJson, 'transform')
problemToJson.csv_to_json(f_csv, f_json)
assert spy.spy_return
assert spy.spy_return["patient"]["birth_date"] == "19500701143000"
assert len(spy.spy_return["problems"]) == 1
assert spy.spy_return["problems"][0]["annotated_display"] == "This is the annotated display."
with open(dir.getpath("problem.json")) as f_json:
lines = f_json.readlines()
assert len(lines) == 1
_json = json.loads(lines[0])
assert _json["patient"]["birth_date"] == "19500701143000"
assert _json["problems"][0]["annotated_display"] == "This is the annotated display."
def mocked_director_v2_with_error(
mocker: MockerFixture, faker: Faker,
director_v2_error: Type[DirectorServiceError]):
mocked_director_v2_api = mocker.patch(
"simcore_service_webserver.clusters.handlers.director_v2_api",
autospec=True)
error = director_v2_error(
status=web.HTTPServiceUnavailable.status_code,
reason="no director-v2",
url=faker.uri(),
cluster_id=faker.pyint(min_value=1),
endpoint=faker.uri(),
)
mocked_director_v2_api.create_cluster.side_effect = error
mocked_director_v2_api.list_clusters.side_effect = error
mocked_director_v2_api.get_cluster.side_effect = error
mocked_director_v2_api.get_cluster_details.side_effect = error
mocked_director_v2_api.update_cluster.side_effect = error
mocked_director_v2_api.delete_cluster.side_effect = error
mocked_director_v2_api.ping_cluster.side_effect = error
def test_set_versions(mocker: MockerFixture) -> None:
for success in [True, False]:
_mock_sys_argv_arguments(mocker)
fail_mock: MagicMock = _mock_cli_fail(mocker)
patch_mock: MagicMock = mocker.patch(
"terraform_manager.entities.terraform.Terraform.set_versions",
return_value=success)
desired_version = "0.13.5"
_mock_fetch_workspaces(mocker, [_test_workspace1])
_mock_parsed_arguments(
mocker, _arguments({"terraform_version": desired_version}))
_mock_get_group_arguments(mocker)
main()
patch_mock.assert_called_once_with(desired_version)
if success:
fail_mock.assert_not_called()
else:
fail_mock.assert_called_once()
