def test_eth_ticker( empty_proxy: PaywalledProxy, session: Session, sender_privkey: str, receiver_privkey: str, monkeypatch: MonkeyPatch ): def get_patched(*args, **kwargs): body = { 'mid': '682.435', 'bid': '682.18', 'ask': '682.69', 'last_price': '683.16', 'low': '532.97', 'high': '684.0', 'volume': '724266.25906224', 'timestamp': '1513167820.721733' } return jsonify(body) monkeypatch.setattr(PaywalledProxyUrl, 'get', get_patched) ETHTickerProxy(receiver_privkey, proxy=empty_proxy) ticker = ETHTickerClient(sender_privkey, session=session, poll_interval=0.5) def post(): ticker.close() assert ticker.pricevar.get() == '683.16 USD' assert len(session.client.get_open_channels()) == 0 ticker.success = True session.close_channel_on_exit = True ticker.success = False ticker.root.after(1500, post) ticker.run() assert ticker.success
def _prepare(self): self.counters = {} basename = None cli_tempdir_basename = self.config.getvalue('tempdir_basename') if cli_tempdir_basename is not None: basename = cli_tempdir_basename else: # Let's see if we have a pytest_tempdir_basename hook implementation basename = self.config.hook.pytest_tempdir_basename() if basename is None: # If by now, basename is still None, use the current directory name basename = os.path.basename(py.path.local().strpath) # pylint: disable=no-member mpatch = MonkeyPatch() temproot = py.path.local.get_temproot() # pylint: disable=no-member # Let's get the full real path to the tempdir tempdir = temproot.join(basename).realpath() if tempdir.exists(): # If it exists, it's a stale tempdir. Remove it log.warning('Removing stale tempdir: %s', tempdir.strpath) tempdir.remove(rec=True, ignore_errors=True) # Make sure the tempdir is created tempdir.ensure(dir=True) # Store a reference the tempdir for cleanup purposes when ending the test # session mpatch.setattr(self.config, '_tempdir', self, raising=False) # Register the cleanup actions self.config._cleanup.extend([ mpatch.undo, self._clean_up_tempdir ]) self.tempdir = tempdir
def test_issue156_undo_staticmethod(Sample): monkeypatch = MonkeyPatch() monkeypatch.setattr(Sample, "hello", None) assert Sample.hello is None monkeypatch.undo() assert Sample.hello()
def test_client_private_key_path( patched_contract, monkeypatch: MonkeyPatch, sender_privkey: str, tmpdir: LocalPath, web3: Web3, channel_manager_address: str ): def check_permission_safety_patched(path: str): return True monkeypatch.setattr( microraiden.utils.private_key, 'check_permission_safety', check_permission_safety_patched ) privkey_file = tmpdir.join('private_key.txt') privkey_file.write(sender_privkey) with pytest.raises(AssertionError): Client( private_key='0xthis_is_not_a_private_key', channel_manager_address=channel_manager_address, web3=web3 ) with pytest.raises(AssertionError): Client( private_key='0xcorrect_length_but_still_not_a_private_key_12345678901234567', channel_manager_address=channel_manager_address, web3=web3 ) with pytest.raises(AssertionError): Client( private_key='/nonexisting/path', channel_manager_address=channel_manager_address, web3=web3 ) Client( private_key=sender_privkey, channel_manager_address=channel_manager_address, web3=web3 ) Client( private_key=sender_privkey[2:], channel_manager_address=channel_manager_address, web3=web3 ) Client( private_key=str(tmpdir.join('private_key.txt')), channel_manager_address=channel_manager_address, web3=web3 )
def pytest_configure(config): """Create a TempdirFactory and attach it to the config object. This is to comply with existing plugins which expect the handler to be available at pytest_configure time, but ideally should be moved entirely to the tmpdir_factory session fixture. """ mp = MonkeyPatch() t = TempdirFactory(config) config._cleanup.extend([mp.undo, t.finish]) mp.setattr(config, '_tmpdirhandler', t, raising=False) mp.setattr(pytest, 'ensuretemp', t.ensuretemp, raising=False)
def pytest_configure(self, config): if not config.getoption('ast_as_python'): return mp = MonkeyPatch() mp.setattr( '_pytest.assertion.rewrite.rewrite_asserts', make_replacement_rewrite_asserts(self.store)) # written pyc files will bypass our patch, so disable reading them mp.setattr( '_pytest.assertion.rewrite._read_pyc', lambda source, pyc, trace=None: None) config._cleanup.append(mp.undo)
def block_unmocked_requests(): """ Prevents requests from being made unless they are mocked. Helps avoid inadvertent dependencies on external resources during the test run. """ def mocked_send(*args, **kwargs): raise RuntimeError('Tests must mock all HTTP requests!') # The standard monkeypatch fixture cannot be used with session scope: # https://github.com/pytest-dev/pytest/issues/363 monkeypatch = MonkeyPatch() # Monkeypatching here since any higher level would break responses: # https://github.com/getsentry/responses/blob/0.5.1/responses.py#L295 monkeypatch.setattr('requests.adapters.HTTPAdapter.send', mocked_send) yield monkeypatch monkeypatch.undo()
def test_delattr(): class A: x = 1 monkeypatch = MonkeyPatch() monkeypatch.delattr(A, 'x') assert not hasattr(A, 'x') monkeypatch.undo() assert A.x == 1 monkeypatch = MonkeyPatch() monkeypatch.delattr(A, 'x') pytest.raises(AttributeError, "monkeypatch.delattr(A, 'y')") monkeypatch.delattr(A, 'y', raising=False) monkeypatch.setattr(A, 'x', 5, raising=False) assert A.x == 5 monkeypatch.undo() assert A.x == 1
def test_delattr(): class A(object): x = 1 monkeypatch = MonkeyPatch() monkeypatch.delattr(A, "x") assert not hasattr(A, "x") monkeypatch.undo() assert A.x == 1 monkeypatch = MonkeyPatch() monkeypatch.delattr(A, "x") pytest.raises(AttributeError, "monkeypatch.delattr(A, 'y')") monkeypatch.delattr(A, "y", raising=False) monkeypatch.setattr(A, "x", 5, raising=False) assert A.x == 5 monkeypatch.undo() assert A.x == 1
def test_model_finetuning_nlu( tmp_path: Path, monkeypatch: MonkeyPatch, trained_nlu_moodbot_path: Text, use_latest_model: bool, ): mocked_nlu_training = AsyncMock(return_value="") monkeypatch.setattr(rasa.nlu, rasa.nlu.train.__name__, mocked_nlu_training) mock_interpreter_create = Mock(wraps=Interpreter.create) monkeypatch.setattr(Interpreter, "create", mock_interpreter_create) mock_DIET_load = Mock(wraps=DIETClassifier.load) monkeypatch.setattr(DIETClassifier, "load", mock_DIET_load) (tmp_path / "models").mkdir() output = str(tmp_path / "models") if use_latest_model: trained_nlu_moodbot_path = str(Path(trained_nlu_moodbot_path).parent) # Typically models will be fine-tuned with a smaller number of epochs than training # from scratch. # Fine-tuning will use the number of epochs in the new config. old_config = rasa.shared.utils.io.read_yaml_file( "examples/moodbot/config.yml") old_config["pipeline"][-1][EPOCHS] = 10 new_config_path = tmp_path / "new_config.yml" rasa.shared.utils.io.write_yaml(old_config, new_config_path) old_nlu = rasa.shared.utils.io.read_yaml_file( "examples/moodbot/data/nlu.yml") old_nlu["nlu"][-1]["examples"] = "-something else" new_nlu_path = tmp_path / "new_nlu.yml" rasa.shared.utils.io.write_yaml(old_nlu, new_nlu_path) train_nlu( str(new_config_path), str(new_nlu_path), domain="examples/moodbot/domain.yml", output=output, model_to_finetune=trained_nlu_moodbot_path, finetuning_epoch_fraction=0.2, ) assert mock_interpreter_create.call_args[1]["should_finetune"] mocked_nlu_training.assert_called_once() _, nlu_train_kwargs = mocked_nlu_training.call_args model_to_finetune = nlu_train_kwargs["model_to_finetune"] assert isinstance(model_to_finetune, Interpreter) _, diet_kwargs = mock_DIET_load.call_args assert diet_kwargs["should_finetune"] is True new_diet_metadata = model_to_finetune.model_metadata.metadata["pipeline"][ -1] assert new_diet_metadata["name"] == "DIETClassifier" assert new_diet_metadata[EPOCHS] == 2
async def test_fail_on_prediction_errors( monkeypatch: MonkeyPatch, tmp_path: Path, _train_rule_based_agent: Callable[[Path, bool], Coroutine], ): monkeypatch.setattr( DefaultPolicyPredictionEnsemble, "combine_predictions_from_kwargs", _probabilities_with_action_unlikely_intent_for(["mood_unhappy"]), ) file_name = tmp_path / "test_action_unlikely_intent_2.yml" file_name.write_text(f""" version: "{LATEST_TRAINING_DATA_FORMAT_VERSION}" stories: - story: unlikely path (with action_unlikely_intent) steps: - user: | very terrible intent: mood_unhappy - action: utter_cheer_up - action: action_unlikely_intent - action: utter_did_that_help - intent: affirm - action: utter_happy """) # We train on the above story so that RulePolicy can memorize # it and we don't have to worry about other actions being # predicted correctly. agent = await _train_rule_based_agent(file_name, False) with pytest.raises(rasa.core.test.WrongPredictionException): await rasa.core.test.test( str(file_name), agent, out_directory=str(tmp_path), fail_on_prediction_errors=True, )
def test_forecast_model_raises_configuration_exception( monkeypatch: MonkeyPatch) -> None: mock_model_config = Mock( spec=BaseModelConfig, DEFAULT_HYPER_PARAMS=BaseModelConfig.DEFAULT_HYPER_PARAMS, HYPER_SPACE=BaseModelConfig.HYPER_SPACE, OVERRIDE_HYPER_PARAMS={}, ) mock_time_series = Mock(spec=TimeSeries) monkeypatch.setattr(H2OGradientBoostingModel, "train", Mock(side_effect=ValueError("Test Value Error"))) with pytest.raises( ConfigurationException, match= ".*Please check configuration of --prediction-start-month or --prediction-end-month.", ): forecast.forecast_model(mock_model_config, mock_time_series, Mock(spec=DataOutput), optimize_hyperparameters=False)
def readline_param(request): m = MonkeyPatch() if request.param == "pyrepl": old_stdin = sys.stdin class fake_stdin: """Missing fileno() to skip pyrepl.readline._setup. This is required to make tests not hang without capturing (`-s`).""" sys.stdin = fake_stdin() try: import pyrepl.readline # noqa: F401 except ImportError as exc: pytest.skip(msg="pyrepl not available: {}".format(exc)) finally: sys.stdin = old_stdin m.setattr("fancycompleter.DefaultConfig.prefer_pyrepl", True) else: m.setattr("fancycompleter.DefaultConfig.prefer_pyrepl", False) return request.param
def test_ensure_schema_exists( monkeypatch: MonkeyPatch, is_postgres: bool, schema_env: Optional[Text], schema_exists: bool, raises_context: ContextManager, ): set_or_delete_postgresql_schema_env_var(monkeypatch, schema_env) monkeypatch.setattr( rasa.core.tracker_store, "is_postgresql_url", lambda _: is_postgres ) monkeypatch.setattr(sqlalchemy, "exists", Mock()) # mock the `session.query().scalar()` query which returns whether the schema # exists in the db scalar = Mock(return_value=schema_exists) query = Mock(scalar=scalar) session = Mock() session.query = Mock(return_value=query) with raises_context: rasa.core.tracker_store.ensure_schema_exists(session)
def test_no_interactive_without_core_data(default_stack_config: Text, monkeypatch: MonkeyPatch) -> None: parser = argparse.ArgumentParser() sub_parser = parser.add_subparsers() interactive.add_subparser(sub_parser, []) args = parser.parse_args([ "interactive", "--config", default_stack_config, "--data", DEFAULT_NLU_DATA ]) interactive._set_not_required_args(args) mock = Mock() monkeypatch.setattr(train, "train", mock.train_model) monkeypatch.setattr(interactive, "perform_interactive_learning", mock.perform_interactive_learning) with pytest.raises(SystemExit): interactive.interactive(args) mock.train_model.assert_not_called() mock.perform_interactive_learning.assert_not_called()
def test_compare_structure_database(prepare_database: Iterator[None], cli_runner: CliRunner, monkeypatch: MonkeyPatch, caplog: LogCaptureFixture) -> None: def mock_get_expected_structure( test_parameters: forecast_structure. ExpectedForecastStructureParameters, ) -> DataFrameStructure: if test_parameters.account_name == "model_run_with_one_forecast_data_row": number_of_rows = 1 elif test_parameters.account_name == "model_run_with_zero_forecast_data_rows": number_of_rows = 0 else: assert False, "Inconsistent test setup, check test model names in fixture" return DataFrameStructure( columns=pd.Index(["0"], dtype="object"), dtypes=pd.Series([np.dtype("object")]), shape=(number_of_rows, 1), ) monkeypatch.setattr(compare_structure_database_helpers, "get_expected_forecast_structure", mock_get_expected_structure) monkeypatch.setattr(master_config, "model_configs", ["ModelConfigAccount1", "ModelConfigAccount2"]) # As we are always querying all values in dsx_write database, it is not easy to achieve # a reproducible consistent state for integration test. As a workaround the dsx outputs are not asserted here monkeypatch.setattr(compare_structure_database, "assert_dsx_output_count", Mock()) monkeypatch.setattr(compare_structure_database, "assert_dsx_output_total_sum", Mock()) result = cli_runner.invoke( compare_structure_database.compare_structure_database_command) assert result.exit_code == 0 assert "Asserted number of completed model_runs (2)" in caplog.messages assert any( re.search( r"Asserted forecast data count \(1\) for model_run_with_one_forecast_data_row.*", message) for message in caplog.messages) assert any( re.search( r"Asserted forecast data count \(0\) for model_run_with_zero_forecast_data_rows.*", message) for message in caplog.messages) assert re.search( r"All database entries for last production run have valid structure", result.output, re.MULTILINE)
async def test_correct_question_for_action_name_was_asked( monkeypatch: MonkeyPatch, mock_endpoint: EndpointConfig, action_name: Text, question: Text, is_marked_as_correct: bool, sent_action_name: Text, ): conversation_id = "conversation_id" policy = "policy" tracker = DialogueStateTracker.from_events("some_sender", []) monkeypatch.setattr( interactive, "retrieve_tracker", AsyncMock(return_value=tracker.current_state()), ) monkeypatch.setattr( interactive, "_ask_questions", AsyncMock(return_value=is_marked_as_correct) ) monkeypatch.setattr( interactive, "_request_action_from_user", AsyncMock(return_value=("action_another_one", False,)), ) mocked_send_action = AsyncMock() monkeypatch.setattr(interactive, "send_action", mocked_send_action) mocked_confirm = Mock(return_value=None) monkeypatch.setattr(interactive.questionary, "confirm", mocked_confirm) # validate the action and make sure that the correct question was asked await interactive._validate_action( action_name, policy, 1.0, [], mock_endpoint, conversation_id ) mocked_confirm.assert_called_once_with(question) args, kwargs = mocked_send_action.call_args_list[-1] assert args[2] == sent_action_name
def test_dockerfile_tmpdir_prefix(tmp_path: Path, monkeypatch: MonkeyPatch) -> None: """Test that DockerCommandLineJob.get_image respects temp directory directives.""" monkeypatch.setattr(target=subprocess, name="check_call", value=lambda *args, **kwargs: True) tmp_outdir_prefix = tmp_path / "1" assert DockerCommandLineJob.get_image( { "class": "DockerRequirement", "dockerFile": "FROM debian:stable", "dockerImageId": sys._getframe().f_code.co_name, }, pull_image=True, force_pull=True, tmp_outdir_prefix=str(tmp_outdir_prefix), ) children = sorted(tmp_outdir_prefix.parent.glob("*")) assert len(children) == 1 subdir = tmp_path / children[0] assert len(sorted(subdir.glob("*"))) == 1 assert (subdir / "Dockerfile").exists()
def test_custom_intent_symbol(text: Text, expected_tokens: List[Text], monkeypatch: MonkeyPatch): monkeypatch.setattr(ConveRTTokenizer, "_get_validated_model_url", lambda x: RESTRICTED_ACCESS_URL) component_config = { "name": "ConveRTTokenizer", "model_url": RESTRICTED_ACCESS_URL, "intent_tokenization": True, "intent_split_symbol": "+", } tokenizer = ConveRTTokenizer(component_config) message = Message(data={TEXT: text}) message.set(INTENT, text) tokenizer.train(TrainingData([message])) assert [t.text for t in message.get(TOKENS_NAMES[INTENT])] == expected_tokens
def test_routing_disjoint_case2(token_networks: List[TokenNetwork], populate_token_networks_case_2: None, addresses: List[Address], monkeypatch: MonkeyPatch): token_network = token_networks[0] # test default diversity penalty paths = token_network.get_paths(addresses[0], addresses[4], value=10, k=3) assert len(paths) == 3 assert paths[0]['path'] == [ addresses[0], addresses[2], addresses[5], addresses[4] ] assert paths[0]['estimated_fee'] == 3000 assert paths[1]['path'] == [ addresses[0], addresses[2], addresses[3], addresses[4] ] assert paths[1]['estimated_fee'] == 3500 assert paths[2]['path'] == [addresses[0], addresses[1], addresses[4]] assert paths[2]['estimated_fee'] == 5000 # set diversity penalty higher monkeypatch.setattr(pathfinder.model.token_network, 'DIVERSITY_PEN_DEFAULT', 10000) paths = token_network.get_paths(addresses[0], addresses[4], value=10, k=3) assert len(paths) == 3 assert paths[0]['path'] == [ addresses[0], addresses[2], addresses[5], addresses[4] ] assert paths[0]['estimated_fee'] == 3000 assert paths[1]['path'] == [addresses[0], addresses[1], addresses[4]] assert paths[1]['estimated_fee'] == 5000 assert paths[2]['path'] == [ addresses[0], addresses[2], addresses[3], addresses[4] ] assert paths[2]['estimated_fee'] == 3500
def mock_environment( event_loop: AbstractEventLoop, monkeypatch_module: MonkeyPatch, mock_dy_volumes: Path, compose_namespace: str, inputs_dir: Path, outputs_dir: Path, state_paths_dirs: List[Path], state_exclude_dirs: List[Path], user_id: UserID, project_id: ProjectID, node_id: NodeID, rabbit_service: RabbitSettings, ) -> None: monkeypatch_module.setenv("SC_BOOT_MODE", "production") monkeypatch_module.setenv("DYNAMIC_SIDECAR_COMPOSE_NAMESPACE", compose_namespace) monkeypatch_module.setenv("REGISTRY_AUTH", "false") monkeypatch_module.setenv("REGISTRY_USER", "test") monkeypatch_module.setenv("REGISTRY_PW", "test") monkeypatch_module.setenv("REGISTRY_SSL", "false") monkeypatch_module.setenv("DY_SIDECAR_USER_ID", f"{user_id}") monkeypatch_module.setenv("DY_SIDECAR_PROJECT_ID", f"{project_id}") monkeypatch_module.setenv("DY_SIDECAR_NODE_ID", f"{node_id}") monkeypatch_module.setenv("DY_SIDECAR_PATH_INPUTS", str(inputs_dir)) monkeypatch_module.setenv("DY_SIDECAR_PATH_OUTPUTS", str(outputs_dir)) monkeypatch_module.setenv("DY_SIDECAR_STATE_PATHS", json.dumps([str(x) for x in state_paths_dirs])) monkeypatch_module.setenv("DY_SIDECAR_STATE_EXCLUDE", json.dumps([str(x) for x in state_exclude_dirs])) # TODO: PC->ANE: this is already guaranteed in the pytest_simcore.rabbit_service fixture monkeypatch_module.setenv("RABBIT_HOST", rabbit_service.RABBIT_HOST) monkeypatch_module.setenv("RABBIT_PORT", f"{rabbit_service.RABBIT_PORT}") monkeypatch_module.setenv("RABBIT_USER", rabbit_service.RABBIT_USER) monkeypatch_module.setenv( "RABBIT_PASSWORD", rabbit_service.RABBIT_PASSWORD.get_secret_value()) # --- monkeypatch_module.setattr(mounted_fs, "DY_VOLUMES", mock_dy_volumes)
def mock_no_user__sync_config(): """ Mock user configuration path """ def exists(self): if self in DEFAULT_CONFIGURATION_PATHS: return False return os.path.exists(str(self)) def is_file(self): if self in DEFAULT_CONFIGURATION_PATHS: return False return os.path.isfile(str(self)) # pylint: disable=import-outside-toplevel from _pytest.monkeypatch import MonkeyPatch monkeypatch = MonkeyPatch() monkeypatch.setattr(Path, 'exists', exists) monkeypatch.setattr(Path, 'is_file', is_file) yield monkeypatch monkeypatch.undo()
def test_model_finetuning( tmp_path: Path, monkeypatch: MonkeyPatch, default_domain_path: Text, default_stories_file: Text, default_stack_config: Text, default_nlu_data: Text, trained_rasa_model: Text, use_latest_model: bool, ): mocked_nlu_training = Mock(wraps=rasa.nlu.train) monkeypatch.setattr(rasa.nlu, rasa.nlu.train.__name__, mocked_nlu_training) mocked_core_training = Mock(wraps=rasa.core.train) monkeypatch.setattr(rasa.core, rasa.core.train.__name__, mocked_core_training) (tmp_path / "models").mkdir() output = str(tmp_path / "models") if use_latest_model: trained_rasa_model = str(Path(trained_rasa_model).parent) train( default_domain_path, default_stack_config, [default_stories_file, default_nlu_data], output=output, force_training=True, model_to_finetune=trained_rasa_model, finetuning_epoch_fraction=0.1, ) mocked_core_training.assert_called_once() _, kwargs = mocked_core_training.call_args assert isinstance(kwargs["model_to_finetune"], Agent) mocked_nlu_training.assert_called_once() _, kwargs = mocked_nlu_training.call_args assert isinstance(kwargs["model_to_finetune"], Interpreter)
def test_attention_mask( actual_sequence_length: int, max_input_sequence_length: int, zero_start_index: int, create_language_model_featurizer: Callable[ [Dict[Text, Any]], LanguageModelFeaturizerGraphComponent ], monkeypatch: MonkeyPatch, ): monkeypatch.setattr( LanguageModelFeaturizerGraphComponent, "_load_model_instance", lambda _: None, ) component = create_language_model_featurizer({"model_name": "bert"}) attention_mask = component._compute_attention_mask( [actual_sequence_length], max_input_sequence_length ) mask_ones = attention_mask[0][:zero_start_index] mask_zeros = attention_mask[0][zero_start_index:] assert np.all(mask_ones == 1) assert np.all(mask_zeros == 0)
def test_role_refs_validator(name, mode, parent, test_id, code, tmp_trestle_dir: pathlib.Path, monkeypatch: MonkeyPatch) -> None: """Test validation of roles and references to them in responsible-parties.""" (tmp_trestle_dir / 'assessment-plans/my_ap').mkdir(exist_ok=True, parents=True) roles = [ Role(id='id1', title='title1'), Role(id='id2', title='title2'), Role(id='id3', title='title3') ] party1 = ResponsibleParty(role_id=test_id, party_uuids=[PartyUuid(__root__=str(uuid4()))]) party2 = ResponsibleParty(role_id='id2', party_uuids=[PartyUuid(__root__=str(uuid4()))]) responsible_parties = [party1, party2] ap_obj = generate_sample_model(ap.AssessmentPlan) ap_obj.metadata.roles = roles ap_obj.metadata.responsible_parties = responsible_parties ap_path = tmp_trestle_dir / 'assessment-plans/my_ap/assessment-plan.json' ap_obj.oscal_write(ap_path) if mode == '-f': if not parent: testcmd = f'trestle validate {mode} {ap_path}' else: testcmd = f'trestle validate {mode} {ap_path.parent}' elif mode == '-n': testcmd = f'trestle validate -t assessment-plan -n {name}' elif mode == '-t': testcmd = 'trestle validate -t assessment-plan' else: testcmd = 'trestle validate -a' monkeypatch.setattr(sys, 'argv', testcmd.split()) with pytest.raises(SystemExit) as pytest_wrapped_e: cli.run() assert pytest_wrapped_e.type == SystemExit assert pytest_wrapped_e.value.code == code
def test_compare_structure_database_if_different_number_of_model_runs( prepare_database: Iterator[None], cli_runner: CliRunner, monkeypatch: MonkeyPatch, caplog: LogCaptureFixture) -> None: monkeypatch.setattr(master_config, "model_configs", ["ModelConfigAccount1", "ModelConfigAccount2"]) monkeypatch.setattr(compare_structure_database, "get_model_run_ids_for_forecast_run", Mock(return_value=["ModelConfigAccount1"])) result = cli_runner.invoke( compare_structure_database.compare_structure_database_command) assert result.exit_code == 1 assert ( "Number of completed model runs (1) does not match the number of model_configs in master_config.py (2)" in caplog.messages) assert re.search( r"Number of completed model runs \(1\) does not match the number of model_configs in master_config.py \(2\)", result.output, re.MULTILINE, )
def test_session_scope_error(monkeypatch: MonkeyPatch, capsys: CaptureFixture, domain: Domain): tracker_store = SQLTrackerStore(domain) tracker_store.sessionmaker = Mock() requested_schema = uuid.uuid4().hex # `ensure_schema_exists()` raises `ValueError` mocked_ensure_schema_exists = Mock( side_effect=ValueError(requested_schema)) monkeypatch.setattr(rasa.core.tracker_store, "ensure_schema_exists", mocked_ensure_schema_exists) # `SystemExit` is triggered by failing `ensure_schema_exists()` with pytest.raises(SystemExit): with tracker_store.session_scope() as _: pass # error message is printed assert ( f"Requested PostgreSQL schema '{requested_schema}' was not found in the " f"database." in capsys.readouterr()[0])
def test_restore(self, monkeypatch: MonkeyPatch, path_type) -> None: other_path_type = self.other_path[path_type] for i in range(10): assert self.path(i) not in getattr(sys, path_type) sys_path = [self.path(i) for i in range(6)] monkeypatch.setattr(sys, path_type, sys_path) original = list(sys_path) original_other = list(getattr(sys, other_path_type)) snapshot = SysPathsSnapshot() transformation = {"source": (0, 1, 2, 3, 4, 5), "target": (6, 2, 9, 7, 5, 8)} assert sys_path == [self.path(x) for x in transformation["source"]] sys_path[1] = self.path(6) sys_path[3] = self.path(7) sys_path.append(self.path(8)) del sys_path[4] sys_path[3:3] = [self.path(9)] del sys_path[0] assert sys_path == [self.path(x) for x in transformation["target"]] snapshot.restore() assert getattr(sys, path_type) is sys_path assert getattr(sys, path_type) == original assert getattr(sys, other_path_type) == original_other
def test_render_w_vega_cli_options( monkeypatch: MonkeyPatch, capsys: SysCapture, chart: alt.TopLevelMixin, vega_cli_options: Optional[List[str]], ) -> None: """Tests that `vega_cli_options` works with both NodeSaver and other Savers""" monkeypatch.setattr(NodeSaver, "enabled", lambda: True) monkeypatch.setattr(SeleniumSaver, "enabled", lambda: False) bundle = render(chart, fmts=["html", "svg"], vega_cli_options=vega_cli_options) assert len(bundle) == 2 for mimetype, content in bundle.items(): assert content is not None fmt = mimetype_to_fmt(mimetype) if isinstance(content, dict): check_output(json.dumps(content), fmt) else: check_output(content, fmt) stderr = capsys.readouterr().err if vega_cli_options: assert "DEBUG" in stderr
def test_pass_conversation_id_to_interactive_learning( monkeypatch: MonkeyPatch): parser = argparse.ArgumentParser() sub_parser = parser.add_subparsers() interactive.add_subparser(sub_parser, []) expected_conversation_id = "🎁" args = parser.parse_args([ "interactive", "--conversation-id", expected_conversation_id, "--skip-visualization", ]) _serve_application = Mock() monkeypatch.setattr(interactive_learning, "_serve_application", _serve_application) do_interactive_learning(args, Mock()) _serve_application.assert_called_once_with(ANY, ANY, True, expected_conversation_id, 5005)
def test_normalization( self, trained_policy: Policy, tracker: DialogueStateTracker, default_domain: Domain, monkeypatch: MonkeyPatch, ): # first check the output is what we expect predicted_probabilities = trained_policy.predict_action_probabilities( tracker, default_domain, RegexInterpreter() ).probabilities # there should be no normalization assert all([confidence > 0 for confidence in predicted_probabilities]) # also check our function is not called mock = Mock() monkeypatch.setattr(train_utils, "normalize", mock.normalize) trained_policy.predict_action_probabilities( tracker, default_domain, RegexInterpreter() ) mock.normalize.assert_not_called()
def test_tmp_path_factory_handles_invalid_dir_characters( tmp_path_factory: TempPathFactory, monkeypatch: MonkeyPatch) -> None: monkeypatch.setattr("getpass.getuser", lambda: "os/<:*?;>agnostic") # _basetemp / _given_basetemp are cached / set in parallel runs, patch them monkeypatch.setattr(tmp_path_factory, "_basetemp", None) monkeypatch.setattr(tmp_path_factory, "_given_basetemp", None) p = tmp_path_factory.getbasetemp() assert "pytest-of-unknown" in str(p)
async def test_metadata_verify(monkeypatch: MonkeyPatch) -> None: fa = FakeArgs() fc = FakeConfig() monkeypatch.setattr(bandersnatch.verify, "verify_producer", do_nothing) monkeypatch.setattr(bandersnatch.verify, "delete_unowned_files", do_nothing) monkeypatch.setattr(bandersnatch.verify.os, "listdir", some_dirs) await metadata_verify(fc, fa) # type: ignore
async def test_inner_linear_normalization( component_builder: ComponentBuilder, tmp_path: Path, classifier_params: Dict[Text, Any], data_path: Text, monkeypatch: MonkeyPatch, ): pipeline = as_pipeline("WhitespaceTokenizer", "CountVectorsFeaturizer", "DIETClassifier") assert pipeline[2]["name"] == "DIETClassifier" pipeline[2].update(classifier_params) _config = RasaNLUModelConfig({"pipeline": pipeline}) (trained_model, _, persisted_path) = await rasa.nlu.train.train( _config, path=str(tmp_path), data=data_path, component_builder=component_builder, ) loaded = Interpreter.load(persisted_path, component_builder) mock = Mock() monkeypatch.setattr(train_utils, "normalize", mock.normalize) parse_data = loaded.parse("hello") intent_ranking = parse_data.get("intent_ranking") # check whether normalization had the expected effect output_sums_to_1 = sum([ intent.get("confidence") for intent in intent_ranking ]) == pytest.approx(1) assert output_sums_to_1 # check whether the normalization of rankings is reflected in intent prediction assert parse_data.get("intent") == intent_ranking[0] # normalize shouldn't have been called mock.normalize.assert_not_called()
def test_lastfailed_usecase(self, pytester: Pytester, monkeypatch: MonkeyPatch) -> None: monkeypatch.setattr("sys.dont_write_bytecode", True) p = pytester.makepyfile(""" def test_1(): assert 0 def test_2(): assert 0 def test_3(): assert 1 """) result = pytester.runpytest(str(p)) result.stdout.fnmatch_lines(["*2 failed*"]) p = pytester.makepyfile(""" def test_1(): assert 1 def test_2(): assert 1 def test_3(): assert 0 """) result = pytester.runpytest(str(p), "--lf") result.stdout.fnmatch_lines([ "collected 3 items / 1 deselected / 2 selected", "run-last-failure: rerun previous 2 failures", "*= 2 passed, 1 deselected in *", ]) result = pytester.runpytest(str(p), "--lf") result.stdout.fnmatch_lines([ "collected 3 items", "run-last-failure: no previously failed tests, not deselecting items.", "*1 failed*2 passed*", ]) pytester.path.joinpath(".pytest_cache", ".git").mkdir(parents=True) result = pytester.runpytest(str(p), "--lf", "--cache-clear") result.stdout.fnmatch_lines(["*1 failed*2 passed*"]) assert pytester.path.joinpath(".pytest_cache", "README.md").is_file() assert pytester.path.joinpath(".pytest_cache", ".git").is_dir() # Run this again to make sure clear-cache is robust if os.path.isdir(".pytest_cache"): shutil.rmtree(".pytest_cache") result = pytester.runpytest("--lf", "--cache-clear") result.stdout.fnmatch_lines(["*1 failed*2 passed*"])
def test_train_called_when_no_model_passed(default_stack_config: Text, monkeypatch: MonkeyPatch) -> None: parser = argparse.ArgumentParser() sub_parser = parser.add_subparsers() interactive.add_subparser(sub_parser, []) args = parser.parse_args([ "interactive", "--config", default_stack_config, "--data", "examples/moodbot/data", ]) interactive._set_not_required_args(args) # Mock actual training and interactive learning methods mock = Mock() monkeypatch.setattr(train, "train", mock.train_model) monkeypatch.setattr(interactive, "perform_interactive_learning", mock.perform_interactive_learning) interactive.interactive(args) mock.train_model.assert_called_once()
def test_convert_featurizer_token_edge_cases( text: Text, expected_tokens: List[Text], expected_indices: List[Tuple[int]], monkeypatch: MonkeyPatch, ): tokenizer = WhitespaceTokenizer() monkeypatch.setattr(ConveRTFeaturizer, "_get_validated_model_url", lambda x: RESTRICTED_ACCESS_URL) component_config = { "name": "ConveRTFeaturizer", "model_url": RESTRICTED_ACCESS_URL } featurizer = ConveRTFeaturizer(component_config) message = Message.build(text=text) td = TrainingData([message]) tokenizer.train(td) tokens = featurizer.tokenize(message, attribute=TEXT) assert [t.text for t in tokens] == expected_tokens assert [t.start for t in tokens] == [i[0] for i in expected_indices] assert [t.end for t in tokens] == [i[1] for i in expected_indices]
def test_sequence_length_overflow_train( input_sequence_length: int, model_name: Text, should_overflow: bool, create_language_model_featurizer: Callable[[Dict[Text, Any]], LanguageModelFeaturizer], monkeypatch: MonkeyPatch, ): monkeypatch.setattr(LanguageModelFeaturizer, "_load_model_instance", lambda _: None) component = create_language_model_featurizer({"model_name": model_name}) message = Message.build(text=" ".join(["hi"] * input_sequence_length)) if should_overflow: with pytest.raises(RuntimeError): component._validate_sequence_lengths([input_sequence_length], [message], "text", inference_mode=False) else: component._validate_sequence_lengths([input_sequence_length], [message], "text", inference_mode=False)
def test_ignore_flag(testdata_dir: pathlib.Path, tmp_trestle_dir: pathlib.Path, monkeypatch: MonkeyPatch) -> None: """Test that ignored files are not validated. Validation will fail if attempted.""" task_template_folder = tmp_trestle_dir / '.trestle/author/test_task/' test_template_folder = testdata_dir / 'author/governed_folders/template_folder_with_drawio' test_instances_folder = testdata_dir / 'author/governed_folders/ignored_files' task_instance_folder = tmp_trestle_dir / 'test_task/folder_1' hidden_file = testdata_dir / pathlib.Path( 'author/governed_folders/template_folder_with_drawio/.hidden_does_not_affect' ) test_utils.make_file_hidden(hidden_file) test_utils.copy_tree_or_file_with_hidden(test_template_folder, task_template_folder) # copy all files shutil.copytree(test_instances_folder, task_instance_folder) command_string_validate_content = 'trestle author folders validate -tn test_task -ig ^_.*' monkeypatch.setattr(sys, 'argv', command_string_validate_content.split()) rc = trestle.cli.Trestle().run() assert rc == 0
def pytest_configure(config): """Create a TempdirFactory and attach it to the config object. This is to comply with existing plugins which expect the handler to be available at pytest_configure time, but ideally should be moved entirely to the tmpdir_factory session fixture. """ mp = MonkeyPatch() tmppath_handler = TempPathFactory.from_config(config) t = TempdirFactory(tmppath_handler) config._cleanup.append(mp.undo) mp.setattr(config, "_tmp_path_factory", tmppath_handler, raising=False) mp.setattr(config, "_tmpdirhandler", t, raising=False) mp.setattr(pytest, "ensuretemp", t.ensuretemp, raising=False)
class TestRelatedFieldHTMLCutoff(APISimpleTestCase): def setUp(self): self.queryset = MockQueryset([ MockObject(pk=i, name=str(i)) for i in range(0, 1100) ]) self.monkeypatch = MonkeyPatch() def test_no_settings(self): # The default is 1,000, so sans settings it should be 1,000 plus one. for many in (False, True): field = serializers.PrimaryKeyRelatedField(queryset=self.queryset, many=many) options = list(field.iter_options()) assert len(options) == 1001 assert options[-1].display_text == "More than 1000 items..." def test_settings_cutoff(self): self.monkeypatch.setattr(relations, "api_settings", MockApiSettings(2, "Cut Off")) for many in (False, True): field = serializers.PrimaryKeyRelatedField(queryset=self.queryset, many=many) options = list(field.iter_options()) assert len(options) == 3 # 2 real items plus the 'Cut Off' item. assert options[-1].display_text == "Cut Off" def test_settings_cutoff_none(self): # Setting it to None should mean no limit; the default limit is 1,000. self.monkeypatch.setattr(relations, "api_settings", MockApiSettings(None, "Cut Off")) for many in (False, True): field = serializers.PrimaryKeyRelatedField(queryset=self.queryset, many=many) options = list(field.iter_options()) assert len(options) == 1100 def test_settings_kwargs_cutoff(self): # The explicit argument should override the settings. self.monkeypatch.setattr(relations, "api_settings", MockApiSettings(2, "Cut Off")) for many in (False, True): field = serializers.PrimaryKeyRelatedField(queryset=self.queryset, many=many, html_cutoff=100) options = list(field.iter_options()) assert len(options) == 101 assert options[-1].display_text == "Cut Off"
def test_setattr(): class A(object): x = 1 monkeypatch = MonkeyPatch() pytest.raises(AttributeError, "monkeypatch.setattr(A, 'notexists', 2)") monkeypatch.setattr(A, "y", 2, raising=False) assert A.y == 2 monkeypatch.undo() assert not hasattr(A, "y") monkeypatch = MonkeyPatch() monkeypatch.setattr(A, "x", 2) assert A.x == 2 monkeypatch.setattr(A, "x", 3) assert A.x == 3 monkeypatch.undo() assert A.x == 1 A.x = 5 monkeypatch.undo() # double-undo makes no modification assert A.x == 5
# -*- coding: utf-8 -*- # # Copyright (C) Pootle contributors. # # This file is a part of the Pootle project. It is distributed under the GPL3 # or later license. See the LICENSE file for a copy of the license and the # AUTHORS file for copyright and authorship information. """Monkeypatching fixtures.""" from _pytest.monkeypatch import MonkeyPatch mp = MonkeyPatch() class FakeJob(object): id = 'FAKE_JOB_ID' mp.setattr('rq.get_current_job', lambda: FakeJob())