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()