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)