def test_follow_redirects(self):
finder = URLFinder()
mock_response = MagicMock()
mock_response_url = PropertyMock()
type(mock_response).url = mock_response_url
with patch("requests.get", MagicMock(return_value=mock_response)) as mock_get:
# A request is sent to the URL. If there was a redirect return the
# final URL.
mock_response_url.return_value = "http://finalurl.com"
self.assertEquals(
finder.follow_redirects("http://redirects.to"),
"http://finalurl.com",
)
self.assertEquals(mock_get.call_count, 1)
self.assertEquals(mock_response_url.call_count, 1)
# If there was no redirect return the original URL.
self.assertEquals(
finder.follow_redirects("http://finalurl.com"),
"http://finalurl.com",
)
self.assertEquals(mock_get.call_count, 2)
self.assertEquals(mock_response_url.call_count, 2)
with patch("requests.get", MagicMock(side_effect=requests.RequestException)) as mock_get:
# If request failed return None
self.assertEquals(
finder.follow_redirects("http://redirects.to"),
None,
)
self.assertEquals(mock_get.call_count, 1)
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_load_one_workspace(self, get_ws_handle_mock, load_mock, process_limits):
# Create a view that will return a path on call to get_workspace_to_load_path
tempdir = gettempdir() # To ensure sample paths are valid on platform of execution
path_to_nexus = join(tempdir, 'cde.nxs')
workspace_name = 'cde'
self.view.get_workspace_efixed = mock.Mock(return_value=(1.845, False))
ws_mock = mock.Mock(spec=Workspace)
get_ws_handle_mock.return_value = ws_mock
e_fixed = PropertyMock()
e_mode = PropertyMock(return_value="Indirect")
ef_defined = PropertyMock(return_value=False)
type(ws_mock).e_fixed = e_fixed
type(ws_mock).e_mode = e_mode
type(ws_mock).ef_defined = ef_defined
with patch('mslice.models.workspacemanager.workspace_algorithms.get_workspace_handle') as gwh:
gwh.return_value = ws_mock
limits = PropertyMock(side_effect=({} if i < 2 else {'DeltaE':[-1, 1]} for i in range(6)))
type(ws_mock).limits = limits
e_fixed.return_value = 1.845
self.presenter.load_workspace([path_to_nexus])
load_mock.assert_called_with(filename=path_to_nexus, output_workspace=workspace_name)
e_fixed.assert_has_calls([call(1.845), call()])
process_limits.assert_called_once_with(ws_mock)
self.main_presenter.show_workspace_manager_tab.assert_called_once()
self.main_presenter.show_tab_for_workspace.assert_called_once()
self.main_presenter.update_displayed_workspaces.assert_called_once()
def test_are_creds_valid_with_invalid_creds(self):
with patch.object(github.Github, 'get_user') as patched_get_user:
mocked_login = PropertyMock()
mocked_login.side_effect = github.BadCredentialsException(401, 'dummy data')
type(patched_get_user.return_value).login = mocked_login
self.assertFalse(self.backend.are_creds_valid())
def _retrieve_content(self):
about_mock = PropertyMock(name="about_mock")
about_mock.version = "5.5.99"
about_mock.build = "999"
content_mock = MagicMock(name="content")
content_mock.about = about_mock
return content_mock
def test_propertymock_returnvalue(self):
m = MagicMock()
p = PropertyMock()
type(m).foo = p
returned = m.foo
p.assert_called_once_with()
self.assertIsInstance(returned, MagicMock)
self.assertNotIsInstance(returned, PropertyMock)
def test_should_initialize_logging_with_current_configuration(self, mock_config, mock_initialize_logging):
config_properties = PropertyMock()
config_properties.log_file = '/foo/bar/baz.log'
mock_config.return_value = config_properties
livestatus_service.initialize('/foo/bar/config.cfg')
self.assertEqual(
mock_initialize_logging.call_args, call(config_properties.log_file))
def test(self, get_config):
mock_configuration = PropertyMock()
mock_configuration.livestatus_socket = './livestatus_socket'
get_config.return_value = mock_configuration
with LiveServer() as liveserver:
with LiveSocket('./livestatus_socket', '{}') as livesocket:
result = urlopen('{0}cmd?q=DISABLE_HOST_NOTIFICATIONS;devica01'.format(liveserver.url))
self.assertEqual(result.read(), b'OK\n')
written_to_socket = livesocket.incoming.get()
self.assertTrue('DISABLE_HOST_NOTIFICATIONS;devica01' in written_to_socket)
def test_get_config_xml(self):
expected_config_xml = "<Sample Config XML/>"
p = PropertyMock(return_value=expected_config_xml)
mock_data_io = MagicMock()
type(mock_data_io).config_xml = p
j = vJob (mock_data_io, None)
self.assertEqual(j.config_xml, expected_config_xml)
p.assert_called_with()
def test_set_config_xml(self):
expected_config_xml = "<Sample Config XML/>"
mock_data_io = MagicMock()
p = PropertyMock(return_value=expected_config_xml)
type(mock_data_io).config_xml = p
v = vView(mock_data_io, None)
v.config_xml = expected_config_xml
self.assertEqual(p.call_count, 1)
p.assert_called_once_with(expected_config_xml)
def test_is_supported(self):
input_mock = PropertyMock(return_value="coffee")
class IsSupportedTestCompiler(BaseCompiler):
input_extension = input_mock
compiler = IsSupportedTestCompiler()
self.assertEqual(compiler.is_supported("dummy.coffee"), True)
self.assertEqual(compiler.is_supported("dummy.js"), False)
input_mock.assert_called_with()
def test_dont_access_source():
"""
Touching the source may trigger an unneeded query.
See <https://github.com/matthewwithanm/django-imagekit/issues/295>
"""
pmock = PropertyMock()
pmock.__get__ = Mock()
with patch.object(Photo, 'original_image', pmock):
photo = Photo() # noqa
assert_false(pmock.__get__.called)
def test_get_config_xml(self):
expected_xml = "<sample_xml/>"
p = PropertyMock(return_value=expected_xml)
mock_data_io = MagicMock()
type(mock_data_io).config_xml = p
v = vView(mock_data_io, None)
actual_xml = v.config_xml
self.assertEqual(actual_xml, expected_xml)
p.assert_called_once_with()
def test_compute_random_record_name(self):
someuuid = "someuuid"
domain = {"name": "domain"}
uuid1_m = self.create_patch("uuid.uuid1")
uuid_m = Mock()
hex_m = PropertyMock()
type(uuid_m).hex = hex_m
uuid1_m.return_value = uuid_m
hex_m.return_value = someuuid
self.assertEqual(compute_random_record_name(domain), someuuid)
def test_commands_waypoints(self, commands_mock):
next_mock = PropertyMock(return_value=1)
type(commands_mock.return_value).next = next_mock
self.assertEqual(self.vehicle.get_next_waypoint(), 1)
self.vehicle.set_next_waypoint()
next_mock.assert_any_call(2)
self.vehicle.set_next_waypoint(waypoint=0)
next_mock.assert_any_call(0)
commands_mock.return_value.configure_mock(count=2)
self.assertEqual(self.vehicle.count_waypoints(), 2)
def test(self, get_config):
mock_configuration = PropertyMock()
mock_configuration.livestatus_socket = './livestatus_socket'
get_config.return_value = mock_configuration
with LiveServer() as liveserver:
socket_response = '[["host_name","notifications_enabled"],["devica01", 1], ["tuvdbs05",1], ["tuvdbs06",1]]'
with LiveSocket('./livestatus_socket', socket_response) as livesocket:
api_call_result = urlopen('{0}query?q=GET%20hosts&key=host_name'.format(liveserver.url))
actual_api_response = json.loads(api_call_result.read().decode('utf-8'))
self.assertEqual(expected_api_call_response, actual_api_response)
written_to_socket = livesocket.incoming.get()
self.assertTrue('GET hosts' in written_to_socket and 'OutputFormat: json' in written_to_socket)
def test_arm_and_takeoff(self):
with patch("sys.stdout"):
with patch.object(Mock_Vehicle, "check_arming", return_value=False):
# The method must raise an exception when the vehicle is not
# ready to be armed.
with self.assertRaises(RuntimeError):
self.mission.arm_and_takeoff()
params = {
"spec": Mock_Vehicle,
"check_arming.return_value": True,
"simple_takeoff.return_value": False
}
with patch.object(self.mission, "vehicle", **params) as vehicle_mock:
armed_mock = PropertyMock(side_effect=[False, False, True])
type(vehicle_mock).armed = armed_mock
with patch.object(time, "sleep") as sleep_mock:
# A ground vehicle that does not take off should have the
# appropriate calls.
self.mission.arm_and_takeoff()
armed_mock.assert_has_calls([call(True), call(), call()])
sleep_mock.assert_any_call(1)
self.assertEqual(vehicle_mock.speed, self.mission.speed)
alt = self.settings.get("altitude")
undershoot = self.settings.get("altitude_undershoot")
loc_ground = LocationGlobalRelative(0.0, 0.0, 0.0)
loc_under = LocationGlobalRelative(0.0, 0.0, undershoot * alt - 0.5)
loc_takeoff = LocationGlobalRelative(0.0, 0.0, alt)
locs = [loc_ground, loc_ground, loc_under, loc_under, loc_takeoff]
global_relative_frame_mock = PropertyMock(side_effect=locs)
location_mock = MagicMock()
type(location_mock).global_relative_frame = global_relative_frame_mock
params = {
"spec": Mock_Vehicle,
"check_arming.return_value": True,
"simple_takeoff.return_value": True,
"location": location_mock
}
with patch.object(self.mission, "vehicle", **params) as vehicle_mock:
armed_mock = PropertyMock(side_effect=[False, True])
type(vehicle_mock).armed = armed_mock
with patch.object(time, "sleep") as sleep_mock:
# A flying vehicle that takes off has the correct calls.
self.mission.arm_and_takeoff()
self.assertEqual(global_relative_frame_mock.call_count, 5)
self.assertEqual(sleep_mock.call_count, 2)
def test(self, get_config):
mock_configuration = PropertyMock()
mock_configuration.livestatus_socket = "./livestatus_socket"
get_config.return_value = mock_configuration
with LiveServer() as liveserver:
socket_response = '[["host_name","notifications_enabled"],["devica01", 1], ["tuvdbs05",1], ["tuvdbs06",1]]'
with LiveSocket("./livestatus_socket", socket_response) as livesocket:
api_call_result = urlopen("{0}query?q=GET%20hosts".format(liveserver.url))
actual_result = json.loads(api_call_result.read().decode("utf-8"))
expected_result = json.loads(expected_api_call_response)
diff = [element for element in actual_result if element not in expected_result]
diff.extend([element for element in expected_result if element not in actual_result])
self.assertEqual(diff, [], "Found difference between expected and actual result : %s" % diff)
written_to_socket = livesocket.incoming.get()
self.assertTrue("GET hosts" in written_to_socket and "OutputFormat: json" in written_to_socket)
def mockery(self, property_name, property_return_value=None):
"""
Return property of *property_name* on self.table with return value of
*property_return_value*.
"""
# mock <a:tbl> element of Table so we can mock its properties
tbl = MagicMock()
self.table._tbl_elm = tbl
# create a suitable mock for the property
property_ = PropertyMock()
if property_return_value:
property_.return_value = property_return_value
# and attach it the the <a:tbl> element object (class actually)
setattr(type(tbl), property_name, property_)
return property_
def setUp(self):
super(TestGeometry, self).setUp()
# Geometry object to use in the tests.
self.geometry = Geometry()
# Delta values for approximate equality checks.
# The default values handle float inaccuracies that may be caused by
# conversions in the geometry class.
self.dist_delta = sys.float_info.epsilon * 10
self.coord_delta = self.dist_delta
self.angle_delta = sys.float_info.epsilon * 10
# Create a mock version of a `Locations` object. The location frames
# have property mocks that can be configured to return a specific
# location value.
self.locations_mock = Mock(spec_set=Locations)
self.relative_mock = PropertyMock()
self.global_mock = PropertyMock()
self.local_mock = PropertyMock()
type(self.locations_mock).global_relative_frame = self.relative_mock
type(self.locations_mock).global_frame = self.global_mock
type(self.locations_mock).local_frame = self.local_mock
# Location objects that can be used by type checking tests, where the
# coordinate values do not matter at all.
self.local_location = LocationLocal(1.0, 2.0, 3.0)
self.global_location = LocationGlobal(4.0, 5.0, 6.0)
self.relative_location = LocationGlobalRelative(7.0, 8.0, 9.0)
def test_extract(self):
untiny = Untiny()
mock_response = MagicMock()
mock_response_text = PropertyMock()
type(mock_response).text = mock_response_text
untiny.is_tiny = MagicMock()
with patch("requests.get", MagicMock(return_value=mock_response)) as mock_get:
# If the URL is tiny send a request to untiny.me to extract
# full URL
untiny.is_tiny.return_value = True
mock_response_text.return_value = "http://foo.com"
self.assertEquals(
untiny.extract("http://2pl.us/234"),
"http://foo.com",
)
self.assertEquals(mock_get.call_count, 1)
self.assertEquals(mock_response_text.call_count, 1)
# Check with another URL
mock_response_text.return_value = "http://bar.com"
self.assertEquals(
untiny.extract("http://1u.ro/123"),
"http://bar.com",
)
self.assertEquals(mock_get.call_count, 2)
self.assertEquals(mock_response_text.call_count, 2)
# If the URL is not tiny return it unchanged.
untiny.is_tiny.return_value = False
self.assertEquals(
untiny.extract("http://example.com"),
"http://example.com",
)
self.assertEquals(mock_get.call_count, 2)
with patch("requests.get", MagicMock(side_effect=requests.RequestException)) as mock_get:
# If a request to untiny.me fails return the original URL.
untiny.is_tiny.return_value = True
self.assertEquals(
untiny.extract("http://1u.ro/123"),
"http://1u.ro/123",
)
self.assertEquals(mock_get.call_count, 1)
def test(self, get_config):
mock_configuration = PropertyMock()
mock_configuration.livestatus_socket = './livestatus_socket'
get_config.return_value = mock_configuration
with LiveServer() as liveserver:
with LiveSocket('./livestatus_socket', '{}') as livesocket:
url = '{0}cmd'.format(liveserver.url)
parameters = {'q': 'DISABLE_HOST_NOTIFICATIONS;devica01',
}
data = urlencode(parameters)
binary_data = data.encode('utf-8')
request = Request(url, binary_data)
response = urlopen(request)
self.assertEquals(response.read(), b'OK\n')
written_to_socket = livesocket.incoming.get()
self.assertTrue('DISABLE_HOST_NOTIFICATIONS;devica01' in written_to_socket)
def mocked_response(status_code=200):
"""
Return mocked response instance
>>> mocked_response(status_code=404).code == 404
True
>>> mocked_response(status_code=404).code == 200
False
>>> mocked_response(status_code=404).read() == 'mocked body'
True
"""
code = PropertyMock()
code.return_value = status_code
response = MagicMock()
response.read.return_value = 'mocked body'
type(response).code = code
return response
def test_delete_will_retry():
global sequential_values, retry_policy
retry_policy = MagicMock()
retry_policy.should_retry.return_value = True
retry_policy.seconds_to_sleep.return_value = 0.01
with patch('requests.delete') as patched_delete:
# When we call assert_equals in this unit test, the side_effect is executed.
# So, the last status_code should be repeated.
sequential_values = [500, 200, 200]
pm = PropertyMock()
pm.side_effect = return_sequential
type(patched_delete.return_value).status_code = pm
client = ReliableHttpClient("http://url.com", {}, "username", "password", retry_policy)
result = client.delete("r", [200])
assert_equals(200, result.status_code)
retry_policy.should_retry.assert_called_once_with(500, 0)
retry_policy.seconds_to_sleep.assert_called_once_with(0)
def test_get_will_retry():
global sequential_values, retry_policy
retry_policy = MagicMock()
retry_policy.should_retry.return_value = True
retry_policy.seconds_to_sleep.return_value = 0.01
with patch('requests.get') as patched_get:
# When we call assert_equals in this unit test, the side_effect is executed.
# So, the last status_code should be repeated.
sequential_values = [500, 200, 200]
pm = PropertyMock()
pm.side_effect = return_sequential
type(patched_get.return_value).status_code = pm
client = ReliableHttpClient(endpoint, {}, retry_policy)
result = client.get("r", [200])
assert_equals(200, result.status_code)
retry_policy.should_retry.assert_called_once_with(500, False, 0)
retry_policy.seconds_to_sleep.assert_called_once_with(0)
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_update_stores_tp(plugin_mock):
"""Site wide update_stores"""
command = Command()
tp = PropertyMock()
tp.configure_mock(
**{'pootle_path': 'FOO',
'project': 23})
command.handle_translation_project(tp, **DEFAULT_OPTIONS)
assert (
list(plugin_mock.return_value.add.call_args)
== [(), {'pootle_path': 'FOO*', 'update': 'pootle'}])
assert (
list(plugin_mock.return_value.rm.call_args)
== [(), {'pootle_path': 'FOO*', 'update': 'pootle'}])
assert (
list(plugin_mock.return_value.resolve.call_args)
== [(), {'pootle_path': 'FOO*', 'merge': True}])
assert (
list(plugin_mock.return_value.sync.call_args)
== [(), {'pootle_path': 'FOO*', 'update': 'pootle'}])
assert list(plugin_mock.call_args) == [(23,), {}]
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_get_keyring_success(self):
key = "key"
tsigsecret = "secret"
conf_m = self.create_patch("yandex_designate.backend.dynamicdns.cfg.CONF")
read_tsigkey_m = self.create_patch("yandex_designate.backend.dynamicdns.read_tsigkey")
parse_tsigkeyring_m = self.create_patch("dns.tsigkeyring.from_text")
keyfile = Mock()
config = Mock()
keyring_m = Mock()
key_m = PropertyMock(return_value=key)
keyfile_m = PropertyMock(return_value=keyfile)
type(config).dyndns_key = key_m
type(config).dyndns_key_file = keyfile_m
conf_m.__getitem__.return_value = config
read_tsigkey_m.return_value = ("md5", tsigsecret)
parse_tsigkeyring_m.return_value = keyring_m
self.assertEqual(get_keyring(), keyring_m)
key_m.assert_called_with()
keyfile_m.assert_called_with()
read_tsigkey_m.assert_called_with(keyfile, key)
parse_tsigkeyring_m.assert_called_with({key: tsigsecret})
class Test_AOVManager(unittest.TestCase):
"""Test ht.sohohooks.manager.AOVManager object."""
def setUp(self):
super(Test_AOVManager, self).setUp()
self.mock_api = MagicMock()
self.mock_settings = MagicMock()
self.mock_soho = MagicMock()
modules = {
"IFDapi": self.mock_api,
"IFDsettings": self.mock_settings,
"soho": self.mock_soho
}
self.patcher = patch.dict("sys.modules", modules)
self.patcher.start()
def tearDown(self):
super(Test_AOVManager, self).tearDown()
self.patcher.stop()
@patch("ht.sohohooks.aovs.manager.AOVManager._init_from_files")
def test___init__(self, mock_init):
mgr = manager.AOVManager()
self.assertEqual(mgr._aovs, {})
self.assertEqual(mgr._groups, {})
self.assertIsNone(mgr._interface)
mock_init.assert_called()
# _build_intrinsic_groups
@patch("ht.sohohooks.aovs.manager.IntrinsicAOVGroup", autospec=True)
@patch.object(manager.AOVManager, "add_group")
@patch.object(manager.AOVManager, "groups", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "aovs", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "__init__", lambda x: None)
def test__build_intrinsic_groups__new_group(self, mock_aovs, mock_groups,
mock_add, mock_int_group):
mock_aov = MagicMock(spec=manager.AOV)
mock_aov.intrinsics = ["int1"]
mock_groups.return_value = {}
mock_aovs.return_value = {MagicMock(spec=str): mock_aov}
mgr = manager.AOVManager()
mgr._build_intrinsic_groups()
mock_int_group.assert_called_with("i:int1")
mock_add.assert_called_with(mock_int_group.return_value)
mock_int_group.return_value.aovs.append.assert_called_with(mock_aov)
@patch.object(manager.AOVManager, "add_group")
@patch.object(manager.AOVManager, "groups", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "aovs", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "__init__", lambda x: None)
def test__build_intrinsic_groups__existing_group(self, mock_aovs,
mock_groups, mock_add):
mock_aov = MagicMock(spec=manager.AOV)
mock_aov.intrinsics = ["int1"]
mock_group = MagicMock(spec=aov.IntrinsicAOVGroup)
mock_groups.return_value = {"i:int1": mock_group}
mock_aovs.return_value = {MagicMock(spec=str): mock_aov}
mgr = manager.AOVManager()
mgr._build_intrinsic_groups()
mock_group.aovs.append.assert_called_with(mock_aov)
# _init_from_files
@patch.object(manager.AOVManager, "_build_intrinsic_groups")
@patch.object(manager.AOVManager, "_merge_readers")
@patch("ht.sohohooks.aovs.manager.AOVFile", autospec=True)
@patch("ht.sohohooks.aovs.manager._find_aov_files")
@patch.object(manager.AOVManager, "__init__", lambda x: None)
def test__init_from_files(self, mock_find, mock_file, mock_merge,
mock_build):
mock_path = MagicMock(spec=str)
mock_find.return_value = [mock_path]
mgr = manager.AOVManager()
mgr._init_from_files()
mock_file.assert_called_with(mock_path)
mock_merge.assert_called_with([mock_file.return_value])
mock_build.assert_called()
# _init_group_members
@patch.object(manager.AOVManager, "aovs", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "__init__", lambda x: None)
def test__init_group_members(self, mock_aovs):
mock_varname1 = MagicMock(spec=str)
mock_varname2 = MagicMock(spec=str)
mock_group = MagicMock(spec=manager.AOVGroup)
mock_group.includes = [mock_varname1, mock_varname2]
mock_aov = MagicMock(spec=manager.AOV)
mock_aovs.return_value = {
mock_varname1: mock_aov,
}
mgr = manager.AOVManager()
mgr._init_group_members(mock_group)
mock_group.aovs.append.assert_called_with(mock_aov)
# _init_reader_aovs
@patch.object(manager.AOVManager, "add_aov")
@patch.object(manager.AOVManager, "aovs", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "__init__", lambda x: None)
def test__init_reader_aovs__new_aov(self, mock_aovs, mock_add):
mock_aov = MagicMock(spec=manager.AOV)
mock_reader = MagicMock(spec=manager.AOVFile)
mock_reader.aovs = [mock_aov]
mock_aovs.return_value = {}
mgr = manager.AOVManager()
mgr._init_reader_aovs(mock_reader)
mock_add.assert_called_with(mock_aov)
@patch.object(manager.AOVManager, "add_aov")
@patch.object(manager.AOVManager, "aovs", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "__init__", lambda x: None)
def test__init_reader_aovs__matches_existing_priority_same(
self, mock_aovs, mock_add):
mock_varname = MagicMock(spec=str)
mock_priority = MagicMock(spec=int)
mock_new_aov = MagicMock(spec=manager.AOV)
mock_new_aov.variable = mock_varname
mock_new_aov.priority = mock_priority
mock_existing_aov = MagicMock(spec=manager.AOV)
mock_existing_aov.variable = mock_varname
mock_existing_aov.priority = mock_priority
mock_reader = MagicMock(spec=manager.AOVFile)
mock_reader.aovs = [mock_new_aov]
mock_aovs.return_value = {mock_varname: mock_existing_aov}
mgr = manager.AOVManager()
mgr._init_reader_aovs(mock_reader)
mock_add.assert_not_called()
@patch.object(manager.AOVManager, "add_aov")
@patch.object(manager.AOVManager, "aovs", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "__init__", lambda x: None)
def test__init_reader_aovs__matches_existing_priority_lower(
self, mock_aovs, mock_add):
mock_varname = MagicMock(spec=str)
mock_new_aov = MagicMock(spec=manager.AOV)
mock_new_aov.variable = mock_varname
mock_new_aov.priority = 3
mock_existing_aov = MagicMock(spec=manager.AOV)
mock_existing_aov.variable = mock_varname
mock_existing_aov.priority = 2
mock_reader = MagicMock(spec=manager.AOVFile)
mock_reader.aovs = [mock_new_aov]
mock_aovs.return_value = {mock_varname: mock_existing_aov}
mgr = manager.AOVManager()
mgr._init_reader_aovs(mock_reader)
mock_add.assert_called_with(mock_new_aov)
# _init_reader_groups
@patch.object(manager.AOVManager, "add_group")
@patch.object(manager.AOVManager, "groups", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "_init_group_members")
@patch.object(manager.AOVManager, "__init__", lambda x: None)
def test__init_reader_groups__new_group(self, mock_init, mock_groups,
mock_add):
mock_group = MagicMock(spec=manager.AOVGroup)
mock_reader = MagicMock(spec=manager.AOVFile)
mock_reader.groups = [mock_group]
mock_groups.return_value = {}
mgr = manager.AOVManager()
mgr._init_reader_groups(mock_reader)
mock_init.assert_called_with(mock_group)
mock_add.assert_called_with(mock_group)
@patch.object(manager.AOVManager, "add_group")
@patch.object(manager.AOVManager, "groups", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "_init_group_members")
@patch.object(manager.AOVManager, "__init__", lambda x: None)
def test__init_reader_groups__matches_existing_priority_same(
self, mock_init, mock_groups, mock_add):
mock_group_name = MagicMock(spec=str)
mock_priority = MagicMock(spec=int)
mock_new_group = MagicMock(spec=manager.AOVGroup)
mock_new_group.name = mock_group_name
mock_new_group.priority = mock_priority
mock_reader = MagicMock(spec=manager.AOVFile)
mock_reader.groups = [mock_new_group]
mock_existing_group = MagicMock(spec=manager.AOVGroup)
mock_existing_group.name = mock_group_name
mock_existing_group.priority = mock_priority
mock_groups.return_value = {mock_group_name: mock_existing_group}
mgr = manager.AOVManager()
mgr._init_reader_groups(mock_reader)
mock_init.assert_called_with(mock_new_group)
mock_add.assert_not_called()
@patch.object(manager.AOVManager, "add_group")
@patch.object(manager.AOVManager, "groups", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "_init_group_members")
@patch.object(manager.AOVManager, "__init__", lambda x: None)
def test__init_reader_groups__matches_existing_priority_lower(
self, mock_init, mock_groups, mock_add):
mock_group_name = MagicMock(spec=str)
mock_new_group = MagicMock(spec=manager.AOV)
mock_new_group.name = mock_group_name
mock_new_group.priority = 3
mock_reader = MagicMock(spec=manager.AOVFile)
mock_reader.groups = [mock_new_group]
mock_existing_group = MagicMock(spec=manager.AOV)
mock_existing_group.name = mock_group_name
mock_existing_group.priority = 2
mock_groups.return_value = {mock_group_name: mock_existing_group}
mgr = manager.AOVManager()
mgr._init_reader_groups(mock_reader)
mock_init.assert_called_with(mock_new_group)
mock_add.assert_called_with(mock_new_group)
# _merge_readers
@patch.object(manager.AOVManager, "_init_reader_groups")
@patch.object(manager.AOVManager, "_init_reader_aovs")
@patch.object(manager.AOVManager, "__init__", lambda x: None)
def test__merge_readers(self, mock_init_aovs, mock_init_groups):
mock_reader = MagicMock(spec=manager.AOVFile)
readers = [mock_reader]
mgr = manager.AOVManager()
mgr._merge_readers(readers)
mock_init_aovs.assert_called_with(mock_reader)
mock_init_groups.assert_called_with(mock_reader)
# properties
@patch.object(manager.AOVManager, "__init__", lambda x: None)
def test_aovs(self):
mock_value = MagicMock(spec=list)
mgr = manager.AOVManager()
mgr._aovs = mock_value
self.assertEqual(mgr.aovs, mock_value)
@patch.object(manager.AOVManager, "__init__", lambda x: None)
def test_groups(self):
mock_value = MagicMock(spec=list)
mgr = manager.AOVManager()
mgr._groups = mock_value
self.assertEqual(mgr.groups, mock_value)
@patch.object(manager.AOVManager, "__init__", lambda x: None)
def test_interface(self):
mgr = manager.AOVManager()
mgr._interface = None
self.assertIsNone(mgr.interface)
# add_aov
@patch.object(manager.AOVManager,
"interface",
new_callable=PropertyMock(return_value=None))
@patch.object(manager.AOVManager, "aovs", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "__init__", lambda x: None)
def test_add_aov__no_interface(self, mock_aovs, mock_interface):
aovs = {}
mock_aovs.return_value = aovs
mock_aov = MagicMock(spec=manager.AOV)
mgr = manager.AOVManager()
mgr.add_aov(mock_aov)
self.assertEqual(aovs, {mock_aov.variable: mock_aov})
@patch.object(manager.AOVManager, "interface", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "aovs", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "__init__", lambda x: None)
def test_add_aov__interface(self, mock_aovs, mock_interface):
interface = MagicMock()
mock_interface.return_value = interface
aovs = {}
mock_aovs.return_value = aovs
mock_aov = MagicMock(spec=manager.AOV)
mgr = manager.AOVManager()
mgr.add_aov(mock_aov)
self.assertEqual(aovs, {mock_aov.variable: mock_aov})
interface.aovAddedSignal.emit.assert_called_with(mock_aov)
# add_aovs_to_ifd
@patch.object(manager.AOVManager, "__init__", lambda x: None)
def test_add_aovs_to_ifd__no_parms(self):
mock_wrangler = MagicMock()
mock_cam = MagicMock()
mock_cam.wrangle.return_value = {}
mock_now = MagicMock(spec=float)
mgr = manager.AOVManager()
calls = [
call("enable_auto_aovs", "int", [1], skipdefault=False),
call("auto_aovs", "str", [""], skipdefault=False)
]
mgr.add_aovs_to_ifd(mock_wrangler, mock_cam, mock_now)
self.mock_soho.SohoParm.assert_has_calls(calls)
@patch.object(manager.AOVManager, "get_aovs_from_string")
@patch.object(manager.AOVManager, "__init__", lambda x: None)
def test_add_aovs_to_ifd__disabled(self, mock_get):
mock_wrangler = MagicMock()
mock_enable_result = MagicMock()
mock_enable_result.Value = [0]
mock_cam = MagicMock()
mock_cam.wrangle.return_value = {
"enable_auto_aovs": mock_enable_result,
}
mock_now = MagicMock(spec=float)
mgr = manager.AOVManager()
calls = [
call("enable_auto_aovs", "int", [1], skipdefault=False),
call("auto_aovs", "str", [""], skipdefault=False)
]
mgr.add_aovs_to_ifd(mock_wrangler, mock_cam, mock_now)
self.mock_soho.SohoParm.assert_has_calls(calls)
@patch("ht.sohohooks.aovs.manager.flatten_aov_items")
@patch.object(manager.AOVManager, "get_aovs_from_string")
@patch.object(manager.AOVManager, "__init__", lambda x: None)
def test_add_aovs_to_ifd__non_opid(self, mock_get, mock_flattened):
mock_aov = MagicMock(spec=manager.AOV)
mock_wrangler = MagicMock()
mock_enable_result = MagicMock()
mock_enable_result.Value = [1]
mock_aovs_result = MagicMock()
mock_cam = MagicMock()
mock_cam.wrangle.return_value = {
"enable_auto_aovs": mock_enable_result,
"auto_aovs": mock_aovs_result,
}
mock_get.return_value = [mock_aov]
mock_now = MagicMock(spec=float)
mock_flattened.return_value = (mock_aov, )
mgr = manager.AOVManager()
calls = [
call("enable_auto_aovs", "int", [1], skipdefault=False),
call("auto_aovs", "str", [""], skipdefault=False)
]
mgr.add_aovs_to_ifd(mock_wrangler, mock_cam, mock_now)
self.mock_soho.SohoParm.assert_has_calls(calls)
mock_get.assert_called_with(mock_aovs_result.Value[0])
mock_aov.write_to_ifd.assert_called_with(mock_wrangler, mock_cam,
mock_now)
self.mock_api.ray_comment.assert_not_called()
@patch("ht.sohohooks.aovs.manager.flatten_aov_items")
@patch.object(manager.AOVManager, "get_aovs_from_string")
@patch.object(manager.AOVManager, "__init__", lambda x: None)
def test_add_aovs_to_ifd__opid(self, mock_get, mock_flattened):
mock_aov = MagicMock(spec=manager.AOV)
mock_aov.variable = "Op_Id"
mock_wrangler = MagicMock()
mock_enable_result = MagicMock()
mock_enable_result.Value = [1]
mock_aovs_result = MagicMock()
mock_cam = MagicMock()
mock_cam.wrangle.return_value = {
"enable_auto_aovs": mock_enable_result,
"auto_aovs": mock_aovs_result,
}
mock_get.return_value = [mock_aov]
mock_now = MagicMock(spec=float)
mock_flattened.return_value = (mock_aov, )
mgr = manager.AOVManager()
calls = [
call("enable_auto_aovs", "int", [1], skipdefault=False),
call("auto_aovs", "str", [""], skipdefault=False)
]
mgr.add_aovs_to_ifd(mock_wrangler, mock_cam, mock_now)
self.mock_soho.SohoParm.assert_has_calls(calls)
mock_get.assert_called_with(mock_aovs_result.Value[0])
mock_aov.write_to_ifd.assert_called_with(mock_wrangler, mock_cam,
mock_now)
self.mock_api.ray_comment.assert_called()
self.assertTrue(self.mock_settings._GenerateOpId)
# add_group
@patch.object(manager.AOVManager,
"interface",
new_callable=PropertyMock(return_value=None))
@patch.object(manager.AOVManager, "groups", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "__init__", lambda x: None)
def test_add_group__no_interface(self, mock_groups, mock_interface):
groups = {}
mock_groups.return_value = groups
mock_group = MagicMock(spec=manager.AOVGroup)
mgr = manager.AOVManager()
mgr.add_group(mock_group)
self.assertEqual(groups, {mock_group.name: mock_group})
@patch.object(manager.AOVManager, "interface", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "groups", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "__init__", lambda x: None)
def test_add_group__interface(self, mock_groups, mock_interface):
interface = MagicMock()
mock_interface.return_value = interface
groups = {}
mock_groups.return_value = groups
mock_group = MagicMock(spec=manager.AOVGroup)
mgr = manager.AOVManager()
mgr.add_group(mock_group)
self.assertEqual(groups, {mock_group.name: mock_group})
interface.groupAddedSignal.emit.assert_called_with(mock_group)
# clear
@patch.object(manager.AOVManager, "__init__", lambda x: None)
def test_clear(self):
mock_aovs = MagicMock(spec=dict)
mock_groups = MagicMock(spec=dict)
mgr = manager.AOVManager()
mgr._aovs = mock_aovs
mgr._groups = mock_groups
mgr.clear()
mock_aovs.clear.assert_called()
mock_groups.clear.assert_called()
# get_aovs_from_string
@patch.object(manager.AOVManager, "groups", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "aovs", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "__init__", lambda x: None)
def test_get_aovs_from_string__no_matches(self, mock_aovs, mock_groups):
mock_aovs.return_value = {}
mock_groups.return_value = {}
mgr = manager.AOVManager()
pattern = ""
result = mgr.get_aovs_from_string(pattern)
self.assertEqual(result, ())
@patch.object(manager.AOVManager, "groups", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "aovs", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "__init__", lambda x: None)
def test_get_aovs_from_string__aovs_match_spaces(self, mock_aovs,
mock_groups):
mock_aov_n = MagicMock(spec=manager.AOV)
mock_aov_p = MagicMock(spec=manager.AOV)
mock_aovs.return_value = {"N": mock_aov_n, "P": mock_aov_p}
mock_groups.return_value = {}
mgr = manager.AOVManager()
pattern = "N P R"
result = mgr.get_aovs_from_string(pattern)
self.assertEqual(result, (mock_aov_n, mock_aov_p))
@patch.object(manager.AOVManager, "groups", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "aovs", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "__init__", lambda x: None)
def test_get_aovs_from_string__aovs_match_commas(self, mock_aovs,
mock_groups):
mock_aov_n = MagicMock(spec=manager.AOV)
mock_aov_p = MagicMock(spec=manager.AOV)
mock_aovs.return_value = {"N": mock_aov_n, "P": mock_aov_p}
mock_groups.return_value = {}
mgr = manager.AOVManager()
pattern = "N,P,R"
result = mgr.get_aovs_from_string(pattern)
self.assertEqual(result, (mock_aov_n, mock_aov_p))
@patch.object(manager.AOVManager, "groups", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "aovs", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "__init__", lambda x: None)
def test_get_aovs_from_string__groups_match_spaces(self, mock_aovs,
mock_groups):
mock_group1 = MagicMock(spec=manager.AOVGroup)
mock_group2 = MagicMock(spec=manager.AOVGroup)
mock_aovs.return_value = {}
mock_groups.return_value = {
"group1": mock_group1,
"group2": mock_group2
}
mgr = manager.AOVManager()
pattern = "@group1 @group3 @group2"
result = mgr.get_aovs_from_string(pattern)
self.assertEqual(result, (mock_group1, mock_group2))
@patch.object(manager.AOVManager, "groups", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "aovs", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "__init__", lambda x: None)
def test_get_aovs_from_string__groups_match_commas(self, mock_aovs,
mock_groups):
mock_group1 = MagicMock(spec=manager.AOVGroup)
mock_group2 = MagicMock(spec=manager.AOVGroup)
mock_aovs.return_value = {}
mock_groups.return_value = {
"group1": mock_group1,
"group2": mock_group2
}
mgr = manager.AOVManager()
pattern = "@group1,@group3, @group2"
result = mgr.get_aovs_from_string(pattern)
self.assertEqual(result, (mock_group1, mock_group2))
# init_interface
@patch.object(manager.AOVManager, "__init__", lambda x: None)
def test_init_interface(self):
mock_utils = MagicMock()
modules = {"ht.ui.aovs.utils": mock_utils}
mgr = manager.AOVManager()
with patch.dict("sys.modules", modules):
mgr.init_interface()
self.assertEqual(mgr._interface,
mock_utils.AOVViewerInterface.return_value)
# load
@patch.object(manager.AOVManager, "_merge_readers")
@patch("ht.sohohooks.aovs.manager.AOVFile", autospec=True)
@patch.object(manager.AOVManager, "__init__", lambda x: None)
def test_load(self, mock_file, mock_merge):
mgr = manager.AOVManager()
mock_path = MagicMock(spec=str)
mgr.load(mock_path)
mock_file.assert_called_with(mock_path)
mock_merge.assert_called_with([mock_file.return_value])
# reload
@patch.object(manager.AOVManager, "_init_from_files")
@patch.object(manager.AOVManager, "clear")
@patch.object(manager.AOVManager, "__init__", lambda x: None)
def test_reload(self, mock_clear, mock_init):
mgr = manager.AOVManager()
mgr.reload()
mock_clear.assert_called()
mock_init.assert_called()
# remove_aov
@patch.object(manager.AOVManager, "interface", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "aovs", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "__init__", lambda x: None)
def test_remove_aov__no_match(self, mock_aovs, mock_interface):
mock_aov1 = MagicMock(spec=manager.AOV)
mock_aov2 = MagicMock(spec=manager.AOV)
aovs = {mock_aov2.variable: mock_aov2}
mock_aovs.return_value = aovs
mgr = manager.AOVManager()
mgr.remove_aov(mock_aov1)
self.assertEqual(aovs, {mock_aov2.variable: mock_aov2})
@patch.object(manager.AOVManager, "interface", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "aovs", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "__init__", lambda x: None)
def test_remove_aov__match_no_interface(self, mock_aovs, mock_interface):
mock_interface.return_value = None
mock_aov = MagicMock(spec=manager.AOV)
aovs = {mock_aov.variable: mock_aov}
mock_aovs.return_value = aovs
mgr = manager.AOVManager()
mgr.remove_aov(mock_aov)
self.assertEqual(aovs, {})
@patch.object(manager.AOVManager, "interface", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "aovs", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "__init__", lambda x: None)
def test_remove_aov__match_interface(self, mock_aovs, mock_interface):
interface = MagicMock()
mock_interface.return_value = interface
mock_aov = MagicMock(spec=manager.AOV)
aovs = {mock_aov.variable: mock_aov}
mock_aovs.return_value = aovs
mgr = manager.AOVManager()
mgr.remove_aov(mock_aov)
self.assertEqual(aovs, {})
interface.aovRemovedSignal.emit.assert_called_with(mock_aov)
# remove_group
@patch.object(manager.AOVManager, "interface", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "groups", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "__init__", lambda x: None)
def test_remove_group__no_match(self, mock_groups, mock_interface):
mock_group1 = MagicMock(spec=manager.AOVGroup)
mock_group2 = MagicMock(spec=manager.AOVGroup)
groups = {mock_group2.name: mock_group2}
mock_groups.return_value = groups
mgr = manager.AOVManager()
mgr.remove_group(mock_group1)
self.assertEqual(groups, {mock_group2.name: mock_group2})
@patch.object(manager.AOVManager, "interface", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "groups", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "__init__", lambda x: None)
def test_remove_group__match_no_interface(self, mock_groups,
mock_interface):
mock_interface.return_value = None
mock_group = MagicMock(spec=manager.AOVGroup)
groups = {mock_group.name: mock_group}
mock_groups.return_value = groups
mgr = manager.AOVManager()
mgr.remove_group(mock_group)
self.assertEqual(groups, {})
@patch.object(manager.AOVManager, "interface", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "groups", new_callable=PropertyMock)
@patch.object(manager.AOVManager, "__init__", lambda x: None)
def test_remove_group__match_interface(self, mock_groups, mock_interface):
interface = MagicMock()
mock_interface.return_value = interface
mock_group = MagicMock(spec=manager.AOVGroup)
groups = {mock_group.name: mock_group}
mock_groups.return_value = groups
mgr = manager.AOVManager()
mgr.remove_group(mock_group)
self.assertEqual(groups, {})
interface.groupRemovedSignal.emit.assert_called_with(mock_group)
def test__validate_uri__opendap_exists(self, mock_PoolManager):
# Mock request.status so it returns 200, meaning successful connection..
mock_PoolManager.return_value.request.return_value = PropertyMock(
status=200)
uri = 'http://nbstds.met.no/thredds/catalog/NBS/S2A/test_catalog.html'
self.assertEqual(utils.validate_uri(uri), None)
def test_non_int_value_returns_none(self):
fake_rushes = PropertyMock(return_value='bad')
type(self.boxscore)._away_rush_attempts = fake_rushes
assert self.boxscore.away_rush_attempts is None
def test_change_axis(self):
view_x_label_mock = PropertyMock()
view_y_label_mock = PropertyMock()
model_x_label_mock = PropertyMock(return_value='x0')
model_y_label_mock = PropertyMock(return_value='y0')
type(self.view).x_label = view_x_label_mock
type(self.view).y_label = view_y_label_mock
type(self.model).x_label = model_x_label_mock
type(self.model).y_label = model_y_label_mock
# labels passed model -> view
self.presenter = SlicePlotOptionsPresenter(self.view, self.model)
model_x_label_mock.assert_called_once_with()
model_y_label_mock.assert_called_once_with()
view_x_label_mock.assert_called_once_with('x0')
view_y_label_mock.assert_called_once_with('y0')
# labels passed view -> model
model_x_label_mock.reset_mock()
model_y_label_mock.reset_mock()
view_x_label_mock.reset_mock()
view_y_label_mock.reset_mock()
view_x_label_mock.return_value = 'x1'
view_y_label_mock.return_value = 'y1'
self.presenter._value_modified('x_label')
self.presenter._value_modified('y_label')
self.presenter.get_new_config()
view_x_label_mock.assert_called_once_with()
view_y_label_mock.assert_called_once_with()
model_x_label_mock.assert_called_once_with('x1')
model_y_label_mock.assert_called_once_with('y1')
def test_view_lang_agnostic_authed(redirect_mock, reverse_mock, projects_mock,
util_mock, get_mock, client):
""" User is authenticated and Userprofile.custom_homepage defined,
redirect to Userprofile.custom_homepage """
test_user, _ = User.objects.get_or_create(username="******")
client.force_login(test_user)
view = reverse("pontoon.translate.locale.agnostic",
kwargs=dict(slug="FOO", part="BAR"))
# mock return value for url reverse
reverse_mock.return_value = 73
# mock return value for Project.objects.available
projects_mock.visible_for().available.return_value = "AVAILABLEPROJECTS"
# create a mock Project with .locales
project_mock = MagicMock()
type(project_mock).locales = PropertyMock(return_value="LOCALES")
# mock return value for get_object_or_404 for Project
get_mock.return_value = project_mock
# mock return value for redirect
mock_response = HttpResponse()
redirect_mock.return_value = mock_response
# mock return_value for get_project_locale_from_request
util_mock.return_value = 23
profile_mock = MagicMock()
type(profile_mock).custom_homepage = PropertyMock(return_value=None)
# mock return_value for user.is_authenticated and custom homepage
user_mock = MagicMock()
type(user_mock).is_authenticated = PropertyMock(return_value=True)
type(user_mock).profile = PropertyMock(return_value=profile_mock)
response = client.get(view)
# Project.objects.visible_for was called with the test_user user
assert projects_mock.visible_for.call_args[0][0] == test_user
# Project.objects.available was called with no args
assert list(projects_mock.visible_for().available.call_args) == [(), {}]
# get_object_or_404 was called with Project.objects.available and
# the requested slug
assert list(get_mock.call_args) == [("AVAILABLEPROJECTS", ), {
"slug": u"FOO"
}]
# reverse was called with args...
assert list(reverse_mock.call_args) == [
("pontoon.translate", ),
{
"kwargs": {
"locale": 23,
"resource": u"BAR",
"project": u"FOO"
}
},
]
# redirect was called with reverse result
assert list(redirect_mock.call_args) == [("73", ), {}]
assert response is mock_response
def test_change_title(self):
mock_view_title = PropertyMock()
type(self.view).title = mock_view_title
mock_model_title = PropertyMock(return_value='Title 0')
type(self.model).title = mock_model_title
# title passed model -> view
self.presenter = CutPlotOptionsPresenter(self.view, self.model)
mock_model_title.assert_called_once_with()
mock_view_title.assert_called_once_with('Title 0')
# title passed view -> model
mock_view_title.reset_mock()
mock_model_title.reset_mock()
mock_view_title.return_value = 'Title 1'
self.presenter._value_modified('title')
self.presenter.get_new_config()
mock_view_title.assert_called_once_with()
mock_model_title.assert_called_once_with('Title 1')
@patch.object(Postgresql, 'is_running', Mock(return_value=True))
@patch.object(Postgresql, 'is_leader', Mock(return_value=True))
@patch.object(Postgresql, 'xlog_position', Mock(return_value=0))
@patch.object(Postgresql, 'call_nowait', Mock(return_value=True))
@patch.object(Postgresql, 'data_directory_empty', Mock(return_value=False))
@patch.object(Postgresql, 'controldata', Mock(return_value={'Database system identifier': '1234567890'}))
@patch.object(Postgresql, 'sync_replication_slots', Mock())
@patch.object(Postgresql, 'write_pg_hba', Mock())
@patch.object(Postgresql, 'write_pgpass', Mock())
@patch.object(Postgresql, 'write_recovery_conf', Mock())
@patch.object(Postgresql, 'query', Mock())
@patch.object(Postgresql, 'checkpoint', Mock())
@patch.object(etcd.Client, 'write', etcd_write)
@patch.object(etcd.Client, 'read', etcd_read)
@patch.object(etcd.Client, 'delete', Mock(side_effect=etcd.EtcdException))
@patch('patroni.async_executor.AsyncExecutor.busy', PropertyMock(return_value=False))
@patch('patroni.async_executor.AsyncExecutor.run_async', run_async)
@patch('subprocess.call', Mock(return_value=0))
class TestHa(unittest.TestCase):
@patch('socket.getaddrinfo', socket_getaddrinfo)
@patch('psycopg2.connect', psycopg2_connect)
@patch.object(etcd.Client, 'read', etcd_read)
def setUp(self):
with patch.object(Client, 'machines') as mock_machines:
mock_machines.__get__ = Mock(return_value=['http://remotehost:2379'])
self.p = Postgresql({'name': 'postgresql0', 'scope': 'dummy', 'listen': '127.0.0.1:5432',
'data_dir': 'data/postgresql0', 'retry_timeout': 10,
'authentication': {'superuser': {'username': '******', 'password': '******'},
'replication': {'username': '', 'password': ''}},
'parameters': {'wal_level': 'hot_standby', 'max_replication_slots': 5, 'foo': 'bar',
def test_no_class_information_returns_dataframe_of_none(self):
mock_points = PropertyMock(return_value=None)
type(self.boxscore)._away_points = mock_points
type(self.boxscore)._home_points = mock_points
assert self.boxscore.dataframe is None
def test_invalid_home_record_returns_default_losses(self):
fake_record = PropertyMock(return_value='Golden State Warriors 1')
type(self.boxscore)._home_record = fake_record
assert self.boxscore.home_losses == 0
def test_invalid_away_record_returns_default_wins(self):
fake_record = PropertyMock(return_value='Golden State Warriors 1')
type(self.boxscore)._away_record = fake_record
assert self.boxscore.away_wins == 0
class TestRestApiHandler(unittest.TestCase):
_authorization = '\nAuthorization: Basic dGVzdDp0ZXN0'
def test_do_GET(self):
MockRestApiServer(RestApiHandler, 'GET /replica')
with patch.object(RestApiHandler, 'get_postgresql_status',
Mock(return_value={})):
MockRestApiServer(RestApiHandler, 'GET /replica')
with patch.object(RestApiHandler, 'get_postgresql_status',
Mock(return_value={'role': 'master'})):
MockRestApiServer(RestApiHandler, 'GET /replica')
MockRestApiServer(RestApiHandler, 'GET /master')
MockPatroni.dcs.cluster.sync.sync_standby = MockPostgresql.name
MockPatroni.dcs.cluster.is_synchronous_mode = Mock(return_value=True)
with patch.object(RestApiHandler, 'get_postgresql_status',
Mock(return_value={'role': 'replica'})):
MockRestApiServer(RestApiHandler, 'GET /synchronous')
with patch.object(RestApiHandler, 'get_postgresql_status',
Mock(return_value={'role': 'replica'})):
MockPatroni.dcs.cluster.sync.sync_standby = ''
MockRestApiServer(RestApiHandler, 'GET /asynchronous')
MockPatroni.ha.is_leader = Mock(return_value=True)
MockRestApiServer(RestApiHandler, 'GET /replica')
MockPatroni.dcs.cluster = None
with patch.object(RestApiHandler, 'get_postgresql_status',
Mock(return_value={'role': 'master'})):
MockRestApiServer(RestApiHandler, 'GET /master')
with patch.object(MockHa, 'restart_scheduled',
Mock(return_value=True)):
MockRestApiServer(RestApiHandler, 'GET /master')
self.assertIsNotNone(MockRestApiServer(RestApiHandler, 'GET /master'))
with patch.object(
RestApiServer, 'query',
Mock(return_value=[('', 1, '', '', '', '', False, '')])):
self.assertIsNotNone(
MockRestApiServer(RestApiHandler, 'GET /patroni'))
with patch.object(MockHa, 'is_standby_cluster',
Mock(return_value=True)):
MockRestApiServer(RestApiHandler, 'GET /standby_leader')
def test_do_OPTIONS(self):
self.assertIsNotNone(
MockRestApiServer(RestApiHandler, 'OPTIONS / HTTP/1.0'))
@patch.object(MockPostgresql, 'state',
PropertyMock(return_value='stopped'))
def test_do_GET_patroni(self):
self.assertIsNotNone(MockRestApiServer(RestApiHandler, 'GET /patroni'))
def test_basicauth(self):
self.assertIsNotNone(
MockRestApiServer(RestApiHandler, 'POST /restart HTTP/1.0'))
MockRestApiServer(RestApiHandler,
'POST /restart HTTP/1.0\nAuthorization:')
@patch.object(MockPatroni, 'dcs')
def test_do_GET_config(self, mock_dcs):
mock_dcs.cluster.config.data = {}
self.assertIsNotNone(MockRestApiServer(RestApiHandler, 'GET /config'))
mock_dcs.cluster.config = None
self.assertIsNotNone(MockRestApiServer(RestApiHandler, 'GET /config'))
@patch.object(MockPatroni, 'dcs')
def test_do_PATCH_config(self, mock_dcs):
config = {
'postgresql': {
'use_slots': False,
'use_pg_rewind': True,
'parameters': {
'wal_level': 'logical'
}
}
}
mock_dcs.get_cluster.return_value.config = ClusterConfig.from_node(
1, json.dumps(config))
request = 'PATCH /config HTTP/1.0' + self._authorization
self.assertIsNotNone(MockRestApiServer(RestApiHandler, request))
request += '\nContent-Length: '
self.assertIsNotNone(
MockRestApiServer(
RestApiHandler,
request + '34\n\n{"postgresql":{"use_slots":false}}'))
config['ttl'] = 5
config['postgresql'].update({
'use_slots': {
'foo': True
},
"parameters": None
})
config = json.dumps(config)
request += str(len(config)) + '\n\n' + config
MockRestApiServer(RestApiHandler, request)
mock_dcs.set_config_value.return_value = False
MockRestApiServer(RestApiHandler, request)
@patch.object(MockPatroni, 'dcs')
def test_do_PUT_config(self, mock_dcs):
mock_dcs.get_cluster.return_value.config = ClusterConfig.from_node(
1, '{}')
request = 'PUT /config HTTP/1.0' + self._authorization + '\nContent-Length: '
self.assertIsNotNone(
MockRestApiServer(RestApiHandler, request + '2\n\n{}'))
config = '{"foo": "bar"}'
request += str(len(config)) + '\n\n' + config
MockRestApiServer(RestApiHandler, request)
mock_dcs.set_config_value.return_value = False
MockRestApiServer(RestApiHandler, request)
mock_dcs.get_cluster.return_value.config = ClusterConfig.from_node(
1, config)
MockRestApiServer(RestApiHandler, request)
@patch.object(MockPatroni, 'sighup_handler', Mock(side_effect=Exception))
def test_do_POST_reload(self):
with patch.object(MockPatroni, 'config') as mock_config:
mock_config.reload_local_configuration.return_value = False
MockRestApiServer(RestApiHandler,
'POST /reload HTTP/1.0' + self._authorization)
self.assertIsNotNone(
MockRestApiServer(RestApiHandler,
'POST /reload HTTP/1.0' + self._authorization))
@patch.object(MockPatroni, 'dcs')
def test_do_POST_restart(self, mock_dcs):
mock_dcs.get_cluster.return_value.is_paused.return_value = False
request = 'POST /restart HTTP/1.0' + self._authorization
self.assertIsNotNone(MockRestApiServer(RestApiHandler, request))
with patch.object(MockHa, 'restart', Mock(side_effect=Exception)):
MockRestApiServer(RestApiHandler, request)
post = request + '\nContent-Length: '
def make_request(request=None, **kwargs):
request = json.dumps(kwargs) if request is None else request
return '{0}{1}\n\n{2}'.format(post, len(request), request)
# empty request
request = make_request('')
MockRestApiServer(RestApiHandler, request)
# invalid request
request = make_request('foobar=baz')
MockRestApiServer(RestApiHandler, request)
# wrong role
request = make_request(schedule=future_restart_time.isoformat(),
role='unknown',
postgres_version='9.5.3')
MockRestApiServer(RestApiHandler, request)
# wrong version
request = make_request(schedule=future_restart_time.isoformat(),
role='master',
postgres_version='9.5.3.1')
MockRestApiServer(RestApiHandler, request)
# unknown filter
request = make_request(schedule=future_restart_time.isoformat(),
batman='lives')
MockRestApiServer(RestApiHandler, request)
# incorrect schedule
request = make_request(schedule='2016-08-42 12:45TZ+1', role='master')
MockRestApiServer(RestApiHandler, request)
# everything fine, but the schedule is missing
request = make_request(role='master', postgres_version='9.5.2')
MockRestApiServer(RestApiHandler, request)
for retval in (True, False):
with patch.object(MockHa, 'schedule_future_restart',
Mock(return_value=retval)):
request = make_request(
schedule=future_restart_time.isoformat())
MockRestApiServer(RestApiHandler, request)
with patch.object(MockHa, 'restart',
Mock(return_value=(retval, "foo"))):
request = make_request(role='master', postgres_version='9.5.2')
MockRestApiServer(RestApiHandler, request)
mock_dcs.get_cluster.return_value.is_paused.return_value = True
MockRestApiServer(
RestApiHandler,
make_request(schedule='2016-08-42 12:45TZ+1', role='master'))
# Valid timeout
MockRestApiServer(RestApiHandler, make_request(timeout='60s'))
# Invalid timeout
MockRestApiServer(RestApiHandler, make_request(timeout='42towels'))
def test_do_DELETE_restart(self):
for retval in (True, False):
with patch.object(MockHa, 'delete_future_restart',
Mock(return_value=retval)):
request = 'DELETE /restart HTTP/1.0' + self._authorization
self.assertIsNotNone(MockRestApiServer(RestApiHandler,
request))
@patch.object(MockPatroni, 'dcs')
def test_do_POST_reinitialize(self, mock_dcs):
cluster = mock_dcs.get_cluster.return_value
cluster.is_paused.return_value = False
request = 'POST /reinitialize HTTP/1.0' + self._authorization + '\nContent-Length: 15\n\n{"force": true}'
MockRestApiServer(RestApiHandler, request)
with patch.object(MockHa, 'reinitialize', Mock(return_value=None)):
MockRestApiServer(RestApiHandler, request)
@patch('time.sleep', Mock())
def test_RestApiServer_query(self):
with patch.object(MockCursor, 'execute',
Mock(side_effect=psycopg2.OperationalError)):
self.assertIsNotNone(
MockRestApiServer(RestApiHandler, 'GET /patroni'))
with patch.object(MockPostgresql, 'connection',
Mock(side_effect=psycopg2.OperationalError)):
self.assertIsNotNone(
MockRestApiServer(RestApiHandler, 'GET /patroni'))
@patch('time.sleep', Mock())
@patch.object(MockPatroni, 'dcs')
def test_do_POST_switchover(self, dcs):
dcs.loop_wait = 10
cluster = dcs.get_cluster.return_value
cluster.is_synchronous_mode.return_value = False
cluster.is_paused.return_value = False
post = 'POST /switchover HTTP/1.0' + self._authorization + '\nContent-Length: '
MockRestApiServer(RestApiHandler, post + '7\n\n{"1":2}')
request = post + '0\n\n'
MockRestApiServer(RestApiHandler, request)
cluster.leader.name = 'postgresql1'
MockRestApiServer(RestApiHandler, request)
request = post + '25\n\n{"leader": "postgresql1"}'
cluster.is_paused.return_value = True
MockRestApiServer(RestApiHandler, request)
cluster.is_paused.return_value = False
for cluster.is_synchronous_mode.return_value in (True, False):
MockRestApiServer(RestApiHandler, request)
cluster.leader.name = 'postgresql2'
request = post + '53\n\n{"leader": "postgresql1", "candidate": "postgresql2"}'
MockRestApiServer(RestApiHandler, request)
cluster.leader.name = 'postgresql1'
for cluster.is_synchronous_mode.return_value in (True, False):
MockRestApiServer(RestApiHandler, request)
cluster.members = [
Member(0, 'postgresql0', 30, {'api_url': 'http'}),
Member(0, 'postgresql2', 30, {'api_url': 'http'})
]
MockRestApiServer(RestApiHandler, request)
cluster.failover = None
MockRestApiServer(RestApiHandler, request)
dcs.get_cluster.side_effect = [cluster]
MockRestApiServer(RestApiHandler, request)
cluster2 = cluster.copy()
cluster2.leader.name = 'postgresql0'
cluster2.is_unlocked.return_value = False
dcs.get_cluster.side_effect = [cluster, cluster2]
MockRestApiServer(RestApiHandler, request)
cluster2.leader.name = 'postgresql2'
dcs.get_cluster.side_effect = [cluster, cluster2]
MockRestApiServer(RestApiHandler, request)
dcs.get_cluster.side_effect = None
dcs.manual_failover.return_value = False
MockRestApiServer(RestApiHandler, request)
dcs.manual_failover.return_value = True
with patch.object(MockHa, 'fetch_nodes_statuses',
Mock(return_value=[])):
MockRestApiServer(RestApiHandler, request)
# Valid future date
request = post + '103\n\n{"leader": "postgresql1", "member": "postgresql2",' +\
' "scheduled_at": "6016-02-15T18:13:30.568224+01:00"}'
MockRestApiServer(RestApiHandler, request)
with patch.object(MockPatroni, 'dcs') as d:
d.manual_failover.return_value = False
MockRestApiServer(RestApiHandler, request)
# Exception: No timezone specified
request = post + '97\n\n{"leader": "postgresql1", "member": "postgresql2",' +\
' "scheduled_at": "6016-02-15T18:13:30.568224"}'
MockRestApiServer(RestApiHandler, request)
# Exception: Scheduled in the past
request = post + '103\n\n{"leader": "postgresql1", "member": "postgresql2", "scheduled_at": "'
MockRestApiServer(RestApiHandler,
request + '1016-02-15T18:13:30.568224+01:00"}')
# Invalid date
self.assertIsNotNone(
MockRestApiServer(RestApiHandler,
request + '2010-02-29T18:13:30.568224+01:00"}'))
@patch.object(MockPatroni, 'dcs', Mock())
def test_do_POST_failover(self):
post = 'POST /failover HTTP/1.0' + self._authorization + '\nContent-Length: '
MockRestApiServer(RestApiHandler, post + '14\n\n{"leader":"1"}')
MockRestApiServer(RestApiHandler,
post + '37\n\n{"candidate":"2","scheduled_at": "1"}')
def setUp(self):
super(TestAgent, self).setUp()
self.conf = cfg.ConfigOpts()
# To load the drivers without using the config file
self.useFixture(ConfFixture(self.conf))
def _fake_parse(self, args=[]):
return cfg.ConfigOpts._parse_cli_opts(self, [])
_fake_parse_method = types.MethodType(_fake_parse, self.conf)
self.conf._parse_cli_opts = _fake_parse_method
# First dependency to be returned
self.dummy_driver_manager = DriverManager.make_test_instance(
extension=Extension(
name=DummyMetricPuller.get_name(),
entry_point='fake.entry.point',
plugin=DummyMetricPuller,
obj=None,
),
namespace='TESTING',
)
# 2nd dependency to be returned
self.fake_driver_manager = DriverManager.make_test_instance(
extension=Extension(
name=FakeMetricPuller.get_name(),
entry_point='fake.entry.point',
plugin=FakeMetricPuller,
obj=None,
),
namespace='TESTING',
)
self.defaults_drivers = {
DummyMetricPuller.get_name(): self.dummy_driver_manager,
FakeMetricPuller.get_name(): self.fake_driver_manager,
}
def _fake_loader(name, **kw):
return self.defaults_drivers[name]
# Patches the agent socket
self.m_agent_socket = MagicMock(autospec=True)
self.patches.extend([
# Deactivates the nanomsg socket
patch(
"watcher_metering.agent.agent.nanomsg.Socket",
new=self.m_agent_socket,
),
# Sets the test namespace to 'TESTING'
patch.object(
Agent,
"namespace",
PropertyMock(return_value='TESTING'),
),
# Patches the driver manager to retourn our test drivers
# instead of the real ones
patch(
"watcher_metering.load.loader.DriverManager",
MagicMock(side_effect=_fake_loader),
),
])
# Applies all of our patches before each test
for _patch in self.patches:
_patch.start()
self.agent = Agent(conf=self.conf,
driver_names=self.conf.agent.driver_names,
use_nanoconfig_service=False,
publisher_endpoint="fake",
nanoconfig_service_endpoint="",
nanoconfig_update_endpoint="",
nanoconfig_profile="nanoconfig://test_profile")
# Default ticking is set to 0 to reduce test execution time
self.agent.TICK_INTERVAL = 0
class TestErrors(TestCase):
"""
Tests to cover failure paths to complete test coverage.
Also used to cover other unusual paths such as
Windows os
pure virtual classes
etc.
"""
@patch('gphotos.authorize.OAuth2Session.fetch_token',
return_value='dummy_token_string')
@patch('gphotos.authorize.input', return_value='dummy_response_string')
def test_authorize(self, fetch_patched, input_patched):
scope = [
'https://www.googleapis.com/auth/photoslibrary.readonly',
'https://www.googleapis.com/auth/photoslibrary.sharing',
]
bad_file: Path = Path(__file__).absolute().parent.parent / \
'test_credentials' / '.no-token-here'
token_file: Path = Path(__file__).absolute().parent.parent / \
'test_credentials' / '.gphotos.token'
secrets_file: Path = Path(__file__).absolute().parent.parent / \
'test_credentials' / 'client_secret.json'
test_data: Path = Path(__file__).absolute().parent.parent / 'test-data'
if bad_file.exists():
bad_file.unlink()
with pytest.raises(SystemExit) as test_wrapped_e:
a = auth.Authorize(scope, bad_file, bad_file)
assert test_wrapped_e.type == SystemExit
a = auth.Authorize(scope, bad_file, secrets_file)
res = a.load_token()
assert res is None
a.authorize()
assert a.token == 'dummy_token_string'
def test_base_media(self):
b = BaseMedia()
with pytest.raises(NotImplementedError):
x = b.size
with pytest.raises(NotImplementedError):
x = b.id
with pytest.raises(NotImplementedError):
x = b.description
with pytest.raises(NotImplementedError):
x = b.orig_name
with pytest.raises(NotImplementedError):
x = b.create_date
with pytest.raises(NotImplementedError):
x = b.modify_date
with pytest.raises(NotImplementedError):
x = b.mime_type
with pytest.raises(NotImplementedError):
x = b.url
with patch('gphotos.Checks.os_name',
new_callable=PropertyMock(return_value='nt')):
assert valid_file_name('hello.txt') == 'hello.txt'
"""Download archived images in test library using flat folders (and
windows file name restrictions)
"""
s = ts.SetupDbAndCredentials()
args = [
'--archived', '--skip-albums', '--start-date', '2019-10-01',
'--use-flat-path'
]
s.test_setup('test_base_media',
args=args,
trash_files=True,
trash_db=True)
s.gp.start(s.parsed_args)
db = LocalData(s.root)
# Total of 1 out of media items
db.cur.execute("SELECT COUNT() FROM SyncFiles")
count = db.cur.fetchone()
self.assertEqual(1, count[0])
pat = str(photos_root / '2019-11' / '*.*')
files = sorted(s.root.glob(pat))
self.assertEqual(1, len(files))
def test_checks(self):
a_path = Path('/tmp')
with patch('gphotos.Checks.Path.symlink_to',
side_effect=FileNotFoundError()):
assert symlinks_supported(a_path) is False
with patch('gphotos.Checks.Path.unlink',
side_effect=FileNotFoundError()):
assert is_case_sensitive(a_path) is False
with patch('gphotos.Checks.subprocess.check_output',
side_effect=BaseException()):
assert get_max_path_length(a_path) == 248
if os.name != 'nt':
with patch('gphotos.Checks.os.statvfs',
side_effect=BaseException()):
assert get_max_filename_length(a_path) == 248
def test_database_media(self):
d = DatabaseMedia()
assert d.url is None
assert d.location is None
def test_db_row(self):
d = DbRow(None)
b = BaseMedia()
with pytest.raises(NotImplementedError):
x = d.to_media()
with pytest.raises(NotImplementedError):
x = d.from_media(b)
with pytest.raises(ValueError):
x = d.make(bad_column=1)
if d:
assert False, "empty DBRow returns true as Bool"
def test_google_albums_media(self):
m = GoogleAlbumMedia("")
g = GoogleAlbumsRow(None)
g.from_media(m)
def download_faves(self, expected=4, no_response=False, trash=True):
# Download favourite images only in test library.
s = ts.SetupDbAndCredentials()
args = [
'--album', 'Clones😀', '--use-flat-path', '--omit-album-date',
'--rescan'
]
s.test_setup('test_google_albums_sync',
args=args,
trash_files=trash,
trash_db=trash)
s.gp.start(s.parsed_args)
db = LocalData(s.root)
# Total of 1 out of media items
db.cur.execute("SELECT COUNT() FROM SyncFiles")
count = db.cur.fetchone()
self.assertEqual(expected, count[0])
class DummyResponse:
@staticmethod
def json():
return {}
@patch('gphotos.GoogleAlbumsSync.PAGE_SIZE',
new_callable=PropertyMock(return_value=1))
@patch('gphotos.GoogleAlbumsSync.ALBUM_ITEMS',
new_callable=PropertyMock(return_value=1))
@patch('gphotos.Checks.MAX_PATH_LENGTH',
new_callable=PropertyMock(return_value=4))
def test_google_albums_sync(self, page_size, album_items, max_path):
# next page in responses (set pageSize = 1) fetch_album_contents()
# blank response.json (empty album - add to test data?)
# also pagesize = 1 in index_albums_type()
# self._omit_album_date = True
# self._use_flat_path = True
# path > Checks.MAX_PATH_LENGTH
# skip hardlink on non-downloaded file (line 272)
# file exists already line 290
# check that next_page functionality works
# in fetch_album_contents and index_albums_type
self.download_faves()
# test file exists already in create_album_content_links
with patch('shutil.rmtree'):
self.download_faves(trash=False)
# check that empty media_json response works
with patch('gphotos.restclient.Method.execute',
return_value=self.DummyResponse()):
self.download_faves(expected=0)
class Test_AOVFile(unittest.TestCase):
"""Test ht.sohohooks.manager.AOVFile object."""
@patch.object(manager.AOVFile, "_init_from_file")
@patch.object(manager.AOVFile,
"exists",
new_callable=PropertyMock(return_value=True))
def test___init___exists(self, mock_exists, mock_init):
mock_path = MagicMock(spec=str)
aov_file = manager.AOVFile(mock_path)
self.assertEqual(aov_file._path, mock_path)
self.assertEqual(aov_file._aovs, [])
self.assertEqual(aov_file._data, {})
self.assertEqual(aov_file._groups, [])
mock_init.assert_called()
@patch.object(manager.AOVFile, "_init_from_file")
@patch.object(manager.AOVFile,
"exists",
new_callable=PropertyMock(return_value=False))
def test___init___does_not_exist(self, mock_exists, mock_init):
mock_path = MagicMock(spec=str)
aov_file = manager.AOVFile(mock_path)
self.assertEqual(aov_file._path, mock_path)
self.assertEqual(aov_file._aovs, [])
self.assertEqual(aov_file._data, {})
self.assertEqual(aov_file._groups, [])
mock_init.assert_not_called()
# _create_aovs
@patch.object(manager.AOVFile, "aovs", new_callable=PropertyMock)
@patch("ht.sohohooks.aovs.manager.AOV", autospec=True)
@patch.object(manager.AOVFile, "path", new_callable=PropertyMock)
@patch.object(manager.AOVFile, "__init__", lambda x, y: None)
def test__create_aovs(self, mock_path, mock_aov, mock_aovs):
definition = {"key": "value"}
definitions = [definition]
aovs = []
mock_aovs.return_value = aovs
aov_file = manager.AOVFile(None)
aov_file._create_aovs(definitions)
mock_aov.assert_called_with({
"key": "value",
"path": mock_path.return_value
})
self.assertEqual(definition, {
"key": "value",
"path": mock_path.return_value
})
self.assertEqual(aovs, [mock_aov.return_value])
# _create_groups
@patch.object(manager.AOVFile, "groups", new_callable=PropertyMock)
@patch.object(manager.AOVFile, "path", new_callable=PropertyMock)
@patch("ht.sohohooks.aovs.manager.AOVGroup", autospec=True)
@patch.object(manager.AOVFile, "__init__", lambda x, y: None)
def test__create_groups_minimal(self, mock_group, mock_path, mock_groups):
mock_group_name = MagicMock(spec=str)
group_data = {}
definitions = {mock_group_name: group_data}
groups = []
mock_groups.return_value = groups
aov_file = manager.AOVFile(None)
aov_file._create_groups(definitions)
mock_group.assert_called_with(mock_group_name)
self.assertEqual(groups, [mock_group.return_value])
self.assertEqual(mock_group.return_value.path, mock_path.return_value)
@patch.object(manager.AOVFile, "groups", new_callable=PropertyMock)
@patch.object(manager.AOVFile, "path", new_callable=PropertyMock)
@patch("ht.sohohooks.aovs.manager.os.path.expandvars")
@patch("ht.sohohooks.aovs.manager.AOVGroup", autospec=True)
@patch.object(manager.AOVFile, "__init__", lambda x, y: None)
def test__create_groups_all_data(self, mock_group, mock_expand, mock_path,
mock_groups):
mock_group_name = MagicMock(spec=str)
mock_includes = MagicMock(spec=list)
mock_comment = MagicMock(spec=str)
mock_priority = MagicMock(spec=int)
mock_icon = MagicMock(spec=str)
group_data = {
consts.GROUP_INCLUDE_KEY: mock_includes,
consts.COMMENT_KEY: mock_comment,
consts.PRIORITY_KEY: mock_priority,
consts.GROUP_ICON_KEY: mock_icon
}
definitions = {mock_group_name: group_data}
groups = []
mock_groups.return_value = groups
aov_file = manager.AOVFile(None)
aov_file._create_groups(definitions)
mock_group.assert_called_with(mock_group_name)
self.assertEqual(groups, [mock_group.return_value])
mock_expand.assert_called_with(mock_icon)
self.assertEqual(mock_group.return_value.path, mock_path.return_value)
self.assertEqual(mock_group.return_value.comment, mock_comment)
self.assertEqual(mock_group.return_value.priority, mock_priority)
self.assertEqual(mock_group.return_value.icon,
mock_expand.return_value)
mock_group.return_value.includes.extend.assert_called_with(
mock_includes)
# _init_from_file
@patch.object(manager.AOVFile, "_create_groups")
@patch.object(manager.AOVFile, "_create_aovs")
@patch("ht.sohohooks.aovs.manager.json.load", return_value={})
@patch.object(manager.AOVFile, "path", new_callable=PropertyMock)
@patch.object(manager.AOVFile, "__init__", lambda x, y: None)
def test__init_from_file__no_items(self, mock_path, mock_load,
mock_create_aovs, mock_create_groups):
aov_file = manager.AOVFile(None)
with patch("__builtin__.open", mock_open()) as mock_handle:
aov_file._init_from_file()
mock_handle.assert_called_with(mock_path.return_value)
mock_load.assert_called_with(mock_handle.return_value)
mock_create_aovs.assert_not_called()
mock_create_groups.assert_not_called()
@patch.object(manager.AOVFile, "_create_groups")
@patch.object(manager.AOVFile, "_create_aovs")
@patch("ht.sohohooks.aovs.manager.json.load")
@patch.object(manager.AOVFile, "path", new_callable=PropertyMock)
@patch.object(manager.AOVFile, "__init__", lambda x, y: None)
def test__init_from_file__items(self, mock_path, mock_load,
mock_create_aovs, mock_create_groups):
mock_definitions = MagicMock(spec=dict)
mock_groups = MagicMock(spec=dict)
mock_load.return_value = {
consts.FILE_DEFINITIONS_KEY: mock_definitions,
consts.FILE_GROUPS_KEY: mock_groups,
}
aov_file = manager.AOVFile(None)
with patch("__builtin__.open", mock_open()) as mock_handle:
aov_file._init_from_file()
mock_handle.assert_called_with(mock_path.return_value)
mock_load.assert_called_with(mock_handle.return_value)
mock_create_aovs.assert_called_with(mock_definitions)
mock_create_groups.assert_called_with(mock_groups)
# properties
@patch.object(manager.AOVFile, "__init__", lambda x, y: None)
def test_aovs(self):
mock_aov = MagicMock(spec=manager.AOV)
aov_file = manager.AOVFile(None)
aov_file._aovs = [mock_aov]
self.assertEqual(aov_file.aovs, [mock_aov])
with self.assertRaises(AttributeError):
aov_file.aovs = []
@patch.object(manager.AOVFile, "__init__", lambda x, y: None)
def test_groups(self):
mock_group = MagicMock(spec=manager.AOVGroup)
aov_file = manager.AOVFile(None)
aov_file._groups = [mock_group]
self.assertEqual(aov_file.groups, [mock_group])
with self.assertRaises(AttributeError):
aov_file.groups = []
@patch.object(manager.AOVFile, "__init__", lambda x, y: None)
def test_path(self):
mock_value = MagicMock(spec=str)
aov_file = manager.AOVFile(None)
aov_file._path = mock_value
self.assertEqual(aov_file.path, mock_value)
with self.assertRaises(AttributeError):
aov_file.path = mock_value
@patch.object(manager.AOVFile, "path", new_callable=PropertyMock)
@patch("ht.sohohooks.aovs.manager.os.path.isfile")
@patch.object(manager.AOVFile, "__init__", lambda x, y: None)
def test_exists(self, mock_isfile, mock_path):
aov_file = manager.AOVFile(None)
self.assertEqual(aov_file.exists, mock_isfile.return_value)
mock_isfile.assert_called_with(mock_path.return_value)
with self.assertRaises(AttributeError):
aov_file.exists = False
# add_aov
@patch.object(manager.AOVFile, "aovs", new_callable=PropertyMock)
@patch.object(manager.AOVFile, "__init__", lambda x, y: None)
def test_add_aov(self, mock_aovs):
mock_aov = MagicMock(spec=manager.AOV)
aov_file = manager.AOVFile(None)
aov_file.add_aov(mock_aov)
mock_aovs.return_value.append.assert_called_with(mock_aov)
# add_group
@patch.object(manager.AOVFile, "groups", new_callable=PropertyMock)
@patch.object(manager.AOVFile, "__init__", lambda x, y: None)
def test_add_group(self, mock_groups):
mock_group = MagicMock(spec=manager.AOVGroup)
aov_file = manager.AOVFile(None)
aov_file.add_group(mock_group)
mock_groups.return_value.append.assert_called_with(mock_group)
# contains_aov
@patch.object(manager.AOVFile, "aovs", new_callable=PropertyMock)
@patch.object(manager.AOVFile, "__init__", lambda x, y: None)
def test_contains_aov(self, mock_aovs):
mock_aov = MagicMock(spec=manager.AOV)
aov_file = manager.AOVFile(None)
result = aov_file.contains_aov(mock_aov)
self.assertEqual(result,
mock_aovs.return_value.__contains__.return_value)
mock_aovs.return_value.__contains__.assert_called_with(mock_aov)
# contains_group
@patch.object(manager.AOVFile, "groups", new_callable=PropertyMock)
@patch.object(manager.AOVFile, "__init__", lambda x, y: None)
def test_contains_group(self, mock_groups):
mock_group = MagicMock(spec=manager.AOVGroup)
aov_file = manager.AOVFile(None)
result = aov_file.contains_group(mock_group)
self.assertEqual(result,
mock_groups.return_value.__contains__.return_value)
mock_groups.return_value.__contains__.assert_called_with(mock_group)
# remove_aov
@patch.object(manager.AOVFile, "aovs", new_callable=PropertyMock)
@patch.object(manager.AOVFile, "__init__", lambda x, y: None)
def test_remove_aov(self, mock_aovs):
mock_aov = MagicMock(spec=manager.AOV)
aovs = [mock_aov]
mock_aovs.return_value = aovs
aov_file = manager.AOVFile(None)
aov_file.remove_aov(mock_aov)
self.assertEqual(aovs, [])
# remove_group
@patch.object(manager.AOVFile, "groups", new_callable=PropertyMock)
@patch.object(manager.AOVFile, "__init__", lambda x, y: None)
def test_remove_group(self, mock_groups):
mock_group = MagicMock(spec=manager.AOVGroup)
groups = [mock_group]
mock_groups.return_value = groups
aov_file = manager.AOVFile(None)
aov_file.remove_group(mock_group)
self.assertEqual(groups, [])
# replace_aov
@patch.object(manager.AOVFile, "aovs", new_callable=PropertyMock)
@patch.object(manager.AOVFile, "__init__", lambda x, y: None)
def test_replace_aov(self, mock_aovs):
mock_aov = MagicMock(spec=manager.AOV)
mock_aovs.return_value.index.return_value = 3
aov_file = manager.AOVFile(None)
aov_file.replace_aov(mock_aov)
mock_aovs.return_value.index.assert_called_with(mock_aov)
mock_aovs.return_value.__setitem__.assert_called_with(3, mock_aov)
# replace_group
@patch.object(manager.AOVFile, "groups", new_callable=PropertyMock)
@patch.object(manager.AOVFile, "__init__", lambda x, y: None)
def test_replace_group(self, mock_groups):
mock_group = MagicMock(spec=manager.AOVGroup)
mock_groups.return_value.index.return_value = 2
aov_file = manager.AOVFile(None)
aov_file.replace_group(mock_group)
mock_groups.return_value.index.assert_called_with(mock_group)
mock_groups.return_value.__setitem__.assert_called_with(2, mock_group)
# write_to_file
@patch("ht.sohohooks.aovs.manager.json.dump")
@patch.object(manager.AOVFile, "aovs", new_callable=PropertyMock)
@patch.object(manager.AOVFile, "groups", new_callable=PropertyMock)
@patch.object(manager.AOVFile, "__init__", lambda x, y: None)
def test_write_to_file__nothing_explicit_path(self, mock_groups, mock_aovs,
mock_dump):
mock_groups.return_value = []
mock_aovs.return_value = []
aov_file = manager.AOVFile(None)
mock_path = MagicMock(spec=str)
with patch("__builtin__.open", mock_open()) as mock_handle:
aov_file.write_to_file(mock_path)
mock_handle.assert_called_with(mock_path, 'w')
mock_dump.assert_called_with({},
mock_handle.return_value,
indent=4)
@patch("ht.sohohooks.aovs.manager.json.dump")
@patch.object(manager.AOVFile, "path", new_callable=PropertyMock)
@patch.object(manager.AOVFile, "aovs", new_callable=PropertyMock)
@patch.object(manager.AOVFile, "groups", new_callable=PropertyMock)
@patch.object(manager.AOVFile, "__init__", lambda x, y: None)
def test_write_to_file(self, mock_groups, mock_aovs, mock_path, mock_dump):
mock_group_key = MagicMock(spec=str)
mock_group_value = MagicMock(spec=str)
mock_group = MagicMock(spec=manager.AOVGroup)
mock_group.as_data.return_value = {mock_group_key: mock_group_value}
mock_groups.return_value = [mock_group]
mock_aov_key = MagicMock(spec=str)
mock_aov_value = MagicMock(spec=str)
mock_aov = MagicMock(spec=manager.AOV)
mock_aov.as_data.return_value = {mock_aov_key: mock_aov_value}
mock_aovs.return_value = [mock_aov]
aov_file = manager.AOVFile(None)
expected = {
consts.FILE_GROUPS_KEY: {
mock_group_key: mock_group_value
},
consts.FILE_DEFINITIONS_KEY: [{
mock_aov_key: mock_aov_value
}]
}
with patch("__builtin__.open", mock_open()) as mock_handle:
aov_file.write_to_file()
mock_handle.assert_called_with(mock_path.return_value, 'w')
mock_dump.assert_called_with(expected,
mock_handle.return_value,
indent=4)
def test_change_xrange(self):
view_x_range_mock = PropertyMock()
type(self.view).x_range = view_x_range_mock
model_x_range_mock = PropertyMock(return_value=(1, 5))
type(self.model).x_range = model_x_range_mock
# passed model -> view
self.presenter1 = SlicePlotOptionsPresenter(self.view, self.model)
model_x_range_mock.assert_called_with()
view_x_range_mock.assert_called_once_with((1, 5))
# passed view -> model through slice presenter
model_x_range_mock.reset_mock()
view_x_range_mock.return_value = (2, 10)
self.presenter1._xy_config_modified('x_range')
self.presenter1.get_new_config()
model_x_range_mock.assert_called_once_with((2, 10))
# passed view -> model through cut presenter
self.presenter2 = CutPlotOptionsPresenter(self.view, self.model)
self.presenter2._xy_config_modified('x_range')
self.presenter2.get_new_config()
self.model.change_axis_scale.assert_called_once()
def test_nfl_away_abbreviation(self):
away_name = PropertyMock(return_value='<a href="/teams/kan/2018.htm" \
itemprop="name">Kansas City Chiefs</a>')
type(self.boxscore)._away_name = away_name
assert self.boxscore.away_abbreviation == 'kan'
class TestOutcomeService(TestLtiConsumerXBlock):
"""
Unit tests for OutcomeService
"""
def setUp(self):
super(TestOutcomeService, self).setUp()
self.outcome_servce = OutcomeService(self.xblock)
@patch('lti_consumer.outcomes.verify_oauth_body_signature', Mock(return_value=True))
@patch('lti_consumer.lti_consumer.LtiConsumerXBlock.lti_provider_key_secret', PropertyMock(return_value=('t', 's')))
@patch('lti_consumer.outcomes.parse_grade_xml_body', Mock(return_value=('', '', 0.5, 'replaceResultRequest')))
def test_handle_replace_result_success(self):
"""
Test replace result request returns with success indicator
"""
request = make_request('')
values = {
'code': 'success',
'description': 'Score for is now 0.5',
'msg_id': '',
'response': '<replaceResultResponse/>'
}
self.assertEqual(
self.outcome_servce.handle_request(request).strip(),
RESPONSE_BODY_TEMPLATE.format(**values).strip()
)
@patch('lti_consumer.lti_consumer.LtiConsumerXBlock.is_past_due', PropertyMock(return_value=True))
def test_grade_past_due(self):
"""
Test late grade returns failure response
"""
request = make_request('')
self.xblock.accept_grades_past_due = False
response = self.outcome_servce.handle_request(request)
self.assertIn('failure', response)
self.assertIn('Grade is past due', response)
@patch('lti_consumer.outcomes.parse_grade_xml_body')
def test_xml_parse_lti_error(self, mock_parse):
"""
Test XML parsing LtiError returns failure response
"""
request = make_request('')
mock_parse.side_effect = LtiError
response = self.outcome_servce.handle_request(request)
self.assertIn('failure', response)
self.assertIn('Request body XML parsing error', response)
@patch('lti_consumer.outcomes.verify_oauth_body_signature')
@patch('lti_consumer.lti_consumer.LtiConsumerXBlock.lti_provider_key_secret', PropertyMock(return_value=('t', 's')))
@patch('lti_consumer.outcomes.parse_grade_xml_body', Mock(return_value=('', '', 0.5, 'replaceResultRequest')))
def test_invalid_signature(self, mock_verify):
"""
Test invalid oauth signature returns failure response
"""
request = make_request('')
mock_verify.side_effect = ValueError
self.assertIn('failure', self.outcome_servce.handle_request(request))
mock_verify.side_effect = LtiError
self.assertIn('failure', self.outcome_servce.handle_request(request))
@patch('lti_consumer.outcomes.verify_oauth_body_signature', Mock(return_value=True))
@patch('lti_consumer.lti_consumer.LtiConsumerXBlock.lti_provider_key_secret', PropertyMock(return_value=('t', 's')))
@patch('lti_consumer.outcomes.parse_grade_xml_body', Mock(return_value=('', '', 0.5, 'replaceResultRequest')))
def test_user_not_found(self):
"""
Test user not found returns failure response
"""
request = make_request('')
self.xblock.runtime.get_real_user.return_value = None
response = self.outcome_servce.handle_request(request)
self.assertIn('failure', response)
self.assertIn('User not found', response)
@patch('lti_consumer.outcomes.verify_oauth_body_signature', Mock(return_value=True))
@patch('lti_consumer.lti_consumer.LtiConsumerXBlock.lti_provider_key_secret', PropertyMock(return_value=('t', 's')))
@patch('lti_consumer.outcomes.parse_grade_xml_body', Mock(return_value=('', '', 0.5, 'unsupportedRequest')))
def test_unsupported_action(self):
"""
Test unsupported action returns unsupported response
"""
request = make_request('')
response = self.outcome_servce.handle_request(request)
self.assertIn('unsupported', response)
self.assertIn('Target does not support the requested operation.', response)
def test_nfl_home_abbreviation(self):
home_name = PropertyMock(return_value='<a href="/teams/nwe/2018.htm" \
itemprop="name">New England Patriots</a>')
type(self.boxscore)._home_name = home_name
assert self.boxscore.home_abbreviation == 'nwe'
class TestHa(unittest.TestCase):
@patch('socket.getaddrinfo', socket_getaddrinfo)
@patch('psycopg2.connect', psycopg2_connect)
@patch('patroni.dcs.dcs_modules',
Mock(return_value=['patroni.dcs.foo', 'patroni.dcs.etcd']))
@patch.object(etcd.Client, 'read', etcd_read)
def setUp(self):
with patch.object(Client, 'machines') as mock_machines:
mock_machines.__get__ = Mock(
return_value=['http://*****:*****@patch.object(Postgresql, 'fix_cluster_state', Mock())
def test_crash_recovery(self):
self.p.is_running = false
self.p.controldata = lambda: {
'Database cluster state': 'in production'
}
self.assertEquals(self.ha.run_cycle(),
'doing crash recovery in a single user mode')
@patch.object(Postgresql, 'rewind_needed_and_possible',
Mock(return_value=True))
def test_recover_with_rewind(self):
self.p.is_running = false
self.ha.cluster = get_cluster_initialized_with_leader()
self.assertEquals(self.ha.run_cycle(), 'running pg_rewind from leader')
@patch.object(Postgresql, 'can_rewind', PropertyMock(return_value=True))
@patch.object(Postgresql, 'fix_cluster_state', Mock())
def test_single_user_after_recover_failed(self):
self.p.controldata = lambda: {'Database cluster state': 'in recovery'}
self.p.is_running = false
self.p.follow = false
self.assertEquals(self.ha.run_cycle(), 'starting as a secondary')
self.assertEquals(self.ha.run_cycle(),
'fixing cluster state in a single user mode')
@patch('sys.exit', return_value=1)
@patch('patroni.ha.Ha.sysid_valid', MagicMock(return_value=True))
def test_sysid_no_match(self, exit_mock):
self.ha.run_cycle()
exit_mock.assert_called_once_with(1)
@patch.object(Cluster, 'is_unlocked', Mock(return_value=False))
def test_start_as_readonly(self):
self.p.is_leader = false
self.p.is_healthy = true
self.ha.has_lock = true
self.p.controldata = lambda: {
'Database cluster state': 'in production'
}
self.assertEquals(
self.ha.run_cycle(),
'promoted self to leader because i had the session lock')
@patch('psycopg2.connect', psycopg2_connect)
def test_acquire_lock_as_master(self):
self.assertEquals(self.ha.run_cycle(),
'acquired session lock as a leader')
def test_promoted_by_acquiring_lock(self):
self.ha.is_healthiest_node = true
self.p.is_leader = false
self.assertEquals(self.ha.run_cycle(),
'promoted self to leader by acquiring session lock')
def test_long_promote(self):
self.ha.cluster.is_unlocked = false
self.ha.has_lock = true
self.p.is_leader = false
self.p.set_role('master')
self.assertEquals(self.ha.run_cycle(),
'no action. i am the leader with the lock')
def test_demote_after_failing_to_obtain_lock(self):
self.ha.acquire_lock = false
self.assertEquals(
self.ha.run_cycle(),
'demoted self after trying and failing to obtain lock')
def test_follow_new_leader_after_failing_to_obtain_lock(self):
self.ha.is_healthiest_node = true
self.ha.acquire_lock = false
self.p.is_leader = false
self.assertEquals(
self.ha.run_cycle(),
'following new leader after trying and failing to obtain lock')
def test_demote_because_not_healthiest(self):
self.ha.is_healthiest_node = false
self.assertEquals(
self.ha.run_cycle(),
'demoting self because i am not the healthiest node')
def test_follow_new_leader_because_not_healthiest(self):
self.ha.is_healthiest_node = false
self.p.is_leader = false
self.assertEquals(
self.ha.run_cycle(),
'following a different leader because i am not the healthiest node'
)
def test_promote_because_have_lock(self):
self.ha.cluster.is_unlocked = false
self.ha.has_lock = true
self.p.is_leader = false
self.assertEquals(
self.ha.run_cycle(),
'promoted self to leader because i had the session lock')
def test_promote_without_watchdog(self):
self.ha.cluster.is_unlocked = false
self.ha.has_lock = true
self.p.is_leader = true
with patch.object(Watchdog, 'activate', Mock(return_value=False)):
self.assertEquals(
self.ha.run_cycle(),
'Demoting self because watchdog could not be activated')
self.p.is_leader = false
self.assertEquals(
self.ha.run_cycle(),
'Not promoting self because watchdog could not be activated')
def test_leader_with_lock(self):
self.ha.cluster.is_unlocked = false
self.ha.has_lock = true
self.assertEquals(self.ha.run_cycle(),
'no action. i am the leader with the lock')
def test_demote_because_not_having_lock(self):
self.ha.cluster.is_unlocked = false
with patch.object(Watchdog, 'is_running',
PropertyMock(return_value=True)):
self.assertEquals(
self.ha.run_cycle(),
'demoting self because i do not have the lock and i was a leader'
)
def test_demote_because_update_lock_failed(self):
self.ha.cluster.is_unlocked = false
self.ha.has_lock = true
self.ha.update_lock = false
self.assertEquals(
self.ha.run_cycle(),
'demoted self because failed to update leader lock in DCS')
self.p.is_leader = false
self.assertEquals(
self.ha.run_cycle(),
'not promoting because failed to update leader lock in DCS')
def test_follow(self):
self.ha.cluster.is_unlocked = false
self.p.is_leader = false
self.assertEquals(
self.ha.run_cycle(),
'no action. i am a secondary and i am following a leader')
self.ha.patroni.replicatefrom = "foo"
self.assertEquals(
self.ha.run_cycle(),
'no action. i am a secondary and i am following a leader')
def test_follow_in_pause(self):
self.ha.cluster.is_unlocked = false
self.ha.is_paused = true
self.assertEquals(self.ha.run_cycle(),
'PAUSE: continue to run as master without lock')
self.p.is_leader = false
self.assertEquals(self.ha.run_cycle(), 'PAUSE: no action')
@patch.object(Postgresql, 'rewind_needed_and_possible',
Mock(return_value=True))
def test_follow_triggers_rewind(self):
self.p.is_leader = false
self.p.trigger_check_diverged_lsn()
self.ha.cluster = get_cluster_initialized_with_leader()
self.assertEquals(self.ha.run_cycle(), 'running pg_rewind from leader')
def test_no_etcd_connection_master_demote(self):
self.ha.load_cluster_from_dcs = Mock(
side_effect=DCSError('Etcd is not responding properly'))
self.assertEquals(
self.ha.run_cycle(),
'demoted self because DCS is not accessible and i was a leader')
@patch('time.sleep', Mock())
def test_bootstrap_from_another_member(self):
self.ha.cluster = get_cluster_initialized_with_leader()
self.assertEquals(self.ha.bootstrap(),
'trying to bootstrap from replica \'other\'')
def test_bootstrap_waiting_for_leader(self):
self.ha.cluster = get_cluster_initialized_without_leader()
self.assertEquals(self.ha.bootstrap(),
'waiting for leader to bootstrap')
def test_bootstrap_without_leader(self):
self.ha.cluster = get_cluster_initialized_without_leader()
self.p.can_create_replica_without_replication_connection = MagicMock(
return_value=True)
self.assertEquals(self.ha.bootstrap(),
'trying to bootstrap (without leader)')
def test_bootstrap_initialize_lock_failed(self):
self.ha.cluster = get_cluster_not_initialized_without_leader()
self.assertEquals(self.ha.bootstrap(),
'failed to acquire initialize lock')
def test_bootstrap_initialized_new_cluster(self):
self.ha.cluster = get_cluster_not_initialized_without_leader()
self.e.initialize = true
self.assertEquals(self.ha.bootstrap(),
'trying to bootstrap a new cluster')
self.p.is_leader = false
self.assertEquals(self.ha.run_cycle(),
'waiting for end of recovery after bootstrap')
self.p.is_leader = true
self.assertEquals(self.ha.run_cycle(), 'running post_bootstrap')
self.assertEquals(self.ha.run_cycle(), 'initialized a new cluster')
def test_bootstrap_release_initialize_key_on_failure(self):
self.ha.cluster = get_cluster_not_initialized_without_leader()
self.e.initialize = true
self.ha.bootstrap()
self.p.is_running = false
self.assertRaises(PatroniException, self.ha.post_bootstrap)
def test_bootstrap_release_initialize_key_on_watchdog_failure(self):
self.ha.cluster = get_cluster_not_initialized_without_leader()
self.e.initialize = true
self.ha.bootstrap()
self.p.is_running.return_value = MockPostmaster()
self.p.is_leader = true
with patch.object(Watchdog, 'activate', Mock(return_value=False)):
self.assertEquals(self.ha.post_bootstrap(),
'running post_bootstrap')
self.assertRaises(PatroniException, self.ha.post_bootstrap)
@patch('psycopg2.connect', psycopg2_connect)
def test_reinitialize(self):
self.assertIsNotNone(self.ha.reinitialize())
self.ha.cluster = get_cluster_initialized_with_leader()
self.assertIsNone(self.ha.reinitialize(True))
self.assertIsNotNone(self.ha.reinitialize())
self.ha.state_handler.name = self.ha.cluster.leader.name
self.assertIsNotNone(self.ha.reinitialize())
@patch('time.sleep', Mock())
def test_restart(self):
self.assertEquals(self.ha.restart({}),
(True, 'restarted successfully'))
self.p.restart = Mock(return_value=None)
self.assertEquals(self.ha.restart({}),
(False, 'postgres is still starting'))
self.p.restart = false
self.assertEquals(self.ha.restart({}), (False, 'restart failed'))
self.ha.cluster = get_cluster_initialized_with_leader()
self.ha.reinitialize()
self.assertEquals(self.ha.restart({}),
(False, 'reinitialize already in progress'))
with patch.object(self.ha, "restart_matches", return_value=False):
self.assertEquals(self.ha.restart({'foo': 'bar'}),
(False, "restart conditions are not satisfied"))
@patch('os.kill', Mock())
def test_restart_in_progress(self):
with patch('patroni.async_executor.AsyncExecutor.busy',
PropertyMock(return_value=True)):
self.ha.restart({}, run_async=True)
self.assertTrue(self.ha.restart_scheduled())
self.assertEquals(self.ha.run_cycle(), 'restart in progress')
self.ha.cluster = get_cluster_initialized_with_leader()
self.assertEquals(self.ha.run_cycle(), 'restart in progress')
self.ha.has_lock = true
self.assertEquals(self.ha.run_cycle(),
'updated leader lock during restart')
self.ha.update_lock = false
self.p.set_role('master')
with patch('patroni.async_executor.CriticalTask.cancel',
Mock(return_value=False)):
with patch(
'patroni.postgresql.Postgresql.terminate_starting_postmaster'
) as mock_terminate:
self.assertEquals(self.ha.run_cycle(),
'lost leader lock during restart')
mock_terminate.assert_called()
@patch('requests.get', requests_get)
def test_manual_failover_from_leader(self):
self.ha.fetch_node_status = get_node_status()
self.ha.has_lock = true
self.ha.cluster = get_cluster_initialized_with_leader(
Failover(0, 'blabla', '', None))
self.assertEquals(self.ha.run_cycle(),
'no action. i am the leader with the lock')
self.ha.cluster = get_cluster_initialized_with_leader(
Failover(0, '', self.p.name, None))
self.assertEquals(self.ha.run_cycle(),
'no action. i am the leader with the lock')
self.ha.cluster = get_cluster_initialized_with_leader(
Failover(0, '', 'blabla', None))
self.assertEquals(self.ha.run_cycle(),
'no action. i am the leader with the lock')
f = Failover(0, self.p.name, '', None)
self.ha.cluster = get_cluster_initialized_with_leader(f)
self.assertEquals(self.ha.run_cycle(),
'manual failover: demoting myself')
self.p.rewind_needed_and_possible = true
self.assertEquals(self.ha.run_cycle(),
'manual failover: demoting myself')
self.ha.fetch_node_status = get_node_status(nofailover=True)
self.assertEquals(self.ha.run_cycle(),
'no action. i am the leader with the lock')
self.ha.fetch_node_status = get_node_status(watchdog_failed=True)
self.assertEquals(self.ha.run_cycle(),
'no action. i am the leader with the lock')
self.ha.fetch_node_status = get_node_status(wal_position=1)
self.assertEquals(self.ha.run_cycle(),
'no action. i am the leader with the lock')
# manual failover from the previous leader to us won't happen if we hold the nofailover flag
self.ha.cluster = get_cluster_initialized_with_leader(
Failover(0, 'blabla', self.p.name, None))
self.assertEquals(self.ha.run_cycle(),
'no action. i am the leader with the lock')
# Failover scheduled time must include timezone
scheduled = datetime.datetime.now()
self.ha.cluster = get_cluster_initialized_with_leader(
Failover(0, 'blabla', self.p.name, scheduled))
self.ha.run_cycle()
scheduled = datetime.datetime.utcnow().replace(tzinfo=tzutc)
self.ha.cluster = get_cluster_initialized_with_leader(
Failover(0, 'blabla', self.p.name, scheduled))
self.assertEquals('no action. i am the leader with the lock',
self.ha.run_cycle())
scheduled = scheduled + datetime.timedelta(seconds=30)
self.ha.cluster = get_cluster_initialized_with_leader(
Failover(0, 'blabla', self.p.name, scheduled))
self.assertEquals('no action. i am the leader with the lock',
self.ha.run_cycle())
scheduled = scheduled + datetime.timedelta(seconds=-600)
self.ha.cluster = get_cluster_initialized_with_leader(
Failover(0, 'blabla', self.p.name, scheduled))
self.assertEquals('no action. i am the leader with the lock',
self.ha.run_cycle())
scheduled = None
self.ha.cluster = get_cluster_initialized_with_leader(
Failover(0, 'blabla', self.p.name, scheduled))
self.assertEquals('no action. i am the leader with the lock',
self.ha.run_cycle())
@patch('requests.get', requests_get)
def test_manual_failover_from_leader_in_pause(self):
self.ha.has_lock = true
self.ha.is_paused = true
scheduled = datetime.datetime.now()
self.ha.cluster = get_cluster_initialized_with_leader(
Failover(0, 'blabla', self.p.name, scheduled))
self.assertEquals('PAUSE: no action. i am the leader with the lock',
self.ha.run_cycle())
self.ha.cluster = get_cluster_initialized_with_leader(
Failover(0, self.p.name, '', None))
self.assertEquals('PAUSE: no action. i am the leader with the lock',
self.ha.run_cycle())
@patch('requests.get', requests_get)
def test_manual_failover_from_leader_in_synchronous_mode(self):
self.p.is_leader = true
self.ha.has_lock = true
self.ha.is_synchronous_mode = true
self.ha.is_failover_possible = false
self.ha.process_sync_replication = Mock()
self.ha.cluster = get_cluster_initialized_with_leader(
Failover(0, self.p.name, 'a', None), (self.p.name, None))
self.assertEquals('no action. i am the leader with the lock',
self.ha.run_cycle())
self.ha.cluster = get_cluster_initialized_with_leader(
Failover(0, self.p.name, 'a', None), (self.p.name, 'a'))
self.ha.is_failover_possible = true
self.assertEquals('manual failover: demoting myself',
self.ha.run_cycle())
@patch('requests.get', requests_get)
def test_manual_failover_process_no_leader(self):
self.p.is_leader = false
self.ha.cluster = get_cluster_initialized_without_leader(
failover=Failover(0, '', self.p.name, None))
self.assertEquals(self.ha.run_cycle(),
'promoted self to leader by acquiring session lock')
self.ha.cluster = get_cluster_initialized_without_leader(
failover=Failover(0, '', 'leader', None))
self.p.set_role('replica')
self.assertEquals(self.ha.run_cycle(),
'promoted self to leader by acquiring session lock')
self.ha.fetch_node_status = get_node_status(
) # accessible, in_recovery
self.assertEquals(
self.ha.run_cycle(),
'following a different leader because i am not the healthiest node'
)
self.ha.cluster = get_cluster_initialized_without_leader(
failover=Failover(0, self.p.name, '', None))
self.assertEquals(
self.ha.run_cycle(),
'following a different leader because i am not the healthiest node'
)
self.ha.fetch_node_status = get_node_status(
reachable=False) # inaccessible, in_recovery
self.p.set_role('replica')
self.assertEquals(self.ha.run_cycle(),
'promoted self to leader by acquiring session lock')
# set failover flag to True for all members of the cluster
# this should elect the current member, as we are not going to call the API for it.
self.ha.cluster = get_cluster_initialized_without_leader(
failover=Failover(0, '', 'other', None))
self.ha.fetch_node_status = get_node_status(
nofailover=True) # accessible, in_recovery
self.p.set_role('replica')
self.assertEquals(self.ha.run_cycle(),
'promoted self to leader by acquiring session lock')
# same as previous, but set the current member to nofailover. In no case it should be elected as a leader
self.ha.patroni.nofailover = True
self.assertEquals(
self.ha.run_cycle(),
'following a different leader because I am not allowed to promote')
def test_manual_failover_process_no_leader_in_pause(self):
self.ha.is_paused = true
self.ha.cluster = get_cluster_initialized_without_leader(
failover=Failover(0, '', 'other', None))
self.assertEquals(self.ha.run_cycle(),
'PAUSE: continue to run as master without lock')
self.ha.cluster = get_cluster_initialized_without_leader(
failover=Failover(0, 'leader', '', None))
self.assertEquals(self.ha.run_cycle(),
'PAUSE: continue to run as master without lock')
self.ha.cluster = get_cluster_initialized_without_leader(
failover=Failover(0, 'leader', 'blabla', None))
self.assertEquals('PAUSE: acquired session lock as a leader',
self.ha.run_cycle())
self.p.is_leader = false
self.p.set_role('replica')
self.ha.cluster = get_cluster_initialized_without_leader(
failover=Failover(0, 'leader', self.p.name, None))
self.assertEquals(
self.ha.run_cycle(),
'PAUSE: promoted self to leader by acquiring session lock')
def test_is_healthiest_node(self):
self.ha.state_handler.is_leader = false
self.ha.patroni.nofailover = False
self.ha.fetch_node_status = get_node_status()
self.assertTrue(self.ha.is_healthiest_node())
with patch.object(Watchdog, 'is_healthy',
PropertyMock(return_value=False)):
self.assertFalse(self.ha.is_healthiest_node())
with patch('patroni.postgresql.Postgresql.is_starting',
return_value=True):
self.assertFalse(self.ha.is_healthiest_node())
self.ha.is_paused = true
self.assertFalse(self.ha.is_healthiest_node())
def test__is_healthiest_node(self):
self.assertTrue(
self.ha._is_healthiest_node(self.ha.old_cluster.members))
self.p.is_leader = false
self.ha.fetch_node_status = get_node_status(
) # accessible, in_recovery
self.assertTrue(
self.ha._is_healthiest_node(self.ha.old_cluster.members))
self.ha.fetch_node_status = get_node_status(
in_recovery=False) # accessible, not in_recovery
self.assertFalse(
self.ha._is_healthiest_node(self.ha.old_cluster.members))
self.ha.fetch_node_status = get_node_status(
wal_position=11) # accessible, in_recovery, wal position ahead
self.assertFalse(
self.ha._is_healthiest_node(self.ha.old_cluster.members))
with patch('patroni.postgresql.Postgresql.timeline_wal_position',
return_value=(1, 1)):
self.assertFalse(
self.ha._is_healthiest_node(self.ha.old_cluster.members))
self.ha.patroni.nofailover = True
self.assertFalse(
self.ha._is_healthiest_node(self.ha.old_cluster.members))
self.ha.patroni.nofailover = False
@patch('requests.get', requests_get)
def test_fetch_node_status(self):
member = Member(0, 'test', 1,
{'api_url': 'http://127.0.0.1:8011/patroni'})
self.ha.fetch_node_status(member)
member = Member(0, 'test', 1,
{'api_url': 'http://*****:*****@patch('patroni.ha.Ha.update_lock', return_value=True)
@patch('patroni.ha.Ha.demote')
def test_starting_timeout(self, demote, update_lock):
def check_calls(seq):
for mock, called in seq:
if called:
mock.assert_called_once()
else:
mock.assert_not_called()
mock.reset_mock()
self.ha.has_lock = true
self.ha.cluster = get_cluster_initialized_with_leader()
self.p.check_for_startup = true
self.p.time_in_state = lambda: 30
self.assertEquals(
self.ha.run_cycle(),
'PostgreSQL is still starting up, 270 seconds until timeout')
check_calls([(update_lock, True), (demote, False)])
self.p.time_in_state = lambda: 350
self.ha.fetch_node_status = get_node_status(
reachable=False) # inaccessible, in_recovery
self.assertEquals(
self.ha.run_cycle(),
'master start has timed out, but continuing to wait because failover is not possible'
)
check_calls([(update_lock, True), (demote, False)])
self.ha.fetch_node_status = get_node_status(
) # accessible, in_recovery
self.assertEquals(self.ha.run_cycle(),
'stopped PostgreSQL because of startup timeout')
check_calls([(update_lock, True), (demote, True)])
update_lock.return_value = False
self.assertEquals(
self.ha.run_cycle(),
'stopped PostgreSQL while starting up because leader key was lost')
check_calls([(update_lock, True), (demote, True)])
self.ha.has_lock = false
self.p.is_leader = false
self.assertEquals(
self.ha.run_cycle(),
'no action. i am a secondary and i am following a leader')
check_calls([(update_lock, False), (demote, False)])
def test_manual_failover_while_starting(self):
self.ha.has_lock = true
self.p.check_for_startup = true
f = Failover(0, self.p.name, '', None)
self.ha.cluster = get_cluster_initialized_with_leader(f)
self.ha.fetch_node_status = get_node_status(
) # accessible, in_recovery
self.assertEquals(self.ha.run_cycle(),
'manual failover: demoting myself')
@patch('patroni.ha.Ha.demote')
def test_failover_immediately_on_zero_master_start_timeout(self, demote):
self.p.is_running = false
self.ha.cluster = get_cluster_initialized_with_leader(
sync=(self.p.name, 'other'))
self.ha.cluster.config.data['synchronous_mode'] = True
self.ha.patroni.config.set_dynamic_configuration(
{'master_start_timeout': 0})
self.ha.has_lock = true
self.ha.update_lock = true
self.ha.fetch_node_status = get_node_status(
) # accessible, in_recovery
self.assertEquals(self.ha.run_cycle(),
'stopped PostgreSQL to fail over after a crash')
demote.assert_called_once()
@patch('patroni.postgresql.Postgresql.follow')
def test_demote_immediate(self, follow):
self.ha.has_lock = true
self.e.get_cluster = Mock(
return_value=get_cluster_initialized_without_leader())
self.ha.demote('immediate')
follow.assert_called_once_with(None)
def test_process_sync_replication(self):
self.ha.has_lock = true
mock_set_sync = self.p.set_synchronous_standby = Mock()
self.p.name = 'leader'
# Test sync key removed when sync mode disabled
self.ha.cluster = get_cluster_initialized_with_leader(sync=('leader',
'other'))
with patch.object(self.ha.dcs,
'delete_sync_state') as mock_delete_sync:
self.ha.run_cycle()
mock_delete_sync.assert_called_once()
mock_set_sync.assert_called_once_with(None)
mock_set_sync.reset_mock()
# Test sync key not touched when not there
self.ha.cluster = get_cluster_initialized_with_leader()
with patch.object(self.ha.dcs,
'delete_sync_state') as mock_delete_sync:
self.ha.run_cycle()
mock_delete_sync.assert_not_called()
mock_set_sync.assert_called_once_with(None)
mock_set_sync.reset_mock()
self.ha.is_synchronous_mode = true
# Test sync standby not touched when picking the same node
self.p.pick_synchronous_standby = Mock(return_value=('other', True))
self.ha.cluster = get_cluster_initialized_with_leader(sync=('leader',
'other'))
self.ha.run_cycle()
mock_set_sync.assert_not_called()
mock_set_sync.reset_mock()
# Test sync standby is replaced when switching standbys
self.p.pick_synchronous_standby = Mock(return_value=('other2', False))
self.ha.dcs.write_sync_state = Mock(return_value=True)
self.ha.run_cycle()
mock_set_sync.assert_called_once_with('other2')
mock_set_sync.reset_mock()
# Test sync standby is not disabled when updating dcs fails
self.ha.dcs.write_sync_state = Mock(return_value=False)
self.ha.run_cycle()
mock_set_sync.assert_not_called()
mock_set_sync.reset_mock()
# Test changing sync standby
self.ha.dcs.write_sync_state = Mock(return_value=True)
self.ha.dcs.get_cluster = Mock(
return_value=get_cluster_initialized_with_leader(sync=('leader',
'other')))
# self.ha.cluster = get_cluster_initialized_with_leader(sync=('leader', 'other'))
self.p.pick_synchronous_standby = Mock(return_value=('other2', True))
self.ha.run_cycle()
self.ha.dcs.get_cluster.assert_called_once()
self.assertEquals(self.ha.dcs.write_sync_state.call_count, 2)
# Test updating sync standby key failed due to race
self.ha.dcs.write_sync_state = Mock(side_effect=[True, False])
self.ha.run_cycle()
self.assertEquals(self.ha.dcs.write_sync_state.call_count, 2)
# Test changing sync standby failed due to race
self.ha.dcs.write_sync_state = Mock(return_value=True)
self.ha.dcs.get_cluster = Mock(
return_value=get_cluster_initialized_with_leader(
sync=('somebodyelse', None)))
self.ha.run_cycle()
self.assertEquals(self.ha.dcs.write_sync_state.call_count, 1)
# Test sync set to '*' when synchronous_mode_strict is enabled
mock_set_sync.reset_mock()
self.ha.is_synchronous_mode_strict = true
self.p.pick_synchronous_standby = Mock(return_value=(None, False))
self.ha.run_cycle()
mock_set_sync.assert_called_once_with('*')
def test_sync_replication_become_master(self):
self.ha.is_synchronous_mode = true
mock_set_sync = self.p.set_synchronous_standby = Mock()
self.p.is_leader = false
self.p.set_role('replica')
self.ha.has_lock = true
mock_write_sync = self.ha.dcs.write_sync_state = Mock(
return_value=True)
self.p.name = 'leader'
self.ha.cluster = get_cluster_initialized_with_leader(sync=('other',
None))
# When we just became master nobody is sync
self.assertEquals(self.ha.enforce_master_role('msg', 'promote msg'),
'promote msg')
mock_set_sync.assert_called_once_with(None)
mock_write_sync.assert_called_once_with('leader', None, index=0)
mock_set_sync.reset_mock()
# When we just became master nobody is sync
self.p.set_role('replica')
mock_write_sync.return_value = False
self.assertTrue(
self.ha.enforce_master_role('msg', 'promote msg') != 'promote msg')
mock_set_sync.assert_not_called()
def test_unhealthy_sync_mode(self):
self.ha.is_synchronous_mode = true
self.p.is_leader = false
self.p.set_role('replica')
self.p.name = 'other'
self.ha.cluster = get_cluster_initialized_without_leader(
sync=('leader', 'other2'))
mock_write_sync = self.ha.dcs.write_sync_state = Mock(
return_value=True)
mock_acquire = self.ha.acquire_lock = Mock(return_value=True)
mock_follow = self.p.follow = Mock()
mock_promote = self.p.promote = Mock()
# If we don't match the sync replica we are not allowed to acquire lock
self.ha.run_cycle()
mock_acquire.assert_not_called()
mock_follow.assert_called_once()
self.assertEquals(mock_follow.call_args[0][0], None)
mock_write_sync.assert_not_called()
mock_follow.reset_mock()
# If we do match we will try to promote
self.ha._is_healthiest_node = true
self.ha.cluster = get_cluster_initialized_without_leader(
sync=('leader', 'other'))
self.ha.run_cycle()
mock_acquire.assert_called_once()
mock_follow.assert_not_called()
mock_promote.assert_called_once()
mock_write_sync.assert_called_once_with('other', None, index=0)
def test_disable_sync_when_restarting(self):
self.ha.is_synchronous_mode = true
self.p.name = 'other'
self.p.is_leader = false
self.p.set_role('replica')
mock_restart = self.p.restart = Mock(return_value=True)
self.ha.cluster = get_cluster_initialized_with_leader(sync=('leader',
'other'))
self.ha.touch_member = Mock(return_value=True)
self.ha.dcs.get_cluster = Mock(side_effect=[
get_cluster_initialized_with_leader(sync=('leader', syncstandby))
for syncstandby in ['other', None]
])
with patch('time.sleep') as mock_sleep:
self.ha.restart({})
mock_restart.assert_called_once()
mock_sleep.assert_called()
# Restart is still called when DCS connection fails
mock_restart.reset_mock()
self.ha.dcs.get_cluster = Mock(side_effect=DCSError("foo"))
self.ha.restart({})
mock_restart.assert_called_once()
# We don't try to fetch the cluster state when touch_member fails
mock_restart.reset_mock()
self.ha.dcs.get_cluster.reset_mock()
self.ha.touch_member = Mock(return_value=False)
self.ha.restart({})
mock_restart.assert_called_once()
self.ha.dcs.get_cluster.assert_not_called()
def test_effective_tags(self):
self.ha._disable_sync = True
self.assertEquals(self.ha.get_effective_tags(), {
'foo': 'bar',
'nosync': True
})
self.ha._disable_sync = False
self.assertEquals(self.ha.get_effective_tags(), {'foo': 'bar'})
def test_restore_cluster_config(self):
self.ha.cluster.config.data.clear()
self.ha.has_lock = true
self.ha.cluster.is_unlocked = false
self.assertEquals(self.ha.run_cycle(),
'no action. i am the leader with the lock')
def test_watch(self):
self.ha.cluster = get_cluster_initialized_with_leader()
self.ha.watch(0)
def test_wakup(self):
self.ha.wakeup()
def test_shutdown(self):
self.p.is_running = false
self.ha.has_lock = true
self.ha.shutdown()
@patch('time.sleep', Mock())
def test_leader_with_empty_directory(self):
self.ha.cluster = get_cluster_initialized_with_leader()
self.ha.has_lock = true
self.p.data_directory_empty = true
self.assertEquals(
self.ha.run_cycle(),
'released leader key voluntarily as data dir empty and currently leader'
)
self.assertEquals(self.p.role, 'uninitialized')
# as has_lock is mocked out, we need to fake the leader key release
self.ha.has_lock = false
# will not say bootstrap from leader as replica can't self elect
self.assertEquals(self.ha.run_cycle(),
"trying to bootstrap from replica 'other'")
def test_update_cluster_history(self):
self.p.get_master_timeline = Mock(return_value=1)
self.ha.has_lock = true
self.ha.cluster.is_unlocked = false
self.assertEquals(self.ha.run_cycle(),
'no action. i am the leader with the lock')
def test_change_xy_log(self):
view_x_log_mock = PropertyMock()
view_y_log_mock = PropertyMock()
model_x_log_mock = PropertyMock(return_value=True)
model_y_log_mock = PropertyMock(return_value=False)
model_x_range_mock = PropertyMock(return_value=(1, 2))
model_y_range_mock = PropertyMock(return_value=(3, 4))
type(self.view).x_log = view_x_log_mock
type(self.view).y_log = view_y_log_mock
type(self.model).x_log = model_x_log_mock
type(self.model).y_log = model_y_log_mock
type(self.model).x_range = model_x_range_mock
type(self.model).y_range = model_y_range_mock
# model -> view
self.presenter = CutPlotOptionsPresenter(self.view, self.model)
view_x_log_mock.assert_called_once_with(True)
view_y_log_mock.assert_called_once_with(False)
# view -> model
view_x_log_mock.return_value = False
view_y_log_mock.return_value = True
self.presenter._xy_config_modified('x_log')
self.presenter._xy_config_modified('y_log')
self.presenter.get_new_config()
self.model.change_axis_scale.assert_called_once_with({'x_range': (1, 2), 'y_range': (3, 4), 'modified': True,
'x_log': False, 'y_log': True})
def test_view_lang_agnostic_anon_available_accept_language(
redirect_mock, reverse_mock, projects_mock, util_mock, get_mock,
client):
"""User is not authenticated, redirect to first
available accept-language locale"""
view = reverse("pontoon.translate.locale.agnostic",
kwargs=dict(slug="FOO", part="BAR"))
# mock return value for url reverse
reverse_mock.return_value = 73
# mock return value for Project.objects.available
projects_mock.visible_for().available.return_value = "AVAILABLEPROJECTS"
# create a mock Project with .locales
project_mock = MagicMock()
type(project_mock).locales = PropertyMock(return_value="LOCALES")
# mock return value for get_object_or_404 for Project
get_mock.return_value = project_mock
# mock return value for redirect
mock_response = HttpResponse()
redirect_mock.return_value = mock_response
# mock return_value for get_project_locale_from_request
util_mock.return_value = 23
response = client.get("%s?baz=17" % view)
# Project.objects.visible_for was called with the test user
assert projects_mock.visible_for.call_args[0][0] == AnonymousUser()
# Project.objects.available was called with no args
assert list(projects_mock.visible_for().available.call_args) == [(), {}]
# get_object_or_404 was called with Project.objects.available and
# the requested slug
assert list(get_mock.call_args) == [("AVAILABLEPROJECTS", ), {
"slug": u"FOO"
}]
# get_project_locale_from_request
assert list(util_mock.call_args) == [(response.wsgi_request, "LOCALES"),
{}]
# reverse was called with args...
assert list(reverse_mock.call_args) == [
("pontoon.translate", ),
{
"kwargs": {
"locale": 23,
"resource": u"BAR",
"project": u"FOO"
}
},
]
# redirect was called with reverse result
assert list(redirect_mock.call_args) == [("73?baz=17", ), {}]
assert response is mock_response
def test_it_should_enqueue_and_send_events_properly(
self, mock_lib_dir, *_):
mock_lib_dir.return_value = self.lib_dir
with self._create_send_telemetry_events_handler() as telemetry_handler:
monitor_handler = _CollectAndEnqueueEventsPeriodicOperation(
telemetry_handler)
self._create_extension_event(message="Message-Test")
test_mtime = 1000 # epoch time, in ms
test_opcodename = datetime.fromtimestamp(test_mtime).strftime(
logger.Logger.LogTimeFormatInUTC)
test_eventtid = 42
test_eventpid = 24
test_taskname = "TEST_TaskName"
with patch("os.path.getmtime", return_value=test_mtime):
with patch('os.getpid', return_value=test_eventpid):
with patch("threading.Thread.ident",
new_callable=PropertyMock(
return_value=test_eventtid)):
with patch("threading.Thread.getName",
return_value=test_taskname):
monitor_handler.run()
TestSendTelemetryEventsHandler._stop_handler(telemetry_handler)
# Validating the crafted message by the collect_and_send_events call.
self.assertEqual(1, len(telemetry_handler.event_calls),
"Only 1 event should be sent")
_, collected_event = telemetry_handler.event_calls[0]
# Some of those expected values come from the mock protocol and imds client set up during test initialization
osutil = get_osutil()
osversion = u"{0}:{1}-{2}-{3}:{4}".format(platform.system(),
DISTRO_NAME,
DISTRO_VERSION,
DISTRO_CODE_NAME,
platform.release())
sample_message = '<Event id="1"><![CDATA[' \
'<Param Name="Name" Value="DummyExtension" T="mt:wstr" />' \
'<Param Name="Version" Value="{0}" T="mt:wstr" />' \
'<Param Name="Operation" Value="Unknown" T="mt:wstr" />' \
'<Param Name="OperationSuccess" Value="True" T="mt:bool" />' \
'<Param Name="Message" Value="Message-Test" T="mt:wstr" />' \
'<Param Name="Duration" Value="0" T="mt:uint64" />' \
'<Param Name="GAVersion" Value="{1}" T="mt:wstr" />' \
'<Param Name="ContainerId" Value="c6d5526c-5ac2-4200-b6e2-56f2b70c5ab2" T="mt:wstr" />' \
'<Param Name="OpcodeName" Value="{2}" T="mt:wstr" />' \
'<Param Name="EventTid" Value="{3}" T="mt:uint64" />' \
'<Param Name="EventPid" Value="{4}" T="mt:uint64" />' \
'<Param Name="TaskName" Value="{5}" T="mt:wstr" />' \
'<Param Name="KeywordName" Value="" T="mt:wstr" />' \
'<Param Name="ExtensionType" Value="json" T="mt:wstr" />' \
'<Param Name="IsInternal" Value="False" T="mt:bool" />' \
'<Param Name="OSVersion" Value="{6}" T="mt:wstr" />' \
'<Param Name="ExecutionMode" Value="IAAS" T="mt:wstr" />' \
'<Param Name="RAM" Value="{7}" T="mt:uint64" />' \
'<Param Name="Processors" Value="{8}" T="mt:uint64" />' \
'<Param Name="TenantName" Value="db00a7755a5e4e8a8fe4b19bc3b330c3" T="mt:wstr" />' \
'<Param Name="RoleName" Value="MachineRole" T="mt:wstr" />' \
'<Param Name="RoleInstanceName" Value="b61f93d0-e1ed-40b2-b067-22c243233448.MachineRole_IN_0" T="mt:wstr" />' \
'<Param Name="Location" Value="uswest" T="mt:wstr" />' \
'<Param Name="SubscriptionId" Value="AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE" T="mt:wstr" />' \
'<Param Name="ResourceGroupName" Value="test-rg" T="mt:wstr" />' \
'<Param Name="VMId" Value="99999999-8888-7777-6666-555555555555" T="mt:wstr" />' \
'<Param Name="ImageOrigin" Value="2468" T="mt:uint64" />' \
']]></Event>'.format(AGENT_VERSION, CURRENT_AGENT, test_opcodename, test_eventtid,
test_eventpid, test_taskname, osversion, int(osutil.get_total_mem()),
osutil.get_processor_cores())
self.assertIn(sample_message, collected_event)
def test_change_grid(self):
view_x_grid_mock = PropertyMock()
view_y_grid_mock = PropertyMock()
model_x_grid_mock = PropertyMock(return_value=False)
model_y_grid_mock = PropertyMock(return_value=False)
type(self.view).x_grid = view_x_grid_mock
type(self.view).y_grid = view_y_grid_mock
type(self.model).x_grid = model_x_grid_mock
type(self.model).y_grid = model_y_grid_mock
# labels passed model -> view
self.presenter = SlicePlotOptionsPresenter(self.view, self.model)
model_x_grid_mock.assert_called_once_with()
model_y_grid_mock.assert_called_once_with()
view_x_grid_mock.assert_called_once_with(False)
view_y_grid_mock.assert_called_once_with(False)
# labels passed view -> model
model_x_grid_mock.reset_mock()
model_y_grid_mock.reset_mock()
view_x_grid_mock.reset_mock()
view_y_grid_mock.reset_mock()
view_x_grid_mock.return_value = True
view_y_grid_mock.return_value = True
self.presenter._value_modified('x_grid')
self.presenter._value_modified('y_grid')
self.presenter.get_new_config()
view_x_grid_mock.assert_called_once_with()
view_y_grid_mock.assert_called_once_with()
model_x_grid_mock.assert_called_once_with(True)
model_y_grid_mock.assert_called_once_with(True)
def __init__(self, *args, **kwargs):
super(MockModel, self).__init__(*args, **kwargs)
self.save = PropertyMock()
self.__meta = MockOptions(*self.get_fields())
class TestPatroni(unittest.TestCase):
@patch('pkgutil.get_importer', Mock(return_value=MockFrozenImporter()))
@patch('sys.frozen', Mock(return_value=True), create=True)
@patch.object(BaseHTTPServer.HTTPServer, '__init__', Mock())
@patch.object(etcd.Client, 'read', etcd_read)
@patch.object(Thread, 'start', Mock())
def setUp(self):
self._handlers = logging.getLogger().handlers[:]
RestApiServer._BaseServer__is_shut_down = Mock()
RestApiServer._BaseServer__shutdown_request = True
RestApiServer.socket = 0
with patch.object(Client, 'machines') as mock_machines:
mock_machines.__get__ = Mock(
return_value=['http://*****:*****@patch('patroni.dcs.AbstractDCS.get_cluster',
Mock(side_effect=[None, DCSError('foo'), None]))
def test_load_dynamic_configuration(self):
self.p.config._dynamic_configuration = {}
self.p.load_dynamic_configuration()
self.p.load_dynamic_configuration()
@patch('time.sleep', Mock(side_effect=SleepException))
@patch.object(etcd.Client, 'delete', Mock())
@patch.object(Client, 'machines')
@patch.object(Thread, 'join', Mock())
def test_patroni_patroni_main(self, mock_machines):
with patch('subprocess.call', Mock(return_value=1)):
sys.argv = ['patroni.py', 'postgres0.yml']
mock_machines.__get__ = Mock(
return_value=['http://*****:*****@patch('os.getpid')
@patch('multiprocessing.Process')
@patch('patroni.patroni_main', Mock())
def test_patroni_main(self, mock_process, mock_getpid):
mock_getpid.return_value = 2
_main()
mock_getpid.return_value = 1
def mock_signal(signo, handler):
handler(signo, None)
with patch('signal.signal', mock_signal):
with patch('os.waitpid', Mock(side_effect=[(1, 0), (0, 0)])):
_main()
with patch('os.waitpid', Mock(side_effect=OSError)):
_main()
ref = {'passtochild': lambda signo, stack_frame: 0}
def mock_sighup(signo, handler):
if hasattr(signal, 'SIGHUP') and signo == signal.SIGHUP:
ref['passtochild'] = handler
def mock_join():
ref['passtochild'](0, None)
mock_process.return_value.join = mock_join
with patch('signal.signal', mock_sighup), patch('os.kill', Mock()):
self.assertIsNone(_main())
@patch('patroni.config.Config.save_cache', Mock())
@patch('patroni.config.Config.reload_local_configuration',
Mock(return_value=True))
@patch('patroni.ha.Ha.is_leader', Mock(return_value=True))
@patch.object(Postgresql, 'state', PropertyMock(return_value='running'))
@patch.object(Postgresql, 'data_directory_empty', Mock(return_value=False))
def test_run(self):
self.p.postgresql.set_role('replica')
self.p.sighup_handler()
self.p.ha.dcs.watch = Mock(side_effect=SleepException)
self.p.api.start = Mock()
self.p.logger.start = Mock()
self.p.config._dynamic_configuration = {}
self.assertRaises(SleepException, self.p.run)
with patch('patroni.config.Config.set_dynamic_configuration',
Mock(return_value=True)):
self.assertRaises(SleepException, self.p.run)
with patch('patroni.postgresql.Postgresql.data_directory_empty',
Mock(return_value=False)):
self.assertRaises(SleepException, self.p.run)
def test_sigterm_handler(self):
self.assertRaises(SystemExit, self.p.sigterm_handler)
def test_schedule_next_run(self):
self.p.ha.cluster = Mock()
self.p.ha.dcs.watch = Mock(return_value=True)
self.p.schedule_next_run()
self.p.next_run = time.time() - self.p.dcs.loop_wait - 1
self.p.schedule_next_run()
def test_noloadbalance(self):
self.p.tags['noloadbalance'] = True
self.assertTrue(self.p.noloadbalance)
def test_nofailover(self):
self.p.tags['nofailover'] = True
self.assertTrue(self.p.nofailover)
self.p.tags['nofailover'] = None
self.assertFalse(self.p.nofailover)
def test_replicatefrom(self):
self.assertIsNone(self.p.replicatefrom)
self.p.tags['replicatefrom'] = 'foo'
self.assertEqual(self.p.replicatefrom, 'foo')
def test_reload_config(self):
self.p.reload_config()
self.p.get_tags = Mock(side_effect=Exception)
self.p.reload_config()
def test_nosync(self):
self.p.tags['nosync'] = True
self.assertTrue(self.p.nosync)
self.p.tags['nosync'] = None
self.assertFalse(self.p.nosync)
@patch.object(Thread, 'join', Mock())
def test_shutdown(self):
self.p.api.shutdown = Mock(side_effect=Exception)
self.p.shutdown()
def test_check_psycopg2(self):
with patch.object(builtins, '__import__',
Mock(side_effect=ImportError)):
self.assertRaises(SystemExit, check_psycopg2)
with patch('psycopg2.__version__', '2.5.3.dev1 a b c'):
self.assertRaises(SystemExit, check_psycopg2)
def test_empty_attribute_returns_none(self):
fake_rushes = PropertyMock(return_value=None)
type(self.boxscore)._away_rush_attempts = fake_rushes
assert self.boxscore.away_rush_attempts is None
import unittest
import os
from mock import PropertyMock
from mock import patch
from worklog import Worklog
@patch('worklog_test.Worklog.time', PropertyMock(return_value='23:52'))
@patch('worklog_test.Worklog.date',
PropertyMock(return_value='01.02.2014 Saturday'))
class WorklogTest(unittest.TestCase):
def setUp(self):
try:
os.mkdir('data')
testing = open('data/testing.md', 'w')
testing.writelines(
["* 23:41 first entry\n", "* 23:42 last entry\n"])
testing.close()
except FileExistsError:
print("data directory is dirty.")
self.worklog = Worklog('data/testing.md')
def tearDown(self):
os.remove('data/testing.md')
os.rmdir('data')
def test_last(self):
last = self.worklog.get_last()
self.assertEqual('* 23:41 first entry\n', last[0])
self.assertEqual('* 23:42 last entry\n', last[1])
def test_cmd_praise(self, mock_dice_check, mock_get_week,
mock_dom_get_week):
from web.character.models import PlayerAccount
from world.dominion.models import Organization, AssetOwner, RPEvent
self.roster_entry.current_account = PlayerAccount.objects.create(
email="*****@*****.**")
self.roster_entry.save()
self.setup_cmd(social.CmdPraise, self.account)
mock_get_week.return_value = 1
mock_dom_get_week.return_value = 1
self.assertEqual(
self.account.get_current_praises_and_condemns().count(), 0)
self.call_cmd("testaccount2",
"You have already used all your praises for the week.")
# property mocks have to be reset at the end, or screws up other tests
old = type(self.char1).social_clout
prop_mock = PropertyMock(return_value=10)
type(self.char1).social_clout = prop_mock
mock_dice_check.return_value = 50
self.call_cmd(
"testaccount2,-2=hi",
"The number of praises used must be a positive number, "
"and less than your max praises.")
self.call_cmd(
"testaccount2,99=hi",
"The number of praises used must be a positive number, "
"and less than your max praises.")
self.account2.inform = Mock()
self.call_cmd(
"/all testaccount2=hi",
'You use 1 action points and have 99 remaining this week.|'
'You praise the actions of Testaccount2. You have 0 praises remaining.'
)
self.account2.inform.assert_called_with(
'Testaccount has praised you. Your prestige has been adjusted by 90.',
append=False,
category='Praised',
week=1)
self.assertEqual(self.assetowner2.fame, 90)
self.assertEqual(
self.account.get_current_praises_and_condemns().count(), 1)
org = Organization.objects.create(name="test org")
org.inform = Mock()
org_assets = AssetOwner.objects.create(organization_owner=org)
self.call_cmd("/org foo", "No organization by that name.")
self.call_cmd(
"/org test org",
'There is no event going on that has test org as a sponsor.')
event = RPEvent.objects.create(name="test event", location=self.room)
self.room.db.current_event = event.id
event.org_event_participation.create(org=org, social=50)
prop_mock.return_value = 50
self.call_cmd(
"/org test org,40=hi2u",
'You use 1 action points and have 98 remaining this week.|'
'You praise the actions of Test org. You have 0 praises remaining.'
)
org.inform.assert_called_with(
'Testaccount has praised you. Your prestige has been adjusted by 10200.',
append=False,
category='Praised',
week=1)
self.assertEqual(org_assets.fame, 10200)
# cleanup property mock
type(self.char1).social_clout = old
def _create_mField_():
mField = mock.create_autospec(Field, spec_set=True, instance=True)
p_grid = PropertyMock(return_value=mGrid)
type(mField).grid = p_grid
return mField, p_grid
def test_change_colorbar_config(self):
view_colorbar_range_mock = PropertyMock()
view_colorbar_log_mock = PropertyMock()
type(self.view).colorbar_range = view_colorbar_range_mock
type(self.view).colorbar_log = view_colorbar_log_mock
model_colorbar_range_mock = PropertyMock(return_value=(1, 5))
model_colorbar_log_mock = PropertyMock(return_value=False)
type(self.model).colorbar_range = model_colorbar_range_mock
type(self.model).colorbar_log = model_colorbar_log_mock
# passed model -> view
self.presenter = SlicePlotOptionsPresenter(self.view, self.model)
model_colorbar_range_mock.assert_called_with()
model_colorbar_log_mock.assert_called_with()
view_colorbar_range_mock.assert_called_once_with((1, 5))
view_colorbar_log_mock.assert_called_once_with(False)
# passed view -> model
view_colorbar_range_mock.return_value = (2, 10)
view_colorbar_log_mock.return_value = True
self.presenter._set_c_range()
self.presenter._set_colorbar_log()
self.presenter.get_new_config()
self.model.change_axis_scale.assert_called_once_with((2, 10), True)
