def fake_key_pair_info(): mocked = mock.Mock() mocked.delete = mock.Mock() type(mocked).key_fingerprint = mock.PropertyMock() return mocked
def setUp(self): self.mock_orchestration = mock.Mock() self.mock_stacks = mock.MagicMock() self.stack_status = mock.PropertyMock() type(self.mock_stacks).stack_status = self.stack_status self.mock_orchestration.stacks.get.return_value = self.mock_stacks
def test_cannot_register_draft_that_is_pending_review(self, mock_enqueue, app, user, payload, url_registrations): with mock.patch.object(DraftRegistration, 'is_pending_review', mock.PropertyMock(return_value=True)): res = app.post_json_api(url_registrations, payload, auth=user.auth, expect_errors=True) assert res.status_code == 403 assert res.json['errors'][0]['detail'] == 'This draft is pending review and cannot be modified.'
def setUp(self): mock.patch.object( mech_driver.OpenDaylightDriver, 'out_of_sync', new_callable=mock.PropertyMock(return_value=False)).start() super(OpenDaylightMechanismTestPortsV2, self).setUp()
def test_sync(self, connection): """Test gmsa.HostGroupWatch.sync.""" # Access protected module # pylint: disable=W0212 server1_path = os.path.join(self.placement_dir, 'server1.ad.com') os.mkdir(server1_path) utils.touch(os.path.join(server1_path, 'proid1.app#0000000000001')) server2_path = os.path.join(self.placement_dir, 'server2.ad.com') os.mkdir(server2_path) utils.touch(os.path.join(server2_path, 'proid4.app#0000000000004')) server3_path = os.path.join(self.placement_dir, 'server3.ad.com') os.mkdir(server3_path) server4_path = os.path.join(self.placement_dir, 'server4.ad.com') os.mkdir(server4_path) utils.touch(os.path.join(server4_path, 'proid3.app#0000000000003')) server5_path = os.path.join(self.placement_dir, 'server5.ad.com') os.mkdir(server5_path) utils.touch(os.path.join(server5_path, 'proid5.app#0000000000005')) utils.touch(os.path.join(server5_path, 'proid5.app#0000000000006')) with io.open(os.path.join(self.servers_dir, 'server1.ad.com'), 'w') as f: yaml.dump({ servers.DC_KEY: 'dc.ad.com', servers.DN_KEY: 'CN=server1,DC=AD,DC=COM', 'partition': 'partition1' }, f) with io.open(os.path.join(self.servers_dir, 'server2.ad.com'), 'w') as f: yaml.dump({ servers.DC_KEY: 'dc.ad.com', servers.DN_KEY: 'CN=server2,DC=AD,DC=COM', 'partition': 'partition1' }, f) with io.open(os.path.join(self.servers_dir, 'server3.ad.com'), 'w') as f: yaml.dump({ servers.DC_KEY: 'dc.ad.com', servers.DN_KEY: 'CN=server3,DC=AD,DC=COM', 'partition': 'partition1' }, f) with io.open(os.path.join(self.servers_dir, 'server5.ad.com'), 'w') as f: yaml.dump({ servers.DC_KEY: 'dc.ad.com', servers.DN_KEY: 'CN=server5,DC=AD,DC=COM', 'partition': 'partition1' }, f) mock_connection = mock.MagicMock() connection.return_value = mock_connection type(mock_connection).result = mock.PropertyMock(side_effect={ 'result': 0 }) type(mock_connection).response = mock.PropertyMock(return_value=[ {'attributes': { 'samAccountName': 'proid1-gmsa-hosts', 'member': ['CN=server1,DC=AD,DC=COM'] }}, {'attributes': { 'samAccountName': 'proid2-gmsa-hosts', 'member': ['CN=server3,DC=AD,DC=COM'] }}, {'attributes': { 'samAccountName': 'proid3-gmsa-hosts', 'member': [] }}, {'attributes': { 'samAccountName': 'proid4-gmsa-hosts', 'member': [] }}, {'attributes': { 'samAccountName': 'proid5-gmsa-hosts', 'member': [] }} ]) watch = gmsa.HostGroupWatch(self.root, 'partition1', 'OU=test,DC=ad,DC=com', '{}-gmsa-hosts') watch._sync() self.assertEqual(watch._proids, { 'proid1': {'CN=server1,DC=AD,DC=COM': 1}, 'proid2': {}, 'proid3': {}, 'proid4': {'CN=server2,DC=AD,DC=COM': 1}, 'proid5': {'CN=server5,DC=AD,DC=COM': 2}, }) mock_connection.modify.assert_has_calls( [ mock.call('CN=proid2-gmsa-hosts,OU=test,DC=ad,DC=com', {'member': [(ldap3.MODIFY_DELETE, ['CN=server3,DC=AD,DC=COM'])]}), mock.call('CN=proid4-gmsa-hosts,OU=test,DC=ad,DC=com', {'member': [(ldap3.MODIFY_ADD, ['CN=server2,DC=AD,DC=COM'])]}), mock.call('CN=proid5-gmsa-hosts,OU=test,DC=ad,DC=com', {'member': [(ldap3.MODIFY_ADD, ['CN=server5,DC=AD,DC=COM'])]}), ], any_order=True )
class TestGitHubAuthViews(GitHubAddonTestCase, OAuthAddonAuthViewsTestCaseMixin, OsfTestCase): @mock.patch('addons.github.models.UserSettings.revoke_remote_oauth_access', mock.PropertyMock()) def test_delete_external_account(self): super(TestGitHubAuthViews, self).test_delete_external_account()
def test_name(packagehandler): type(packagehandler.setuphandler).name = mock.PropertyMock( return_value='name') assert packagehandler.name == 'name'
def _mock_env(fingerprint=None): env = mock.Mock() prop_fingerprint = mock.PropertyMock(return_value=fingerprint) type(env).fingerprint = prop_fingerprint return env
def _mock_static(pod, path_format, locale=None): doc = mock.Mock() type(doc).pod = mock.PropertyMock(return_value=pod) type(doc).path_format = mock.PropertyMock(return_value=path_format) type(doc).locale = mock.PropertyMock(return_value=locale) return doc
class TestApiBaseViews(ApiTestCase): def setUp(self): super(TestApiBaseViews, self).setUp() self.EXCLUDED_VIEWS = [MoveFileMetadataView, CopyFileMetadataView] def test_root_returns_200(self): res = self.app.get('/{}'.format(API_BASE)) assert_equal(res.status_code, 200) def test_does_not_exist_returns_404(self): res = self.app.get('/{}{}'.format(API_BASE, "notapage"), expect_errors=True) assert_equal(res.status_code, 404) def test_does_not_exist_formatting(self): if DEBUG_MODE: raise SkipTest else: url = '/{}{}/'.format(API_BASE, 'notapage') res = self.app.get(url, expect_errors=True) errors = res.json['errors'] assert (isinstance(errors, list)) assert_equal(errors[0], {'detail': 'Not found.'}) def test_view_classes_have_minimal_set_of_permissions_classes(self): base_permissions = [ TokenHasScope, (IsAuthenticated, IsAuthenticatedOrReadOnly) ] for view in VIEW_CLASSES: if view in self.EXCLUDED_VIEWS: continue for cls in base_permissions: if isinstance(cls, tuple): has_cls = any([c in view.permission_classes for c in cls]) assert_true( has_cls, "{0} lacks the appropriate permission classes".format( view)) else: assert_in( cls, view.permission_classes, "{0} lacks the appropriate permission classes".format( view)) for key in ['read', 'write']: scopes = getattr(view, 'required_{}_scopes'.format(key), None) assert_true(bool(scopes)) for scope in scopes: assert_is_not_none(scope) if key == 'write': assert_not_in(CoreScopes.ALWAYS_PUBLIC, scopes) def test_view_classes_support_embeds(self): for view in VIEW_CLASSES: if view in self.EXCLUDED_VIEWS: continue assert_true(hasattr(view, '_get_embed_partial'), "{0} lacks embed support".format(view)) def test_view_classes_define_or_override_serializer_class(self): for view in VIEW_CLASSES: has_serializer_class = getattr(view, 'serializer_class', None) or \ getattr(view, 'get_serializer_class', None) assert_true( has_serializer_class, "{0} should include serializer class or override get_serializer_class()" .format(view)) @mock.patch('osf.models.OSFUser.is_confirmed', mock.PropertyMock(return_value=False)) def test_unconfirmed_user_gets_error(self): user = factories.AuthUserFactory() res = self.app.get('/{}nodes/'.format(API_BASE), auth=user.auth, expect_errors=True) assert_equal(res.status_code, http.BAD_REQUEST) @mock.patch('osf.models.OSFUser.is_disabled', mock.PropertyMock(return_value=True)) def test_disabled_user_gets_error(self): user = factories.AuthUserFactory() res = self.app.get('/{}nodes/'.format(API_BASE), auth=user.auth, expect_errors=True) assert_equal(res.status_code, http.BAD_REQUEST)
def testrail_client(mocker): fake_statuses = mock.PropertyMock(return_value={1: 'passed', 2: 'skipped'}) mocker.patch('xunit2testrail.reporter.TrClient.statuses', new_callable=fake_statuses) return
def test_target_capacity(mock_resource_group, is_stale): with mock.patch(f'{__name__}.MockResourceGroup.is_stale', mock.PropertyMock(return_value=is_stale)): assert mock_resource_group.target_capacity == 0 if is_stale else 5
def test_workflow(self, fake_requests, client_logger, logger): self.dispatcher = gnocchi.GnocchiDispatcher(self.conf.conf) base_url = self.dispatcher.conf.dispatcher_gnocchi.url url_params = { 'url': urlparse.urljoin(base_url, '/v1/resource'), # NOTE(sileht): we don't use urlparse.quote here # to ensure / is converted in %2F 'resource_id': self.sample['resource_id'].replace("/", "%2F"), 'resource_type': self.resource_type, 'metric_name': self.sample['counter_name'] } headers = { 'Content-Type': 'application/json', 'X-Auth-Token': 'fake_token' } patch_responses = [] post_responses = [] # This is needed to mock Exception in py3 fake_requests.ConnectionError = requests.ConnectionError expected_calls = [ mock.call.session(), mock.call.session().mount('http://', mock.ANY), mock.call.session().mount('https://', mock.ANY), mock.call.session().post( "%(url)s/%(resource_type)s/%(resource_id)s/" "metric/%(metric_name)s/measures" % url_params, headers=headers, data=json_matcher(self.measures_attributes)) ] post_responses.append(MockResponse(self.measure)) if self.measure == 401: type(self.ks_client).auth_token = mock.PropertyMock(side_effect=[ 'fake_token', 'new_token', 'new_token', 'new_token', 'new_token' ]) headers = { 'Content-Type': 'application/json', 'X-Auth-Token': 'new_token' } expected_calls.append(mock.call.session().post( "%(url)s/%(resource_type)s/%(resource_id)s/" "metric/%(metric_name)s/measures" % url_params, headers=headers, data=json_matcher(self.measures_attributes))) post_responses.append(MockResponse(200)) if self.post_resource: attributes = self.postable_attributes.copy() attributes.update(self.patchable_attributes) attributes['id'] = self.sample['resource_id'] attributes['metrics'] = dict((metric_name, { 'archive_policy_name': 'low' }) for metric_name in self.metric_names) expected_calls.append( mock.call.session().post("%(url)s/%(resource_type)s" % url_params, headers=headers, data=json_matcher(attributes)), ) post_responses.append(MockResponse(self.post_resource)) if self.metric: expected_calls.append(mock.call.session().post( "%(url)s/%(resource_type)s/%(resource_id)s/metric" % url_params, headers=headers, data=json_matcher({ self.sample['counter_name']: { 'archive_policy_name': 'low' } }))) post_responses.append(MockResponse(self.metric)) if self.measure_retry: expected_calls.append(mock.call.session().post( "%(url)s/%(resource_type)s/%(resource_id)s/" "metric/%(metric_name)s/measures" % url_params, headers=headers, data=json_matcher(self.measures_attributes))) post_responses.append(MockResponse(self.measure_retry)) if self.patch_resource and self.patchable_attributes: expected_calls.append( mock.call.session().patch( "%(url)s/%(resource_type)s/%(resource_id)s" % url_params, headers=headers, data=json_matcher(self.patchable_attributes)), ) patch_responses.append(MockResponse(self.patch_resource)) s = fake_requests.session.return_value s.patch.side_effect = patch_responses s.post.side_effect = post_responses self.dispatcher.record_metering_data([self.sample]) # Check that the last log message is the expected one if self.measure == 500 or self.measure_retry == 500: logger.error.assert_called_with( "Fail to post measure on metric %s of resource %s " "with status: %d: Internal Server Error" % (self.sample['counter_name'], self.sample['resource_id'], 500)) elif self.post_resource == 500 or (self.patch_resource == 500 and self.patchable_attributes): logger.error.assert_called_with( "Resource %s %s failed with status: " "%d: Internal Server Error" % (self.sample['resource_id'], 'update' if self.patch_resource else 'creation', 500)) elif self.metric == 500: logger.error.assert_called_with( "Fail to create metric %s of resource %s " "with status: %d: Internal Server Error" % (self.sample['counter_name'], self.sample['resource_id'], 500)) elif self.patch_resource == 204 and self.patchable_attributes: client_logger.debug.assert_called_with('Resource %s updated', self.sample['resource_id']) elif self.measure == 200: client_logger.debug.assert_called_with( "Measure posted on metric %s of resource %s", self.sample['counter_name'], self.sample['resource_id']) self.assertEqual(expected_calls, fake_requests.mock_calls)
def test_raises_for_invalid_json_body(self, user, pyramid_request, patch): type(pyramid_request).json_body = mock.PropertyMock( side_effect=ValueError()) with pytest.raises(PayloadError): update(user, pyramid_request)
class ViewTests(TestCase): def verify_health_response(self, expected_status_code, overall_status, database_connection, analytics_api): """Verify that the health endpoint returns the expected response.""" response = self.client.get(reverse('health')) self.assertEqual(response.status_code, expected_status_code) self.assertEqual(response['content-type'], 'application/json') expected = { u'overall_status': overall_status, u'detailed_status': { u'database_connection': database_connection, u'analytics_api': analytics_api } } self.assertDictEqual(json.loads(response.content), expected) def test_status(self): response = self.client.get(reverse('status')) self.assertEqual(response.status_code, 200) @mock.patch('analyticsclient.status.Status.healthy', mock.PropertyMock(return_value=True)) def test_healthy(self): with LogCapture(level=logging.ERROR) as l: self.verify_health_response(expected_status_code=200, overall_status=OK, database_connection=OK, analytics_api=OK) l.check() @mock.patch('analyticsclient.status.Status.healthy', mock.PropertyMock(return_value=True)) @mock.patch('django.db.backends.BaseDatabaseWrapper.cursor', mock.Mock(side_effect=DatabaseError('example error'))) def test_health_database_outage(self): with LogCapture(level=logging.ERROR) as l: self.verify_health_response(expected_status_code=503, overall_status=UNAVAILABLE, database_connection=UNAVAILABLE, analytics_api=OK) l.check(('analytics_dashboard.core.views', 'ERROR', 'Insights database is not reachable: example error')) @mock.patch('analyticsclient.status.Status.healthy', mock.PropertyMock(return_value=False)) def test_health_analytics_api_unhealthy(self): with LogCapture(level=logging.ERROR) as l: self.verify_health_response(expected_status_code=503, overall_status=UNAVAILABLE, database_connection=OK, analytics_api=UNAVAILABLE) l.check(('analytics_dashboard.core.views', 'ERROR', 'Analytics API health check failed from dashboard')) @mock.patch('analyticsclient.status.Status.healthy', mock.PropertyMock(side_effect=TimeoutError('example error'))) def test_health_analytics_api_unreachable(self): with LogCapture(level=logging.ERROR) as l: self.verify_health_response(expected_status_code=503, overall_status=UNAVAILABLE, database_connection=OK, analytics_api=UNAVAILABLE) l.check(( 'analytics_dashboard.core.views', 'ERROR', 'Analytics API health check timed out from dashboard: example error' )) @mock.patch('analyticsclient.status.Status.healthy', mock.PropertyMock(return_value=False)) @mock.patch('django.db.backends.BaseDatabaseWrapper.cursor', mock.Mock(side_effect=DatabaseError('example error'))) def test_health_both_unavailable(self): with LogCapture(level=logging.ERROR) as l: self.verify_health_response(expected_status_code=503, overall_status=UNAVAILABLE, database_connection=UNAVAILABLE, analytics_api=UNAVAILABLE) l.check(('analytics_dashboard.core.views', 'ERROR', 'Insights database is not reachable: example error'), ('analytics_dashboard.core.views', 'ERROR', 'Analytics API health check failed from dashboard'))
def _mock_collection(basename=None, root=None): collection = mock.Mock() type(collection).basename = mock.PropertyMock(return_value=basename) type(collection).root = mock.PropertyMock(return_value=root) return collection
def setUp(self): super(TestTokenController, self).setUp() type(pecan.request).remote_user = mock.PropertyMock( return_value=USERNAME)
def test_str_operator(self): mock_invite = hikari_test_helpers.mock_class_namespace( invites.InviteCode, code=mock.PropertyMock(return_value="hikari"))() assert str(mock_invite) == "https://discord.gg/hikari"
def test_can_mark_complete_admin_grader(self, available_now): with patch_obj(self.block_to_test, 'is_admin_grader', mock.PropertyMock(return_value=True)), \ patch_obj(self.block_to_test, 'available_now', mock.PropertyMock(return_value=available_now)): self.assertEqual(self.block.can_mark_complete, True)
def test_question_property_no_questions(self): with mock.patch.object(self.block_to_test, 'activity_questions', mock.PropertyMock(return_value=[])): self.assertIsNone(self.block.question)
The newly-created Event entities. """ return [CreateEvent(blockable) for _ in xrange(event_count)] def CreateSantaEvents(blockable, event_count): return [CreateSantaEvent(blockable) for _ in xrange(event_count)] def CreateBit9Events(blockable, event_count): return [CreateBit9Event(blockable) for _ in xrange(event_count)] @mock.patch.object(settings.ProdEnv, 'ENABLE_BIGQUERY_STREAMING', new_callable=mock.PropertyMock(return_value=False)) def CreateUser(_, admin=False, **kwargs): """Creates an User entity. Args: admin: Whether or not administrative privileges should be assigned. **kwargs: Dictionary of any user properties to customize. Returns: The newly created User. """ email = kwargs.pop('email', None) or RandomEmail() roles = set(kwargs.pop('roles', [])) # Create an User entity if one doesn't exist, and update the resulting # entity with any overridden properties.
def test_question_property_no_matching_questions(self): self.block.question_id = 'q1' questions = [make_question('123', '123'), make_question('456', '456')] with mock.patch.object(self.block_to_test, 'activity_questions', mock.PropertyMock(return_value=questions)): self.assertIsNone(self.block.question)
def test_exec_command(self): gsc_mock = self.patch('tempest_lib.common.ssh.Client.' '_get_ssh_connection') ito_mock = self.patch('tempest_lib.common.ssh.Client._is_timed_out') select_mock = self.patch('select.poll') client_mock = mock.MagicMock() tran_mock = mock.MagicMock() chan_mock = mock.MagicMock() poll_mock = mock.MagicMock() def reset_mocks(): gsc_mock.reset_mock() ito_mock.reset_mock() select_mock.reset_mock() poll_mock.reset_mock() client_mock.reset_mock() tran_mock.reset_mock() chan_mock.reset_mock() select_mock.return_value = poll_mock gsc_mock.return_value = client_mock ito_mock.return_value = True client_mock.get_transport.return_value = tran_mock tran_mock.open_session.return_value = chan_mock poll_mock.poll.side_effect = [[0, 0, 0]] # Test for a timeout condition immediately raised client = ssh.Client('localhost', 'root', timeout=2) with testtools.ExpectedException(exceptions.TimeoutException): client.exec_command("test") chan_mock.fileno.assert_called_once_with() chan_mock.exec_command.assert_called_once_with("test") chan_mock.shutdown_write.assert_called_once_with() SELECT_POLLIN = 1 poll_mock.register.assert_called_once_with(chan_mock, SELECT_POLLIN) poll_mock.poll.assert_called_once_with(10) # Test for proper reading of STDOUT and STDERROR and closing # of all file descriptors. reset_mocks() select_mock.return_value = poll_mock gsc_mock.return_value = client_mock ito_mock.return_value = False client_mock.get_transport.return_value = tran_mock tran_mock.open_session.return_value = chan_mock poll_mock.poll.side_effect = [[1, 0, 0]] closed_prop = mock.PropertyMock(return_value=True) type(chan_mock).closed = closed_prop chan_mock.recv_exit_status.return_value = 0 chan_mock.recv.return_value = '' chan_mock.recv_stderr.return_value = '' client = ssh.Client('localhost', 'root', timeout=2) client.exec_command("test") chan_mock.fileno.assert_called_once_with() chan_mock.exec_command.assert_called_once_with("test") chan_mock.shutdown_write.assert_called_once_with() SELECT_POLLIN = 1 poll_mock.register.assert_called_once_with(chan_mock, SELECT_POLLIN) poll_mock.poll.assert_called_once_with(10) chan_mock.recv_ready.assert_called_once_with() chan_mock.recv.assert_called_once_with(1024) chan_mock.recv_stderr_ready.assert_called_once_with() chan_mock.recv_stderr.assert_called_once_with(1024) chan_mock.recv_exit_status.assert_called_once_with() closed_prop.assert_called_once_with()
def test_question_property_one_matching_question(self): self.block.question_id = '456' questions = [make_question('123', '123'), make_question('456', '456')] with mock.patch.object(self.block_to_test, 'activity_questions', mock.PropertyMock(return_value=questions)): self.assertEqual(self.block.question, questions[1])
class TestRegistrationRetractions(SearchTestCase): def setUp(self): super(TestRegistrationRetractions, self).setUp() self.user = UserFactory(usename='Doug Bogie') self.title = 'Red Special' self.consolidate_auth = Auth(user=self.user) self.project = ProjectFactory( title=self.title, creator=self.user, is_public=True, ) self.registration = RegistrationFactory( project=self.project, title=self.title, creator=self.user, is_public=True, is_registration=True ) def test_retraction_is_searchable(self): self.registration.retract_registration(self.user) docs = query('category:registration AND ' + self.title)['results'] assert_equal(len(docs), 1) @mock.patch('website.project.model.Node.archiving', mock.PropertyMock(return_value=False)) def test_pending_retraction_wiki_content_is_searchable(self): # Add unique string to wiki wiki_content = {'home': 'public retraction test'} for key, value in wiki_content.items(): docs = query(value)['results'] assert_equal(len(docs), 0) self.registration.update_node_wiki( key, value, self.consolidate_auth, ) # Query and ensure unique string shows up docs = query(value)['results'] assert_equal(len(docs), 1) # Query and ensure registration does show up docs = query('category:registration AND ' + self.title)['results'] assert_equal(len(docs), 1) # Retract registration self.registration.retract_registration(self.user, '') self.registration.save() self.registration.reload() # Query and ensure unique string in wiki doesn't show up docs = query('category:registration AND "{}"'.format(wiki_content['home']))['results'] assert_equal(len(docs), 1) # Query and ensure registration does show up docs = query('category:registration AND ' + self.title)['results'] assert_equal(len(docs), 1) @mock.patch('website.project.model.Node.archiving', mock.PropertyMock(return_value=False)) def test_retraction_wiki_content_is_not_searchable(self): # Add unique string to wiki wiki_content = {'home': 'public retraction test'} for key, value in wiki_content.items(): docs = query(value)['results'] assert_equal(len(docs), 0) self.registration.update_node_wiki( key, value, self.consolidate_auth, ) # Query and ensure unique string shows up docs = query(value)['results'] assert_equal(len(docs), 1) # Query and ensure registration does show up docs = query('category:registration AND ' + self.title)['results'] assert_equal(len(docs), 1) # Retract registration self.registration.retract_registration(self.user, '') self.registration.retraction.state = Retraction.APPROVED self.registration.retraction.save() self.registration.save() self.registration.update_search() # Query and ensure unique string in wiki doesn't show up docs = query('category:registration AND "{}"'.format(wiki_content['home']))['results'] assert_equal(len(docs), 0) # Query and ensure registration does show up docs = query('category:registration AND ' + self.title)['results'] assert_equal(len(docs), 1)
def test_question_property_multiple_matching_questions(self): self.block.question_id = '123' questions = [make_question('123', '123'), make_question('123', '123')] with mock.patch.object(self.block_to_test, 'activity_questions', mock.PropertyMock(return_value=questions)), \ self.assertRaises(ValueError): _ = self.block.question # pylint:disable=invalid-name
def test_has_updates_is_false_if_active_with_no_output(self): target = ('neutron.agent.linux.ovsdb_monitor.SimpleInterfaceMonitor' '.is_active') with mock.patch(target, new_callable=mock.PropertyMock(return_value=True)): self.assertFalse(self.monitor.has_updates)
def _test_update_device_up(self, extensions, kwargs): with mock.patch('neutron.plugins.ml2.plugin.Ml2Plugin' '._device_to_port_id'): type(self.l3plugin).supported_extension_aliases = ( mock.PropertyMock(return_value=extensions)) self.callbacks.update_device_up(mock.ANY, **kwargs)
def test_cannot_register_draft_that_has_already_been_approved(self, app, user, payload, url_registrations): with mock.patch.object(DraftRegistration, 'requires_approval', mock.PropertyMock(return_value=True)), mock.patch.object(DraftRegistration, 'is_approved', mock.PropertyMock(return_value=True)): res = app.post_json_api(url_registrations, payload, auth=user.auth, expect_errors=True) assert res.status_code == 403 assert res.json['errors'][0]['detail'] == 'This draft has already been approved and cannot be modified.'
class TestNodeSettings(OAuthAddonNodeSettingsTestSuiteMixin, unittest.TestCase): short_name = 'gitlab' full_name = 'GitLab' ExternalAccountFactory = GitLabAccountFactory NodeSettingsFactory = GitLabNodeSettingsFactory NodeSettingsClass = NodeSettings UserSettingsFactory = GitLabUserSettingsFactory ## Mixin Overrides ## def _node_settings_class_kwargs(self, node, user_settings): return { 'user_settings': self.user_settings, 'repo': 'mock', 'user': '******', 'owner': self.node, 'repo_id': '123' } def test_set_folder(self): # GitLab doesn't use folderpicker, and the nodesettings model # does not need a `set_repo` method pass def test_serialize_settings(self): # GitLab's serialized_settings are a little different from # common storage addons. settings = self.node_settings.serialize_waterbutler_settings() expected = { 'host': 'https://some-super-secret', 'owner': 'abc', 'repo': 'mock', 'repo_id': '123' } assert_equal(settings, expected) @mock.patch('addons.gitlab.models.UserSettings.revoke_remote_oauth_access', mock.PropertyMock()) def test_complete_has_auth_not_verified(self): super(TestNodeSettings, self).test_complete_has_auth_not_verified() @mock.patch('addons.gitlab.api.GitLabClient.repos') def test_to_json(self, mock_repos): mock_repos.return_value = {} super(TestNodeSettings, self).test_to_json() @mock.patch('addons.gitlab.api.GitLabClient.repos') def test_to_json_user_is_owner(self, mock_repos): mock_repos.return_value = {} result = self.node_settings.to_json(self.user) assert_true(result['user_has_auth']) assert_equal(result['gitlab_user'], 'abc') assert_true(result['is_owner']) assert_true(result['valid_credentials']) assert_equal(result.get('gitlab_repo', None), 'mock') @mock.patch('addons.gitlab.api.GitLabClient.repos') def test_to_json_user_is_not_owner(self, mock_repos): mock_repos.return_value = {} not_owner = UserFactory() result = self.node_settings.to_json(not_owner) assert_false(result['user_has_auth']) assert_equal(result['gitlab_user'], 'abc') assert_false(result['is_owner']) assert_true(result['valid_credentials']) assert_equal(result.get('repo_names', None), None)