def test_filename_with_nonsense_uri(self):
presenter = self.presenter(document_uris=[mock.Mock(uri="foobar")])
assert presenter.filename == ""
def test_bad_surface_air_pressure(self):
new_surface_p_coord = mock.Mock(units=cf_units.Unit("km"), nbounds=0)
with self.assertRaises(ValueError):
self.factory.update(self.surface_air_pressure, new_surface_p_coord)
def test_handler_rejects_invalid_properties(self):
handler = CleanupResourceHandler(route53_client=mock.Mock())
with self.assertRaises(Exception):
handler.handle_event({'RequestType': 'Delete', 'ResourceProperties': {'Invalid': 'Invalid'}}, {})
def setUp(self):
self.delta = mock.Mock(units=cf_units.Unit("Pa"), nbounds=0)
self.sigma = mock.Mock(units=cf_units.Unit("1"), nbounds=0)
self.surface_air_pressure = mock.Mock(units=cf_units.Unit("Pa"),
nbounds=0)
def test_alternative_bad_delta(self):
new_delta_coord = mock.Mock(units=cf_units.Unit("Pa"), nbounds=4)
with self.assertRaises(ValueError):
self.factory.update(self.delta, new_delta_coord)
def setUp(self):
super(TestQuotaList, self).setUp()
# Work with multiple projects in this class
self.projects_mock.get.side_effect = self.projects
self.projects_mock.list.return_value = self.projects
self.compute_quotas = [
compute_fakes.FakeQuota.create_one_comp_quota(),
compute_fakes.FakeQuota.create_one_comp_quota(),
]
self.compute_default_quotas = [
compute_fakes.FakeQuota.create_one_default_comp_quota(),
compute_fakes.FakeQuota.create_one_default_comp_quota(),
]
self.compute = self.app.client_manager.compute
self.compute.quotas.defaults = mock.Mock(
side_effect=self.compute_default_quotas, )
self.compute_reference_data = (
self.projects[0].id,
self.compute_quotas[0].cores,
self.compute_quotas[0].fixed_ips,
self.compute_quotas[0].injected_files,
self.compute_quotas[0].injected_file_content_bytes,
self.compute_quotas[0].injected_file_path_bytes,
self.compute_quotas[0].instances,
self.compute_quotas[0].key_pairs,
self.compute_quotas[0].metadata_items,
self.compute_quotas[0].ram,
self.compute_quotas[0].server_groups,
self.compute_quotas[0].server_group_members,
)
self.network_quotas = [
network_fakes.FakeQuota.create_one_net_quota(),
network_fakes.FakeQuota.create_one_net_quota(),
]
self.network_default_quotas = [
network_fakes.FakeQuota.create_one_default_net_quota(),
network_fakes.FakeQuota.create_one_default_net_quota(),
]
self.network = self.app.client_manager.network
self.network.get_quota_default = mock.Mock(
side_effect=self.network_default_quotas, )
self.network_reference_data = (
self.projects[0].id,
self.network_quotas[0].floating_ips,
self.network_quotas[0].networks,
self.network_quotas[0].ports,
self.network_quotas[0].rbac_policies,
self.network_quotas[0].routers,
self.network_quotas[0].security_groups,
self.network_quotas[0].security_group_rules,
self.network_quotas[0].subnets,
self.network_quotas[0].subnet_pools,
)
self.volume_quotas = [
volume_fakes.FakeQuota.create_one_vol_quota(),
volume_fakes.FakeQuota.create_one_vol_quota(),
]
self.volume_default_quotas = [
volume_fakes.FakeQuota.create_one_default_vol_quota(),
volume_fakes.FakeQuota.create_one_default_vol_quota(),
]
self.volume = self.app.client_manager.volume
self.volume.quotas.defaults = mock.Mock(
side_effect=self.volume_default_quotas, )
self.volume_reference_data = (
self.projects[0].id,
self.volume_quotas[0].backups,
self.volume_quotas[0].backup_gigabytes,
self.volume_quotas[0].gigabytes,
self.volume_quotas[0].per_volume_gigabytes,
self.volume_quotas[0].snapshots,
self.volume_quotas[0].volumes,
)
self.cmd = quota.ListQuota(self.app, None)
def test_disallow_direct_span_creation(self):
with self.assertRaises(TypeError):
# pylint: disable=abstract-class-instantiated
trace.Span("name", mock.Mock(spec=trace_api.SpanContext))
def test_advance(dummy_config):
specs = setup_test_behavior_specs(use_discrete=False,
use_visual=False,
vector_action_space=2)
dummy_config.hyperparameters.steps_per_update = 20
dummy_config.hyperparameters.reward_signal_steps_per_update = 20
dummy_config.hyperparameters.buffer_init_steps = 0
trainer = SACTrainer("test", 0, dummy_config, True, False, 0, "0")
behavior_id = BehaviorIdentifiers.from_name_behavior_id(trainer.brain_name)
policy = trainer.create_policy(behavior_id, specs)
trainer.add_policy(behavior_id, policy)
trajectory_queue = AgentManagerQueue("testbrain")
policy_queue = AgentManagerQueue("testbrain")
trainer.subscribe_trajectory_queue(trajectory_queue)
trainer.publish_policy_queue(policy_queue)
trajectory = make_fake_trajectory(
length=15,
observation_shapes=specs.observation_shapes,
max_step_complete=True,
action_spec=specs.action_spec,
)
trajectory_queue.put(trajectory)
trainer.advance()
# Check that trainer put trajectory in update buffer
assert trainer.update_buffer.num_experiences == 15
# Check that the stats are being collected as episode isn't complete
for reward in trainer.collected_rewards.values():
for agent in reward.values():
assert agent > 0
# Add a terminal trajectory
trajectory = make_fake_trajectory(
length=6,
observation_shapes=specs.observation_shapes,
max_step_complete=False,
action_spec=specs.action_spec,
)
trajectory_queue.put(trajectory)
trainer.advance()
# Check that the stats are reset as episode is finished
for reward in trainer.collected_rewards.values():
for agent in reward.values():
assert agent == 0
assert trainer.stats_reporter.get_stats_summaries(
"Policy/Extrinsic Reward").num > 0
# Assert we're not just using the default values
assert (trainer.stats_reporter.get_stats_summaries(
"Policy/Extrinsic Reward").mean > 0)
# Make sure there is a policy on the queue
policy_queue.get_nowait()
# Add another trajectory. Since this is less than 20 steps total (enough for)
# two updates, there should NOT be a policy on the queue.
trajectory = make_fake_trajectory(
length=5,
observation_shapes=specs.observation_shapes,
action_spec=specs.action_spec,
max_step_complete=False,
)
trajectory_queue.put(trajectory)
trainer.advance()
with pytest.raises(AgentManagerQueue.Empty):
policy_queue.get_nowait()
# Call add_policy and check that we update the correct number of times.
# This is to emulate a load from checkpoint.
behavior_id = BehaviorIdentifiers.from_name_behavior_id(trainer.brain_name)
policy = trainer.create_policy(behavior_id, specs)
policy.get_current_step = lambda: 200
trainer.add_policy(behavior_id, policy)
trainer.optimizer.update = mock.Mock()
trainer.model_saver.initialize_or_load(policy)
trainer.optimizer.update_reward_signals = mock.Mock()
trainer.optimizer.update_reward_signals.return_value = {}
trainer.optimizer.update.return_value = {}
trajectory_queue.put(trajectory)
trainer.advance()
# Make sure we did exactly 1 update
assert trainer.optimizer.update.call_count == 1
assert trainer.optimizer.update_reward_signals.call_count == 1
def connector(loop):
conn = BaseConnector(loop=loop)
proto = mock.Mock()
conn._conns['a'] = [(proto, 123)]
return conn
def test_expanded_landing_page_view_service_client_mtls_env_auto(use_client_cert_env):
# This tests the endpoint autoswitch behavior. Endpoint is autoswitched to the default
# mtls endpoint, if GOOGLE_API_USE_CLIENT_CERTIFICATE is "true" and client cert exists.
# Check the case client_cert_source is provided. Whether client cert is used depends on
# GOOGLE_API_USE_CLIENT_CERTIFICATE value.
with mock.patch.dict(os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": use_client_cert_env}):
options = client_options.ClientOptions(client_cert_source=client_cert_source_callback)
with mock.patch('google.ads.googleads.v5.services.services.expanded_landing_page_view_service.transports.ExpandedLandingPageViewServiceGrpcTransport.__init__') as grpc_transport:
ssl_channel_creds = mock.Mock()
with mock.patch('grpc.ssl_channel_credentials', return_value=ssl_channel_creds):
grpc_transport.return_value = None
client = ExpandedLandingPageViewServiceClient(client_options=options)
if use_client_cert_env == "false":
expected_ssl_channel_creds = None
expected_host = client.DEFAULT_ENDPOINT
else:
expected_ssl_channel_creds = ssl_channel_creds
expected_host = client.DEFAULT_MTLS_ENDPOINT
grpc_transport.assert_called_once_with(
ssl_channel_credentials=expected_ssl_channel_creds,
credentials=None,
host=expected_host,
client_info=transports.base.DEFAULT_CLIENT_INFO,
)
# Check the case ADC client cert is provided. Whether client cert is used depends on
# GOOGLE_API_USE_CLIENT_CERTIFICATE value.
with mock.patch.dict(os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": use_client_cert_env}):
with mock.patch('google.ads.googleads.v5.services.services.expanded_landing_page_view_service.transports.ExpandedLandingPageViewServiceGrpcTransport.__init__') as grpc_transport:
with mock.patch('google.auth.transport.grpc.SslCredentials.__init__', return_value=None):
with mock.patch('google.auth.transport.grpc.SslCredentials.is_mtls', new_callable=mock.PropertyMock) as is_mtls_mock:
with mock.patch('google.auth.transport.grpc.SslCredentials.ssl_credentials', new_callable=mock.PropertyMock) as ssl_credentials_mock:
if use_client_cert_env == "false":
is_mtls_mock.return_value = False
ssl_credentials_mock.return_value = None
expected_host = client.DEFAULT_ENDPOINT
expected_ssl_channel_creds = None
else:
is_mtls_mock.return_value = True
ssl_credentials_mock.return_value = mock.Mock()
expected_host = client.DEFAULT_MTLS_ENDPOINT
expected_ssl_channel_creds = ssl_credentials_mock.return_value
grpc_transport.return_value = None
client = ExpandedLandingPageViewServiceClient()
grpc_transport.assert_called_once_with(
ssl_channel_credentials=expected_ssl_channel_creds,
credentials=None,
host=expected_host,
client_info=transports.base.DEFAULT_CLIENT_INFO,
)
# Check the case client_cert_source and ADC client cert are not provided.
with mock.patch.dict(os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": use_client_cert_env}):
with mock.patch('google.ads.googleads.v5.services.services.expanded_landing_page_view_service.transports.ExpandedLandingPageViewServiceGrpcTransport.__init__') as grpc_transport:
with mock.patch('google.auth.transport.grpc.SslCredentials.__init__', return_value=None):
with mock.patch('google.auth.transport.grpc.SslCredentials.is_mtls', new_callable=mock.PropertyMock) as is_mtls_mock:
is_mtls_mock.return_value = False
grpc_transport.return_value = None
client = ExpandedLandingPageViewServiceClient()
grpc_transport.assert_called_once_with(
ssl_channel_credentials=None,
credentials=None,
host=client.DEFAULT_ENDPOINT,
client_info=transports.base.DEFAULT_CLIENT_INFO,
)
def test_resolve_gomod(
mock_run,
mock_get_worker_config,
mock_set_full_relpaths,
mock_vet_local_deps,
mock_get_allowed_local_deps,
mock_merge_tree,
mock_temp_dir,
mock_golang_version,
dep_replacement,
go_list_error_pkg,
expected_replace,
cgo_disable,
tmpdir,
sample_deps,
sample_deps_replace,
sample_deps_replace_new_name,
sample_package,
sample_pkg_deps_without_replace,
):
mock_cmd_output = _generate_mock_cmd_output(go_list_error_pkg)
# Mock the tempfile.TemporaryDirectory context manager
mock_temp_dir.return_value.__enter__.return_value = str(tmpdir)
# Mock the "subprocess.run" calls
run_side_effects = []
if dep_replacement:
run_side_effects.append(mock.Mock(returncode=0, stdout=None)) # go mod edit -replace
run_side_effects.append(mock.Mock(returncode=0, stdout=None)) # go mod download
if dep_replacement:
run_side_effects.append(mock.Mock(returncode=0, stdout=None)) # go mod tidy
run_side_effects.append(
mock.Mock(returncode=0, stdout="github.com/release-engineering/retrodep/v2") # go list -m
)
run_side_effects.append(mock.Mock(returncode=0, stdout=mock_cmd_output)) # go list -m all
run_side_effects.append(mock.Mock(returncode=0, stdout=mock_pkg_list)) # go list -find ./...
run_side_effects.append(mock.Mock(returncode=0, stdout=mock_pkg_deps)) # go list -deps -json
mock_run.side_effect = run_side_effects
mock_golang_version.return_value = "v2.1.1"
mock_get_allowed_local_deps.return_value = ["*"]
archive_path = "/this/is/path/to/archive.tar.gz"
request = {"id": 3, "ref": "c50b93a32df1c9d700e3e80996845bc2e13be848"}
if cgo_disable:
request["flags"] = ["cgo-disable"]
if dep_replacement is None:
gomod = resolve_gomod(archive_path, request)
expected_deps = sample_deps
else:
gomod = resolve_gomod(archive_path, request, [dep_replacement])
if dep_replacement.get("new_name"):
expected_deps = sample_deps_replace_new_name
else:
expected_deps = sample_deps_replace
if expected_replace:
assert mock_run.call_args_list[0][0][0] == (
"go",
"mod",
"edit",
"-replace",
expected_replace,
)
if dep_replacement:
assert mock_run.call_args_list[2][0][0] == ("go", "mod", "tidy")
for call in mock_run.call_args_list:
env = call.kwargs["env"]
if cgo_disable:
assert env["CGO_ENABLED"] == "0"
else:
assert "CGO_ENABLED" not in env
assert gomod["module"] == sample_package
assert gomod["module_deps"] == expected_deps
assert len(gomod["packages"]) == 1
if dep_replacement is None:
assert (
sorted(gomod["packages"][0]["pkg_deps"], key=_package_sort_key)
== sample_pkg_deps_without_replace
)
mock_merge_tree.assert_called_once_with(
os.path.join(tmpdir, RequestBundleDir.go_mod_cache_download_part),
str(RequestBundleDir(request["id"]).gomod_download_dir),
)
expect_module_name = sample_package["name"]
mock_get_allowed_local_deps.assert_called_once_with(expect_module_name)
mock_vet_local_deps.assert_has_calls(
[
mock.call(expected_deps, expect_module_name, ["*"]),
mock.call(gomod["packages"][0]["pkg_deps"], expect_module_name, ["*"]),
],
)
mock_set_full_relpaths.assert_called_once_with(gomod["packages"][0]["pkg_deps"], expected_deps)
def test_generate_rule(self):
match = mock.Mock()
match.group.side_effect = self.my_side_effect
obj = MarkdownRule(match)
assert (obj.rule == 'MD009')
assert (obj.file_line_number == 15)
def test_print_map(self):
self.assertRaises(TypeError,self.game_map.print_map,(1))
self.assertRaises(TypeError,self.game_map.print_map,([1,2],1))
self.game_map.print_map = mock.Mock()
self.game_map.print_map(['2'])
self.game_map.print_map.assert_called_with(['2'])
def test2_can_connect(self):
api = Api()
m_constants.SESSION.get.side_effect = requests.exceptions.ConnectionError(mock.Mock(status="Connection Error"))
exp = False
obs = api.can_connect()
self.assertEqual(exp, obs)
def test_method_pode_alterar_deve_retornar_true(self, is_owner, acontecendo):
is_owner.return_value = True
acontecendo.return_value = True
self.assertTrue(self.avaliacao_homologador.pode_alterar(user=mock.Mock()))
def create_connection(req):
# return self.transport, self.protocol
return mock.Mock()
def test_method_pode_alterar_deve_retornar_false_quando_fase_nao_estiver_acontecendo(
self, is_owner, acontecendo
):
is_owner.return_value = True
acontecendo.return_value = False
self.assertFalse(self.avaliacao_homologador.pode_alterar(user=mock.Mock()))
def test_update_sinogram(self):
image_data = mock.Mock()
self.view.update_sinogram(image_data)
self.image_view.update_sinogram.assert_called_once_with(image_data)
def test_shutdown(self):
tracer_provider = trace.TracerProvider()
mock_processor1 = mock.Mock(spec=trace.SpanProcessor)
tracer_provider.add_span_processor(mock_processor1)
mock_processor2 = mock.Mock(spec=trace.SpanProcessor)
tracer_provider.add_span_processor(mock_processor2)
tracer_provider.shutdown()
self.assertEqual(mock_processor1.shutdown.call_count, 1)
self.assertEqual(mock_processor2.shutdown.call_count, 1)
shutdown_python_code = """
import atexit
from unittest import mock
from opentelemetry.sdk import trace
mock_processor = mock.Mock(spec=trace.SpanProcessor)
def print_shutdown_count():
print(mock_processor.shutdown.call_count)
# atexit hooks are called in inverse order they are added, so do this before
# creating the tracer
atexit.register(print_shutdown_count)
tracer_provider = trace.TracerProvider({tracer_parameters})
tracer_provider.add_span_processor(mock_processor)
{tracer_shutdown}
"""
def run_general_code(shutdown_on_exit, explicit_shutdown):
tracer_parameters = ""
tracer_shutdown = ""
if not shutdown_on_exit:
tracer_parameters = "shutdown_on_exit=False"
if explicit_shutdown:
tracer_shutdown = "tracer_provider.shutdown()"
return subprocess.check_output(
[
# use shutil to avoid calling python outside the
# virtualenv on windows.
shutil.which("python"),
"-c",
shutdown_python_code.format(
tracer_parameters=tracer_parameters,
tracer_shutdown=tracer_shutdown,
),
]
)
# test default shutdown_on_exit (True)
out = run_general_code(True, False)
self.assertTrue(out.startswith(b"1"))
# test that shutdown is called only once even if Tracer.shutdown is
# called explicitely
out = run_general_code(True, True)
self.assertTrue(out.startswith(b"1"))
# test shutdown_on_exit=False
out = run_general_code(False, False)
self.assertTrue(out.startswith(b"0"))
def setUp(self) -> None:
with mock.patch(
"mantidimaging.gui.windows.main.view.WelcomeScreenPresenter"):
self.main_window = MainWindowView()
self.view = ReconstructWindowView(self.main_window)
self.view.presenter = self.presenter = mock.Mock()
self.view.image_view = self.image_view = mock.Mock()
self.view.tableView = self.tableView = mock.Mock()
self.view.resultCor = self.resultCor = mock.Mock()
self.view.resultTilt = self.resultTilt = mock.Mock()
self.view.resultSlope = self.resultSlope = mock.Mock()
self.view.numIter = self.numIter = mock.Mock()
self.view.pixelSize = self.pixelSize = mock.Mock()
self.view.algorithmName = self.algorithmName = mock.Mock()
self.view.filterName = self.filterName = mock.Mock()
self.view.maxProjAngle = self.maxProjAngle = mock.Mock()
self.view.autoFindMethod = self.autoFindMethod = mock.Mock()
def test_basic_span(self):
span = trace._Span("name", mock.Mock(spec=trace_api.SpanContext))
self.assertEqual(span.name, "name")
def test_show_recon_volume(self):
data = mock.Mock()
self.main_window.create_new_stack = create_new_stack_mock = mock.Mock()
self.view.show_recon_volume(data)
create_new_stack_mock.assert_called_once_with(data, "Recon")
def test_good_delta(self):
new_delta_coord = mock.Mock(units=cf_units.Unit("Pa"), nbounds=0)
self.factory.update(self.delta, new_delta_coord)
self.assertIs(self.factory.delta, new_delta_coord)
def test_cleanup(self):
self.view.stackSelector = stack_selector_mock = mock.Mock()
self.view.cleanup()
stack_selector_mock.unsubscribe_from_main_window.assert_called_once()
assert self.main_window.recon is None
def test_good_surface_air_pressure(self):
new_surface_p_coord = mock.Mock(units=cf_units.Unit("Pa"), nbounds=0)
self.factory.update(self.surface_air_pressure, new_surface_p_coord)
self.assertIs(self.factory.surface_air_pressure, new_surface_p_coord)
def test_data_sources_differ(self, get_job, get_data_source, get_cluster):
get_job.return_value = mock.Mock(type=edp.JOB_TYPE_MAPREDUCE_STREAMING,
libs=[],
interface=[])
ds1_id = uuidutils.generate_uuid()
ds2_id = uuidutils.generate_uuid()
data_sources = {
ds1_id: mock.Mock(type="swift", url="http://swift/test"),
ds2_id: mock.Mock(type="swift", url="http://swift/test2"),
}
get_data_source.side_effect = lambda ctx, x: data_sources[x]
ng = tu.make_ng_dict('master',
42, ['oozie'],
1,
instances=[tu.make_inst_dict('id', 'name')])
get_cluster.return_value = tu.create_cluster("cluster", "tenant1",
"fake", "0.1", [ng])
self._assert_create_object_validation(
data={
"cluster_id": uuidutils.generate_uuid(),
"input_id": ds1_id,
"output_id": ds2_id,
"job_configs": {
"configs": {
"edp.streaming.mapper": "/bin/cat",
"edp.streaming.reducer": "/usr/bin/wc"
},
"params": {},
"job_execution_info": {},
"args": []
}
})
data_sources[ds2_id].url = "http://swift/test"
err_msg = ("Provided input and output DataSources reference the "
"same location: %s" % data_sources[ds2_id].url)
self._assert_create_object_validation(data={
"cluster_id":
uuidutils.generate_uuid(),
"input_id":
ds1_id,
"output_id":
ds2_id,
"job_configs": {
"configs": {
"edp.streaming.mapper": "/bin/cat",
"edp.streaming.reducer": "/usr/bin/wc"
},
"params": {},
"job_execution_info": {},
"args": []
}
},
bad_req_i=(1, "INVALID_DATA",
err_msg))
def test_non_dependency(self):
old_coord = mock.Mock()
new_coord = mock.Mock()
orig_dependencies = self.factory.dependencies
self.factory.update(old_coord, new_coord)
self.assertEqual(orig_dependencies, self.factory.dependencies)
def setUp(self):
super(TestJobExecUpdateValidation, self).setUp()
self._create_object_fun = mock.Mock()
self.scheme = je_schema.JOB_EXEC_UPDATE_SCHEMA
def mocked_user_output():
mocked_output_user = mock.Mock()
mocked_output_user.one.return_value = MockedUserData()
return mocked_output_user
def test_filename_with_no_uri(self):
# self.uri should always be unicode, the worst it should ever be is an
# empty string.
presenter = self.presenter(document_uris=[mock.Mock(uri="")])
assert presenter.filename == ""
