def mock_virtualenv_winreg(cls, monkeypatch, data):
def enum_key(key, index):
try:
return data.get(key, [])[index]
except IndexError:
raise WindowsError
def query_value(key, path):
installed_version_tags = data.get(key, [])
suffix = "\\InstallPath"
if path.endswith(suffix):
version_tag = path[: -len(suffix)]
if version_tag in installed_version_tags:
return "{}-{}-path".format(key, version_tag)
raise WindowsError
mock_winreg = NonCallableMock(
spec_set=["HKEY_LOCAL_MACHINE", "HKEY_CURRENT_USER", "CreateKey", "EnumKey", "QueryValue", "CloseKey"]
)
mock_winreg.HKEY_LOCAL_MACHINE = "HKEY_LOCAL_MACHINE"
mock_winreg.HKEY_CURRENT_USER = "******"
mock_winreg.CreateKey.side_effect = [cls.key_local_machine, cls.key_current_user]
mock_winreg.EnumKey.side_effect = enum_key
mock_winreg.QueryValue.side_effect = query_value
mock_winreg.CloseKey.return_value = None
monkeypatch.setattr(virtualenv, "winreg", mock_winreg)
return mock_winreg
def test_map_row_with_prefix(self):
"""
Tests map_row with a prefix set
"""
writer = BaseTSVWriter([
('Prop2', 'prop2'),
], field_prefix='prop1')
row = NonCallableMock()
row.prop1 = NonCallableMock(prop2=145)
assert writer.map_row(row) == {
'Prop2': 145,
}
def _(artist, event):
# (Faster that iterating over all segments ourselves.)
contains, info = artist.contains(event)
mock = NonCallableMock(wraps=artist)
mock.get_xydata = lambda: segment
mock.get_drawstyle = lambda: "default"
mock.get_marker = lambda: "none"
segments = artist.get_segments()
sels = []
for index in info["ind"]:
segment = segments[index]
sels.append(compute_pick.dispatch(Line2D)(mock, event))
sel, index = min(((sel, idx) for idx, sel in enumerate(sels) if sel),
key=lambda sel_idx: sel_idx[0].dist, default=(None, None))
if sel:
sel = sel._replace(artist=artist)
sel.target.index = (index, getattr(sel.target, "index", None))
return sel
def test_app_scenario_running_raises_an_unexpected_error(
mocker, executor_factory, executor):
scheduler = NonCallableMock(ScenarioScheduler)
scheduler.run.side_effect = RuntimeError
mocker.patch(f"{PKG}.create_scheduler", return_value=scheduler)
exit_code = app(executor_factory=executor_factory)
assert exit_code == 3
executor.__exit__.assert_called_once()
def test_matches_single_process():
target_action = NonCallableMock(spec=ExecuteProcess)
handler = OnProcessExit(
target_action=target_action,
on_exit=Mock())
assert handler.matches(ProcessExited(
action=target_action, name='foo', cmd=['ls'], cwd=None, env=None, pid=3,
returncode=0))
assert not handler.matches(phony_process_started)
assert not handler.matches(phony_process_exited)
def _(artist, event):
# (Faster that iterating over all segments ourselves.)
contains, info = artist.contains(event)
mock = NonCallableMock(wraps=artist)
mock.get_xydata = lambda: segment
mock.get_drawstyle = lambda: "default"
mock.get_marker = lambda: "none"
segments = artist.get_segments()
sels = []
for index in info["ind"]:
segment = segments[index]
sels.append(compute_pick.dispatch(Line2D)(mock, event))
sel, index = min(((sel, idx) for idx, sel in enumerate(sels) if sel),
key=lambda sel_idx: sel_idx[0].dist,
default=(None, None))
if sel:
sel = sel._replace(artist=artist)
sel.target.index = (index, getattr(sel.target, "index", None))
return sel
def test_get_custom_build_selector_with_allowlist_yaml(
self,
mock_gen_unboxing: NonCallableMock,
mock_make_file_manager: NonCallableMock,
mock_parse_native_yaml: NonCallableMock,
mock_get_custom_build_selector: NonCallableMock,
) -> None:
temp_file = tempfile.NamedTemporaryFile()
temp_file.write(b"- aten::add.Tensor")
temp_file.seek(0)
args = [
f"--TEST_ONLY_op_registration_allowlist_yaml_path={temp_file.name}",
"--op_selection_yaml_path=path2",
]
gen_unboxing.main(args)
mock_get_custom_build_selector.assert_called_once_with(
["aten::add.Tensor"], "path2"
)
temp_file.close()
def test_sync_design_docs(self):
db = NonCallableMock()
with patch('dimagi.utils.couch.sync_docs.push',
MagicMock()) as mock_push:
sync_design_docs(db, 'design_dir', 'design_name')
mock_push.assert_called_with('design_dir',
db,
docid='_design/design_name',
force=True)
def test_value_factory(matcher_func):
value = NonCallableMock(Value)
value.resolve.return_value = sentinel.resolved
factory = ValueMatcherFactory(matcher_func, value)
matcher = factory.create(sentinel.context)
assert matcher is sentinel.matcher
value.resolve.assert_called_once_with(sentinel.context)
matcher_func.assert_called_once_with(sentinel.resolved)
def test_compile_fixed(compiler: CaseCompiler, mocker):
compiled = NonCallableMock(spec=CaseCompiled)
compiled.fix.return_value = sentinel.fixed
comp = mocker.patch.object(compiler, "compile", return_value=compiled)
fixed = compiler.compile_fixed(sentinel.obj)
assert fixed is sentinel.fixed
comp.assert_called_once_with(sentinel.obj)
compiled.fix.assert_called_once_with()
def test_add_it_accept_cycling_session_as_params_and_update_data():
cycling_session_1 = Mock(summary=Mock(return_value=NonCallableMock(
distance=10, moving_time=20, average_speed=.5, max_speed=30)))
cycling_session_2 = Mock(summary=Mock(return_value=NonCallableMock(
distance=10, moving_time=20, average_speed=.5, max_speed=30)))
compiled = CompiledCyclingData()
compiled.add(cycling_session_1)
assert compiled.total_distance == 10
assert compiled.total_moving_time == 20
assert compiled.average_speed == .5
assert compiled.max_speed == 30
compiled.add(cycling_session_2)
assert compiled.total_distance == 20
assert compiled.total_moving_time == 40
assert compiled.average_speed == .5
assert compiled.max_speed == 30
def response():
return NonCallableMock(
spec=Response,
id=sentinel.response_id,
elapsed=sentinel.elapsed,
status_code=sentinel.status_code,
headers=sentinel.headers,
body=sentinel.body,
request_datetime=sentinel.starts,
)
def test_given_a_response(mocker):
retry = mocker.patch(f"{PKG}.retry_while_false", side_effect=_retry)
execution = ExecutionReport(starts=sentinel.starts)
requester = NonCallableMock(Requester)
requester.base_url = sentinel.requester_base_url
requester.execute.return_value = (execution, sentinel.response)
def _verify(analyzer: Analyzer,
context: Optional[Context] = None) -> Verification:
assert analyzer is sentinel.response
assert context == Context(foo="bar", starts=sentinel.starts)
return sentinel.verification
requirements = NonCallableMock(ResponseDescription,
verify=Mock(side_effect=_verify))
runner = UnitRunner(requester=requester, retry=3, delay=sentinel.delay)
assert runner.base_url is sentinel.requester_base_url
execution, response, verification = runner.run(
sentinel.request,
requirements,
sentinel.session,
context=Context(foo="bar"),
)
assert execution is execution
assert response is sentinel.response
assert verification is sentinel.verification
requester.execute.assert_called_with(
sentinel.request,
session=sentinel.session,
context=Context(foo="bar"),
)
# Contextual values will disappear.
requirements.verify.assert_called_with(sentinel.response,
Context(foo="bar"))
retry.assert_called_once_with(ANY,
attempts=4,
delay=sentinel.delay,
predicate=ANY)
def test_attribute_deletion(self):
for mock in (Mock(), MagicMock(), NonCallableMagicMock(),
NonCallableMock()):
self.assertTrue(hasattr(mock, 'm'))
del mock.m
self.assertFalse(hasattr(mock, 'm'))
del mock.f
self.assertFalse(hasattr(mock, 'f'))
self.assertRaises(AttributeError, getattr, mock, 'f')
def test_load_plugins_invalid_module(mocker):
loader = NonCallableMock(InspectLoader)
loader.exec_module.side_effect = SyntaxError("msg")
spec = NonCallableMock(ModuleSpec, loader=loader)
mocker.patch(f"{PKG}.spec_from_file_location", return_value=spec)
module = NonCallableMock(ModuleType)
mocker.patch(f"{PKG}.module_from_spec", return_value=module)
uuid4 = NonCallableMagicMock(uuid.uuid4)
uuid4.__str__.return_value = "module-name"
mocker.patch("uuid.uuid4", return_value=uuid4)
manager = NonCallableMock(PluginManager)
with raises(SyntaxError):
load_plugins(manager, (sentinel.plugin, ))
manager.register.assert_not_called()
assert sys.modules.get("module-name") != module
def create_query(self, method, ajax_value):
render_mock = Mock()
handle_mock = Mock()
ajax_arg_mock = Mock(return_value=ajax_value)
query = NonCallableMock(
spec=RequestHandler,
get_query_argument=ajax_arg_mock,
request=Mock(method=method),
render=render_mock,
get_template_name=Mock(return_value='index.html'))
return query, handle_mock, render_mock
def mock_sql():
mock_sql_query = Mock(
spec_set=['_execute_sql', 'query', 'as_sql', 'connection'])
mock_sql_query._execute_sql = Mock()
mock_sql_query.query = NonCallableMock(spec_set=['model'])
mock_sql_query.query.model = Mock()
query_string = 'SELECT * from table_name'
mock_sql_query.as_sql = Mock(return_value=(query_string, ()))
mock_sql_query.connection = NonCallableMock(
spec_set=['cursor', 'features', 'ops'],
cursor=Mock(spec_set=['__call__'],
return_value=NonCallableMagicMock(
spec_set=['__enter__', '__exit__', 'execute'])),
features=NonCallableMock(
spec_set=['supports_explaining_query_execution'],
supports_explaining_query_execution=True),
ops=NonCallableMock(spec_set=['explain_query_prefix']),
)
return mock_sql_query, query_string
def test_assert_called_with_failure_message(self):
mock = NonCallableMock()
expected = "mock(1, '2', 3, bar='foo')"
message = 'Expected call: %s\nNot called'
self.assertRaisesWithMsg(
AssertionError, message % (expected,),
mock.assert_called_with, 1, '2', 3, bar='foo'
)
mock.foo(1, '2', 3, foo='foo')
asserters = [
mock.foo.assert_called_with, mock.foo.assert_called_once_with
]
for meth in asserters:
actual = "foo(1, '2', 3, foo='foo')"
expected = "foo(1, '2', 3, bar='foo')"
message = 'Expected call: %s\nActual call: %s'
self.assertRaisesWithMsg(
AssertionError, message % (expected, actual),
meth, 1, '2', 3, bar='foo'
)
# just kwargs
for meth in asserters:
actual = "foo(1, '2', 3, foo='foo')"
expected = "foo(bar='foo')"
message = 'Expected call: %s\nActual call: %s'
self.assertRaisesWithMsg(
AssertionError, message % (expected, actual),
meth, bar='foo'
)
# just args
for meth in asserters:
actual = "foo(1, '2', 3, foo='foo')"
expected = "foo(1, 2, 3)"
message = 'Expected call: %s\nActual call: %s'
self.assertRaisesWithMsg(
AssertionError, message % (expected, actual),
meth, 1, 2, 3
)
# empty
for meth in asserters:
actual = "foo(1, '2', 3, foo='foo')"
expected = "foo()"
message = 'Expected call: %s\nActual call: %s'
self.assertRaisesWithMsg(
AssertionError, message % (expected, actual), meth
)
def test_matcher_predicate(mocker):
matcher_factory = NonCallableMock(MatcherFactoryCompiler)
matcher_factory.compile.return_value = sentinel.factory
predicate_ctor = mocker.patch(f"{PKG}.MatcherWrappingPredicate")
predicate_ctor.return_value = sentinel.predicate
predicate = PredicateCompiler(matcher_factory).compile(sentinel.obj)
assert predicate is sentinel.predicate
matcher_factory.compile.assert_called_once_with(sentinel.obj)
predicate_ctor.assert_called_once_with(sentinel.factory)
def test_datetime_with_format_default():
original = NonCallableMock(Value)
original.resolve.return_value = datetime(2020, 1, 23, 1, 23, 45, 678901)
value = DatetimeValueWithFormat(original)
assert value.type == DatetimeWithFormat
resolved = value.resolve()
assert resolved.value == datetime(2020, 1, 23, 1, 23, 45, 678901)
assert resolved.fmt is ISO8601
original.resolve.assert_called_once_with(None)
def test_datetime_with_format_contextual():
original = NonCallableMock(Value)
original.resolve.return_value = datetime(2020, 1, 23, 1, 23, 45, 678901)
value = DatetimeValueWithFormat(original, sentinel.fmt)
assert value.type == DatetimeWithFormat
resolved = value.resolve(sentinel.context)
assert resolved.value == datetime(2020, 1, 23, 1, 23, 45, 678901)
assert resolved.fmt is sentinel.fmt
original.resolve.assert_called_once_with(sentinel.context)
def test_running_scenario_task_empty():
cases_result = NonCallableMock(StatusedList, status=Status.SKIPPED)
cases = NonCallableMock(CasesTask)
cases.result.return_value = cases_result
task = RunningScenarioTask(
label=sentinel.label,
conditions=sentinel.conditions,
cases=cases,
subscenarios=[],
)
result = task.result()
assert result.label is sentinel.label
assert result.status is Status.SKIPPED
assert result.message is None
assert result.conditions is sentinel.conditions
assert result.cases is cases_result
assert not result.subscenarios.items
cases.result.assert_called_once_with()
def mock_redis(mock_pipeline):
mock_redis = NonCallableMock(name='redis', spec=Redis)
def transaction(func, *watches, value_from_callable=False):
assert value_from_callable
mock_pipeline.watch(*watches)
result = func(mock_pipeline)
mock_pipeline.execute()
return result
mock_redis.transaction.side_effect = transaction
return mock_redis
def test_when_given_no_response(mocker):
mocker.patch(f"{PKG}.now", return_value=sentinel.starts)
execution = ExecutionReport(status=Status.FAILURE)
case = Case(label=sentinel.label,
request=sentinel.request,
response=sentinel.response)
def _run_unit(
request: Request,
requirements: ResponseDescription,
session: Optional[requests.Session] = None,
context: Optional[Context] = None,
) -> Result:
assert request is sentinel.request
assert requirements is sentinel.response
assert session is None
assert context == Context(starts=sentinel.starts,
base_url=sentinel.base_url)
return execution, None, None
unit_runner = NonCallableMock(UnitRunner, base_url=sentinel.base_url)
unit_runner.run.side_effect = Mock(side_effect=_run_unit)
listener = NonCallableMock(spec=CaseListener)
runner = CaseRunner(unit_runner=unit_runner, listener=listener)
result = runner.run(case)
assert result.label is sentinel.label
assert result.status is Status.FAILURE
assert result.execution is execution
assert result.response is None
# Contextual values will disappear.
unit_runner.run.assert_called_once_with(
request=sentinel.request,
requirements=sentinel.response,
session=None,
context=Context(),
)
listener.on_execution.assert_called_once_with(execution, None)
def create_query(self, method, user):
redirect = Mock()
query = NonCallableMock(
spec=RequestHandler,
current_user=user,
request=Mock(method='GET',
fullurl=Mock(return_value='/fullurl'),
uri='/uri'),
redirect=redirect,
get_login_url=Mock(return_value='/login'),
get_verify_url=Mock(return_value='/verify'),
)
return query, redirect
def test_load_plugins_normal(mocker):
loader = NonCallableMock(InspectLoader)
spec = NonCallableMock(ModuleSpec, loader=loader)
spec_ctor = mocker.patch(f"{PKG}.spec_from_file_location",
return_value=spec)
module = NonCallableMock(ModuleType)
module_ctor = mocker.patch(f"{PKG}.module_from_spec", return_value=module)
uuid4 = NonCallableMagicMock(uuid.uuid4)
uuid4.__str__.return_value = "module-name"
mocker.patch("uuid.uuid4", return_value=uuid4)
manager = NonCallableMock(PluginManager)
load_plugins(manager, (sentinel.plugin, ))
spec_ctor.assert_called_once_with("module-name", sentinel.plugin)
module_ctor.assert_called_once_with(spec)
loader.exec_module.assert_called_once_with(module)
manager.register.assert_called_once_with(module)
assert sys.modules["module-name"] == module
def create_query(self, chk_session_res, session_cookie):
check_session_status = Mock(return_value=chk_session_res)
gapsule.handlers.Base.check_session_status = asyncio.coroutine(
check_session_status)
if session_cookie is not None:
get_secure_cookie = Mock(
return_value=session_encode(session_cookie))
else:
get_secure_cookie = Mock(return_value=None)
base_handler = NonCallableMock(spec=BaseHandler,
get_secure_cookie=get_secure_cookie,
prepare=BaseHandler.prepare)
return base_handler, get_secure_cookie, check_session_status
def test_map_row_without_prefix(self):
"""
Tests map_row with a prefix set
"""
writer = BaseTSVWriter([
('Prop2', 'prop1'),
])
row = NonCallableMock(prop1=145)
assert writer.map_row(row) == {
'Prop2': 145,
}
def test_get_potential_posters(self, mocked_search):
with self.subTest('When MAL returns no poster'):
expected = [{'current': True, 'url': self.kiznaiver.ext_poster}]
mocked_search.return_value = NonCallableMock(poster=None)
# Let the magic occur.
posters = get_potential_posters(self.kiznaiver)
# In this case, `get_potential_posters` cannot fix the current poster.
self.assertCountEqual(posters, expected)
with self.subTest('When MAL returns a poster'):
expected = [{
'current': True,
'url': self.kiznaiver.ext_poster
}, {
'current': False,
'url': 'kiznaiver_mal_poster_url'
}]
mocked_search.return_value = NonCallableMock(
poster=expected[1]['url'])
posters = get_potential_posters(self.kiznaiver)
# In this case, `get_potential_posters` should return a list of two posters, i.e. old external, MAL's one.
self.assertCountEqual(posters, expected)
def test_fix_filled(mocker):
ctor = mocker.patch(f"{PKG}.Request", return_value=sentinel.fixed)
body = NonCallableMock(RequestBodyCompiled)
body.fix = Mock(return_value=sentinel.body)
compiled = RequestCompiled(
method=sentinel.method,
path=sentinel.path,
headers=sentinel.headers,
params=sentinel.params,
body=body,
)
fixed = compiled.fix()
assert fixed is sentinel.fixed
ctor.assert_called_once_with(
method=sentinel.method,
path=sentinel.path,
headers=sentinel.headers,
params=sentinel.params,
body=sentinel.body,
)
body.fix.assert_called_once_with()
def test_invalid_integration_params():
for kwarg in [
"deposit",
"withdrawal",
"sep31_receiver",
"customer",
"rails",
"fee",
"scripts",
"sep6_info",
"toml",
]:
with pytest.raises(TypeError):
register_integrations(**{kwarg: NonCallableMock()})
def test_matches_single_process_output():
target_action = NonCallableMock(spec=ExecuteProcess)
handler = OnProcessIO(target_action=target_action)
assert handler.matches(
ProcessIO(action=target_action,
name='foo',
cmd=['ls'],
cwd=None,
env=None,
pid=3,
text=b'phony io',
fd=0))
assert not handler.matches(phony_process_started)
assert not handler.matches(phony_process_io)
def session():
response = NonCallableMock(requests.Response)
response.elapsed = timedelta(seconds=1.23)
response.status_code = 402
response.headers = {"Header-Name": "Header-Value"}
response.text = sentinel.text
response.content = sentinel.content
session = NonCallableMagicMock(requests.Session)
session.__enter__.return_value = session
session.rebuild_proxies.return_value = sentinel.proxies
session.send.return_value = response
return session
