def test_property_mock_dynamic_set():
m = MagicMock()
p = PropertyMock(return_value=3)
type(m).foo = p
assert m.foo == 3
p.assert_called_once()
def test_get_scheduler(self):
"""Tests successful execution of the get_scheduler command."""
mock_options = self.setup_mock_options()
mock_proxy = create_autospec(spec=SchedulerProxy, instance=True)
mock_scheduler_client = create_autospec(spec=SchedulerClient,
instance=True)
mock_raw_url = PropertyMock(return_value="url")
mock_proxy.scheduler_client.return_value = mock_scheduler_client
mock_scheduler_client.raw_url = mock_raw_url
with contextlib.nested(
patch('twitter.common.app.get_options',
return_value=mock_options),
patch('apache.aurora.admin.admin.make_admin_client',
return_value=create_autospec(spec=AuroraClientAPI)),
patch('apache.aurora.admin.admin.CLUSTERS',
new=self.TEST_CLUSTERS),
) as (_, mock_make_admin_client, _):
api = mock_make_admin_client.return_value
api.scheduler_proxy = PropertyMock(return_value=mock_proxy)
get_scheduler([self.TEST_CLUSTER])
mock_raw_url.assert_called_once()
def test_generate_plan_persist_destroy(
self, mock_graph_tags: PropertyMock) -> None:
"""Test generate plan persist destroy."""
mock_graph_tags.return_value = {}
context = self._get_context(
extra_config_args={"persistent_graph_key": "test.json"})
context._persistent_graph = Graph.from_steps(
[Step.from_stack_name("removed", context)])
deploy_action = deploy.Action(context=context)
plan = cast(Plan,
deploy_action._Action__generate_plan()) # type: ignore
self.assertIsInstance(plan, Plan)
self.assertEqual(deploy.Action.DESCRIPTION, plan.description)
mock_graph_tags.assert_called_once()
# order is different between python2/3 so can't compare dicts
result_graph_dict = plan.graph.to_dict()
self.assertEqual(5, len(result_graph_dict))
self.assertEqual(set(), result_graph_dict["other"])
self.assertEqual(set(), result_graph_dict["removed"])
self.assertEqual(set(), result_graph_dict["vpc"])
self.assertEqual(set(["vpc"]), result_graph_dict["bastion"])
self.assertEqual(set(["bastion", "vpc"]), result_graph_dict["db"])
self.assertEqual(deploy_action._destroy_stack,
plan.graph.steps["removed"].fn)
self.assertEqual(deploy_action._launch_stack,
plan.graph.steps["vpc"].fn)
self.assertEqual(deploy_action._launch_stack,
plan.graph.steps["bastion"].fn)
self.assertEqual(deploy_action._launch_stack,
plan.graph.steps["db"].fn)
self.assertEqual(deploy_action._launch_stack,
plan.graph.steps["other"].fn)
def test_store_checks_fullness(self):
is_full_mock = PropertyMock()
with patch.object(_MetricCache, 'is_full', is_full_mock):
with patch('carbon.cache.events'):
metric_cache = _MetricCache()
metric_cache.store('foo', (123456, 1.0))
is_full_mock.assert_called_once()
def test_generate_plan_with_persist_no_lock_req(
self, mock_stack_action: PropertyMock,
mock_tags: PropertyMock) -> None:
"""Test generate plan with persist no lock req."""
mock_stack_action.return_value = MagicMock()
mock_tags.return_value = {}
context = mock_context(namespace="test",
extra_config_args=self.config_persist,
region=self.region)
persist_step = Step.from_stack_name("removed", context)
context._persistent_graph = Graph.from_steps([persist_step])
action = BaseAction(
context=context,
provider_builder=MockProviderBuilder(provider=self.provider,
region=self.region),
)
plan = action._generate_plan(include_persistent_graph=True,
require_unlocked=False)
self.assertIsInstance(plan, Plan)
mock_tags.assert_called_once()
# order is different between python2/3 so can't compare dicts
result_graph_dict = plan.graph.to_dict()
self.assertEqual(3, len(result_graph_dict))
self.assertEqual(set(), result_graph_dict["stack1"])
self.assertEqual(set(["stack1"]), result_graph_dict["stack2"])
self.assertEqual(set(), result_graph_dict["removed"])
self.assertEqual(BaseAction.DESCRIPTION, plan.description)
self.assertFalse(plan.require_unlocked)
def test_store_checks_fullness(self):
is_full_mock = PropertyMock()
with patch.object(_MetricCache, 'is_full', is_full_mock):
with patch('carbon.cache.events'):
metric_cache = _MetricCache()
metric_cache.store('foo', (123456, 1.0))
is_full_mock.assert_called_once()
def test_postprocess_testjob_save_attachments(
self,
results_url_mock,
get_from_artifactorial_mock,
assign_test_log_mock,
create_testrun_attachment_mock,
):
results_url_mock.return_value = "http://foo.com"
result_files = ResultFiles()
result_files.test_results = ExtractedResult()
result_files.test_results.contents = "abc"
result_files.test_results.length = 3
get_from_artifactorial_mock.return_value = result_files
testjob_mock = MagicMock()
id_mock = PropertyMock(return_value="999111")
type(testjob_mock).pk = id_mock
job_id_mock = PropertyMock(return_value="1234")
type(testjob_mock).job_id = job_id_mock
testjob_mock.backend = MagicMock()
implementation_type_mock = PropertyMock(return_value="lava")
type(testjob_mock.backend).implementation_type = implementation_type_mock
definition_mock = PropertyMock(return_value=JOB_DEFINITION)
type(testjob_mock).definition = definition_mock
self.plugin.postprocess_testjob(testjob_mock)
implementation_type_mock.assert_called_once()
definition_mock.assert_called()
results_url_mock.assert_called()
testjob_mock.testrun.metadata.__setitem__.assert_called()
testjob_mock.testrun.save.assert_called()
assign_test_log_mock.assert_called()
create_testrun_attachment_mock.assert_called()
def test_throw(self):
player = players.Thief()
rat = players.Rat()
dagger = MockHelper.get_mock_weapon()
not_a_dagger = MockHelper.get_mock_item()
#Must be carrying item
#Item must be a throwable weapon
#Should decrease number of items when thrown
#If none left then no longer carrying
#Not carrying
player.is_carrying = Mock(return_value=False)
self.assertFalse(player.throw(dagger, rat))
player.is_carrying.assert_called_once()
#Not a weapon
#TODO: Allow food to be thrown?
player.is_carrying = Mock(return_value=True)
self.assertFalse(player.throw(not_a_dagger, rat))
#Not throwable
#Mock class methods
mock_is_throwable = PropertyMock(return_value=True)
type(dagger).is_throwable = mock_is_throwable
self.assertTrue(player.throw(dagger, rat))
mock_is_throwable.assert_called_once()
def test_colorbar(self, quick_axis_options_view):
quick_axis_options_view.return_value = self.view
self.view.exec_ = MagicMock(return_value=True)
colorbar_log = PropertyMock()
type(self.model).colorbar_log = colorbar_log
self.view.log_scale.isChecked = Mock()
quick_axis_options('colorbar_range', self.model, True)
self.view.log_scale.isChecked.assert_called_once()
colorbar_log.assert_called_once()
def test_download_results_expired_url(self, get_mock):
requests_result_mock = Mock()
status_code_mock = PropertyMock(return_value=404)
type(requests_result_mock).status_code = status_code_mock
content_mock = PropertyMock(return_value=bytes())
type(requests_result_mock).content = content_mock
get_mock.return_value = requests_result_mock
results = self.plugin._download_results(RESULT_DICT)
status_code_mock.assert_called_once()
content_mock.assert_not_called()
self.assertEqual(self.plugin.tradefed_results_url, RESULT_URL)
self.assertIsNone(results.test_results)
self.assertIsNone(results.tradefed_stdout)
self.assertIsNone(results.tradefed_logcat)
def test_run_persist(
self,
mock_execute: MagicMock,
mock_unlock: MagicMock,
mock_lock: MagicMock,
mock_graph_tags: PropertyMock,
) -> None:
"""Test run persist."""
mock_graph_tags.return_value = {}
context = self._get_context(
extra_config_args={"persistent_graph_key": "test.json"})
context._persistent_graph = Graph.from_steps(
[Step.from_stack_name("removed", context)])
deploy_action = deploy.Action(context=context)
deploy_action.run()
mock_graph_tags.assert_called_once()
mock_lock.assert_called_once()
mock_execute.assert_called_once()
mock_unlock.assert_called_once()
def verify_super_property_called_with_wait(self, prop_name):
"""
Verifies that accessing the given property calls the equally
named property on the super class.
"""
with patch(
'__builtin__.super'
) as mock_super, patch.object(
self.instance, 'wait_for_angular'
) as mock_wait_for_angular:
# setup the mocked property
mock_prop = PropertyMock(name='super.{}'.format(prop_name))
setattr(type(mock_super.return_value), prop_name, mock_prop)
result = getattr(self.instance, prop_name)
mock_wait_for_angular.assert_called_once()
mock_super.assert_called_once_with(WebDriverMixin, self.instance)
mock_prop.assert_called_once()
self.assertIs(result, mock_prop.return_value)
def verify_super_property_called_with_wait(self, prop_name):
"""
Verifies that accessing the given property calls the equally
named property on the super class.
"""
with patch(
'__builtin__.super'
) as mock_super, patch.object(
self.instance, 'wait_for_angular'
) as mock_wait_for_angular:
# setup the mocked property
mock_prop = PropertyMock(name='super.{}'.format(prop_name))
setattr(type(mock_super.return_value), prop_name, mock_prop)
result = getattr(self.instance, prop_name)
mock_wait_for_angular.assert_called_once()
mock_super.assert_called_once_with(WebDriverMixin, self.instance)
mock_prop.assert_called_once()
self.assertIs(result, mock_prop.return_value)
def test_get_scheduler(self):
"""Tests successful execution of the get_scheduler command."""
mock_options = self.setup_mock_options()
mock_proxy = Mock(spec=SchedulerProxy)
mock_scheduler_client = Mock(spec=SchedulerClient)
mock_raw_url = PropertyMock(return_value="url")
mock_proxy.scheduler_client.return_value = mock_scheduler_client
mock_scheduler_client.raw_url = mock_raw_url
with contextlib.nested(
patch('twitter.common.app.get_options', return_value=mock_options),
patch('apache.aurora.client.commands.admin.AuroraClientAPI',
new=Mock(spec=AuroraClientAPI)),
patch('apache.aurora.client.commands.admin.CLUSTERS', new=self.TEST_CLUSTERS),
) as (_, api, _):
api.return_value.scheduler_proxy = PropertyMock(return_value=mock_proxy)
get_scheduler([self.TEST_CLUSTER])
mock_raw_url.assert_called_once()
def test_drink(self):
#is carrying
#has 1 left
#Not carrying
potion = potions.StrengthPotion()
self.assertEqual(potion.count, 1)
player = Mock()
mock_is_carrying = PropertyMock(return_value=False)
player.is_carrying = mock_is_carrying
self.assertFalse(potion.drink(player))
mock_is_carrying.assert_called_once()
self.assertEqual(potion.count, 1)
#Carrying
mock_is_carrying.return_value = True
self.assertTrue(potion.drink(player))
self.assertEqual(potion.count, 0)
#None left
self.assertFalse(potion.drink(player))
