def test_check_answer(self): test_cases = [ TCData(([0, 3, 1, 2], 2, [0, 2]), True), TCData(([2, 1, 0], 2, [1, 2]), True), TCData(([2, 0, 1], 1, [1]), True), TCData(([3, 1, 2, 0], 2, [1, 3]), True), TCData(([3, 1, 2, 0], 2, [3, 1]), True), TCData(([3, 1, 2, 0], 4, [3, 1, 0, 2]), True), TCData(([3, 1, 2, 0], 4, [3, 1, 2, 0]), True), TCData(([0, 3, 1, 2], 1, [0, 1]), False), TCData(([2, 1, 0], 2, []), False), TCData(([2, 0, 1], 1, [0, 2]), False), TCData(([3, 1, 2, 0], 1, [1]), False), TCData(([1, 3, 2, 0], 2, [3, 1]), False), TCData(([3, 1, 2, 0], 4, [1, 2, 0]), False) ] for test_case in test_cases: subpart_question_mock = NonCallableMagicMock(spec_set=['options']) subpart_question_mock.options = NonCallableMagicMock( spec_set=['order', 'correct']) subpart_question_mock.options.order = test_case.input[0] subpart_question_mock.options.correct = NonCallableMagicMock( spec_set=['__len__']) subpart_question_mock.options.correct.__len__ = MagicMock( return_value=test_case.input[1]) mcmaq_answer = MCMAQAnswer(test_case.input[2], None) mcmaq_answer.check_answer(subpart_question_mock) self.assertEqual(mcmaq_answer.correct, test_case.expected_output)
def setUp(self): super(DesignateBackendTest, self).setUp() opts = RoObject(username='******', password='******', project_name='project', project_zone_name='project_zone', user_zone_name='user_zone') self.target = RoObject({ 'id': '4588652b-50e7-46b9-b688-a9bad40a873e', 'type': 'dyndns', 'masters': [RoObject({ 'host': '192.0.2.1', 'port': 53 })], 'options': opts }) # Backends blow up when trying to self.admin_context = ... due to # policy not being initialized self.admin_context = Mock() get_context_patcher = patch( 'designate.context.DesignateContext.get_admin_context') get_context = get_context_patcher.start() get_context.return_value = self.admin_context self.backend = impl_designate.DesignateBackend(self.target) # Mock client self.client = NonCallableMagicMock() zones = NonCallableMagicMock(spec_set=['create', 'delete']) self.client.configure_mock(zones=zones)
def test_check_answer(self): test_cases = [ TCData(('12', None, '11.99'), False), TCData(('1', None, '1001/1000'), False), TCData(('19.45', None, '19.455'), False), TCData(('19.45', None, '19.4500'), True), TCData(('6.25', None, '25/4'), True), TCData(('6.25', None, '6.25'), True), TCData(('19.45000000', None, '19.450'), True), TCData(('-1.7', 0.05, '- 10/6'), True), TCData(('1.47', 0.01, '1.459'), True), TCData((str(Decimal(22) / Decimal(7)), 0.02, '3.129'), True), TCData(('1.292', 0.005, '1.2983'), False), TCData(('1.292', 0.005, '1.2857'), False), TCData(('1.292', 0.005, '1.29299'), True), ] for test_case in test_cases: subpart_question_mock = NonCallableMagicMock(spec_set=['answer']) subpart_question_mock.answer = NonCallableMagicMock( spec_set=['tolerance', 'value']) subpart_question_mock.answer.value = test_case.input[0] subpart_question_mock.answer.tolerance = test_case.input[1] numeric_answer = NumericAnswer(test_case.input[2], None) numeric_answer.check_answer(subpart_question_mock) self.assertEqual(numeric_answer.correct, test_case.expected_output)
def test_return_defunct_connection_on_down_host(self): host = Mock(spec=Host, address='ip1') session = self.make_session() conn = NonCallableMagicMock(spec=Connection, in_flight=0, is_defunct=False, is_closed=False, max_request_id=100, signaled_error=False) session.cluster.connection_factory.return_value = conn pool = HostConnectionPool(host, HostDistance.LOCAL, session) session.cluster.connection_factory.assert_called_once_with( host.address) pool.borrow_connection(timeout=0.01) conn.is_defunct = True session.cluster.signal_connection_failure.return_value = True pool.return_connection(conn) # the connection should be closed a new creation scheduled self.assertTrue(session.cluster.signal_connection_failure.call_args) self.assertTrue(conn.close.call_args) self.assertFalse(session.submit.called) self.assertTrue(pool.is_shutdown)
def test_spawn_when_at_max(self): host = Mock(spec=Host, address='ip1') session = self.make_session() conn = NonCallableMagicMock(spec=Connection, in_flight=0, is_defunct=False, is_closed=False) session.cluster.connection_factory.return_value = conn # core conns = 1, max conns = 2 session.cluster.get_max_connections_per_host.return_value = 2 pool = HostConnectionPool(host, HostDistance.LOCAL, session) session.cluster.connection_factory.assert_called_once_with( host.address) pool.borrow_connection(timeout=0.01) self.assertEqual(1, conn.in_flight) # make this conn full conn.in_flight = MAX_STREAM_PER_CONNECTION # we don't care about making this borrow_connection call succeed for the # purposes of this test, as long as it results in a new connection # creation being scheduled self.assertRaises(NoConnectionsAvailable, pool.borrow_connection, 0) session.submit.assert_called_once_with(pool._create_new_connection)
def setUp(self): super(BaseRunning, self).setUp() self.getLogger_patcher = patch( "{src}.getLogger".format(**PATH), autospec=True, ) self.getLogger = self.getLogger_patcher.start() self.addCleanup(self.getLogger_patcher.stop) self.getUtility_patcher = patch( "{src}.getUtility".format(**PATH), autospec=True, ) self.getUtility = self.getUtility_patcher.start() self.addCleanup(self.getUtility_patcher.stop) self.LoopingCall_patcher = patch( "{src}.LoopingCall".format(**PATH), autospec=True, ) self.LoopingCall = self.LoopingCall_patcher.start() self.addCleanup(self.LoopingCall_patcher.stop) self.max_retries = self.getUtility.return_value.task_max_retries self.logger = self.getLogger.return_value self.loop = self.LoopingCall.return_value self.workers = NonCallableMagicMock(spec=WorkerPool) self.worklist = NonCallableMagicMock(spec=ZenHubWorklist) self.name = "default" self.running = _Running( self.name, self.worklist, self.workers, self.logger, ) self.reactor = Mock(spec=reactor)
def test_get_listed_users(self): usr1 = models.CassandraUser(self._get_random_name(1025)) usr2 = models.CassandraUser(self._get_random_name(1025)) usr3 = models.CassandraUser(self._get_random_name(1025)) db1 = models.CassandraSchema('db1') db2 = models.CassandraSchema('db2') usr1.databases.append(db1.serialize()) usr3.databases.append(db2.serialize()) rv_1 = NonCallableMagicMock() rv_1.configure_mock(name=usr1.name, super=False) rv_2 = NonCallableMagicMock() rv_2.configure_mock(name=usr2.name, super=False) rv_3 = NonCallableMagicMock() rv_3.configure_mock(name=usr3.name, super=True) with patch.object(self.conn, 'execute', return_value=iter( [rv_1, rv_2, rv_3])): with patch.object(self.admin, '_get_acl', return_value={usr1.name: {db1.name: {'SELECT'}, db2.name: {}}, usr3.name: {db2.name: {'SELECT'}}} ): usrs = self.manager.list_users(self.context) self.conn.execute.assert_has_calls([ call(self.__LIST_USR_FORMAT), ], any_order=True) self.assertIn(usr1.serialize(), usrs[0]) self.assertIn(usr2.serialize(), usrs[0]) self.assertIn(usr3.serialize(), usrs[0])
def mock_http_with_file(request): content = ''.join( chr(randrange(0, 256)) for x in xrange(0, 1024 * randrange(3, 10) + randrange(0, 1024))) def iter_content(chunk_size=1024): for i in xrange(0, len(content), chunk_size): yield content[i:i + chunk_size] mock_response = NonCallableMagicMock() mock_response.iter_content = MagicMock(side_effect=iter_content) mock_requests = NonCallableMagicMock() mock_requests.get = MagicMock(return_value=mock_response) mock_requests._mock_response = mock_response mock_requests._content = content patcher = patch( target='fabric_ovirt.lib.remote_files.requests', new=mock_requests, ) def finalizer(): patcher.stop() return patcher.start()
def setUp(self): NCMock = NonCallableMock self.subject = NCMock(spec=str) self.body = NCMock(spec=str) self.from_email = NCMock(spec=str) self.to = NonCallableMagicMock(spec=list) self.cc = NonCallableMagicMock(spec=list) self.bcc = NonCallableMagicMock(spec=list) self.reply_to = NCMock(spec=str) self.fail_silently = NCMock(spec=bool) self.auth_user = NCMock(spec=str) self.auth_password = NCMock(spec=str) self.connection = NCMock() self.attachments = NCMock(spec=list) self.headers = NonCallableMagicMock(spec=dict)
def setUp(self): NCMock = NonCallableMock self.subject = NCMock(spec=str) self.body = NCMock(spec=str) self.from_email = NCMock(spec=str) # self.to = NonCallableMagicMock(spec=list) # self.to.__iter__.return_value = ['to0', 'to1', 'to2'] # self.cc = NonCallableMagicMock(spec=list) # self.cc.__iter__.return_value = ['cc0', 'cc1', 'cc2'] # self.bcc = NonCallableMagicMock(spec=list) # self.bcc.__iter__.return_value = ['bcc0', 'bcc1', 'bcc2'] self.to = ['to0', 'to1', 'to2'] self.cc = ['cc0', 'cc1', 'cc2'] self.bcc = ['bcc0', 'bcc1', 'bcc2'] self.reply_to = NCMock(spec=str) self.fail_silently = NCMock(spec=bool) self.auth_user = NCMock(spec=str) self.auth_password = NCMock(spec=str) self.connection = NCMock() self.attachments = NCMock(spec=list) self.headers = NonCallableMagicMock(spec=dict)
def test_arg_lists(self): mocks = [ Mock(), MagicMock(), NonCallableMock(), NonCallableMagicMock() ] def assert_attrs(mock): names = 'call_args_list', 'method_calls', 'mock_calls' for name in names: attr = getattr(mock, name) self.assertIsInstance(attr, _CallList) self.assertIsInstance(attr, list) self.assertEqual(attr, []) for mock in mocks: assert_attrs(mock) if callable(mock): mock() mock(1, 2) mock(a=3) mock.reset_mock() assert_attrs(mock) mock.foo() mock.foo.bar(1, a=3) mock.foo(1).bar().baz(3) mock.reset_mock() assert_attrs(mock)
def configure(self): self.consumer = MagicMock() self.ctx.Message.return_value = self.message = NonCallableMagicMock() self.agent = ConsumerAgent(self.consumer, sentinel.broker, sentinel.bindings) self.agent.acknowledge = MagicMock() self.agent._process = MagicMock()
def setUp(self): super(DesignateBackendTest, self).setUp() opts = RoObject( username="******", password="******", project_name="project", project_domain_name="project_domain", user_domain_name="user_domain", ) self.target = RoObject( { "id": "4588652b-50e7-46b9-b688-a9bad40a873e", "type": "dyndns", "masters": [RoObject({"host": "192.0.2.1", "port": 53})], "options": opts, } ) # Backends blow up when trying to self.admin_context = ... due to # policy not being initialized self.admin_context = Mock() get_context_patcher = patch("designate.context.DesignateContext.get_admin_context") get_context = get_context_patcher.start() get_context.return_value = self.admin_context self.backend = impl_designate.DesignateBackend(self.target) # Mock client self.client = NonCallableMagicMock() zones = NonCallableMagicMock(spec_set=["create", "delete"]) self.client.configure_mock(zones=zones)
def setUp(self): super(DesignateBackendTestCase, self).setUp() self.zone = objects.Zone( id='e2bed4dc-9d01-11e4-89d3-123b93f75cba', name='example.com.', email='*****@*****.**', ) self.target = { 'id': '4588652b-50e7-46b9-b688-a9bad40a873e', 'type': 'designate', 'masters': [ {'host': '192.0.2.1', 'port': 53}, ], 'options': [ {'key': 'username', 'value': 'user'}, {'key': 'password', 'value': 'secret'}, {'key': 'project_name', 'value': 'project'}, {'key': 'project_zone_name', 'value': 'project_zone'}, {'key': 'user_zone_name', 'value': 'user_zone'}, ], } self.backend = impl_designate.DesignateBackend( objects.PoolTarget.from_dict(self.target) ) # Mock client self.client = NonCallableMagicMock() zones = NonCallableMagicMock(spec_set=[ 'create', 'delete']) self.client.configure_mock(zones=zones)
def test_successful_wait_for_connection(self): host = Mock(spec=Host, address='ip1') session = self.make_session() conn = NonCallableMagicMock(spec=Connection, in_flight=0, is_defunct=False, is_closed=False) session.cluster.connection_factory.return_value = conn pool = HostConnectionPool(host, HostDistance.LOCAL, session) session.cluster.connection_factory.assert_called_once_with( host.address) pool.borrow_connection(timeout=0.01) self.assertEqual(1, conn.in_flight) def get_second_conn(): c = pool.borrow_connection(1.0) self.assertIs(conn, c) pool.return_connection(c) t = Thread(target=get_second_conn) t.start() pool.return_connection(conn) t.join() self.assertEqual(0, conn.in_flight)
def setUp(self): super(DesignateBackendTest, self).setUp() opts = RoObject( username='******', password='******', project_name='project', project_zone_name='project_zone', user_zone_name='user_zone' ) self.target = RoObject({ 'id': '4588652b-50e7-46b9-b688-a9bad40a873e', 'type': 'dyndns', 'masters': [RoObject({'host': '192.0.2.1', 'port': 53})], 'options': opts }) # Backends blow up when trying to self.admin_context = ... due to # policy not being initialized self.admin_context = Mock() get_context_patcher = patch( 'designate.context.DesignateContext.get_admin_context') get_context = get_context_patcher.start() get_context.return_value = self.admin_context self.backend = impl_designate.DesignateBackend(self.target) # Mock client self.client = NonCallableMagicMock() zones = NonCallableMagicMock(spec_set=[ 'create', 'delete']) self.client.configure_mock(zones=zones)
def test_update_overrides(self): cfg_mgr_mock = MagicMock() self.manager._app.configuration_manager = cfg_mgr_mock overrides = NonCallableMagicMock() self.manager.update_overrides(Mock(), overrides) cfg_mgr_mock.apply_user_override.assert_called_once_with(overrides) cfg_mgr_mock.remove_user_override.assert_not_called()
def test_failed_wait_for_connection(self): host = Mock(spec=Host, address='ip1') session = self.make_session() conn = NonCallableMagicMock(spec=Connection, in_flight=0, is_defunct=False, is_closed=False) session.cluster.connection_factory.return_value = conn pool = HostConnectionPool(host, HostDistance.LOCAL, session) session.cluster.connection_factory.assert_called_once_with(host.address) pool.borrow_connection(timeout=0.01) self.assertEqual(1, conn.in_flight) conn.in_flight = MAX_STREAM_PER_CONNECTION # we're already at the max number of requests for this connection, # so we this should fail self.assertRaises(NoConnectionsAvailable, pool.borrow_connection, 0)
def test_return_closed_connection(self): host = Mock(spec=Host, address='ip1') session = self.make_session() conn = NonCallableMagicMock(spec=Connection, in_flight=0, is_defunct=False, is_closed=True) session.cluster.connection_factory.return_value = conn pool = HostConnectionPool(host, HostDistance.LOCAL, session) session.cluster.connection_factory.assert_called_once_with(host.address) pool.borrow_connection(timeout=0.01) conn.is_closed = True session.cluster.signal_connection_failure.return_value = False pool.return_connection(conn) # a new creation should be scheduled session.submit.assert_called_once() self.assertFalse(pool.is_shutdown)
def test_check_answer(self): test_cases = [ TCData(([0, 3, 1, 2], 0), True), TCData(([2, 1, 0], 2), True), TCData(([2, 0, 1], None), False), TCData(([3, 1, 2, 0], 2), False) ] for test_case in test_cases: subpart_question_mock = NonCallableMagicMock(spec_set=['options']) subpart_question_mock.options = NonCallableMagicMock( spec_set=['order']) subpart_question_mock.options.order = test_case.input[0] mcsaq_answer = MCSAQAnswer(test_case.input[1], None) mcsaq_answer.check_answer(subpart_question_mock) self.assertEqual(mcsaq_answer.correct, test_case.expected_output)
def test_return_closed_connection(self): host = Mock(spec=Host, address='ip1') session = self.make_session() conn = NonCallableMagicMock(spec=Connection, in_flight=0, is_defunct=False, is_closed=True) session.cluster.connection_factory.return_value = conn pool = HostConnectionPool(host, HostDistance.LOCAL, session) session.cluster.connection_factory.assert_called_once_with(host.address) pool.borrow_connection(timeout=0.01) conn.is_closed = True host.monitor.signal_connection_failure.return_value = False pool.return_connection(conn) # a new creation should be scheduled session.submit.assert_called_once() self.assertFalse(pool.is_shutdown)
def setUp(self): self.endpoint = ["1.2.3.4"] self.client_mock = NonCallableMagicMock() patcher = patch( 'controller.array_action.array_mediator_ds8k.RESTClient') self.connect_mock = patcher.start() self.addCleanup(patcher.stop) self.connect_mock.return_value = self.client_mock self.client_mock.get_system.return_value = Munch({ "id": "dsk array id", "name": "mtc032h", "state": "online", "release": "7.4", "bundle": "87.51.47.0", "MTM": "2421-961", "sn": "75DHZ81", "wwnn": "5005076306FFD2F0", "cap": "440659", "capalloc": "304361", "capavail": "136810", "capraw": "73282879488" }) self.volume_response = Munch({ "cap": "1073741824", "id": "0001", "name": "test_name", "pool": "fake_pool", "tp": "ese", "flashcopy": "" }) self.flashcopy_response = Munch({ "source_volume": { "id": "0000" }, "target_volume": { "id": "0001" }, "id": "0000:0001", "state": "valid" }) self.array = DS8KArrayMediator("user", "password", self.endpoint)
def test_check_answer(self): test_cases = [ TCData((' JawAHArLal Nehru ', 'Jawaharlal Nehru'), True), TCData(('jawaharlalnehru', 'Jawaharlal Nehru'), False), TCData(('\t\t FooBAR ', 'foobar'), True), TCData((None, 'foobar'), False), TCData(('banana', 'foobar'), False), TCData(('foobar', 'FooBar'), True), TCData(('Jawaharlal nehroo', 'Jawaharlal Nehru'), False), TCData(('jawaharlal\tnehru', 'Jawaharlal Nehru'), True), ] for test_case in test_cases: subpart_question_mock = NonCallableMagicMock(spec_set=['answer']) subpart_question_mock.answer = test_case.input[1] textual_answer = TextualAnswer(test_case.input[0], None) textual_answer.check_answer(subpart_question_mock) self.assertEqual(textual_answer.correct, test_case.expected_output)
def test_no_effect(self): DataCollector().configure() sql, _ = mock_sql() sql.query.model = NonCallableMagicMock(spec_set=['__module__']) sql.query.model.__module__ = 'silk.models' # No SQLQuery models should be created for silk requests for obvious reasons with patch('silk.sql.DataCollector', return_value=Mock()) as mock_DataCollector: execute_sql(sql) self.assertFalse(mock_DataCollector().register_query.call_count)
def test_attribute_deletion(self): for mock in (Mock(), MagicMock(), NonCallableMagicMock(), NonCallableMock()): self.assertTrue(hasattr(mock, 'm')) del mock.m self.assertFalse(hasattr(mock, 'm')) del mock.f self.assertFalse(hasattr(mock, 'f')) self.assertRaises(AttributeError, getattr, mock, 'f')
def configure(self): self.consumer = MagicMock() self.consumer.process.side_effect = self.exc self.message = NonCallableMagicMock() self.agent = ConsumerAgent(self.consumer, sentinel.broker, sentinel.bindings) self.agent.reject = MagicMock() self.agent.stop = MagicMock() self.agent._record_exception = MagicMock() self.agent.processing_failure = MagicMock() self.agent.reconnect = MagicMock()
def test_check_answer(self): test_cases = [ TCData((HWCentralConditionalAnswerFormat.NUMERIC, 1, '_value_ < 10', []), [False]), TCData((HWCentralConditionalAnswerFormat.NUMERIC, 3, '_value_ < 10', []), [False, False, False]), TCData((HWCentralConditionalAnswerFormat.NUMERIC, 3, '_value_ < 10', ['5.1', '3/10', '- 5 / 56']), [True, True, True]), TCData((HWCentralConditionalAnswerFormat.NUMERIC, 1, '_value_ < 10', ['11.1']), [False]), TCData((HWCentralConditionalAnswerFormat.NUMERIC, 3, '_value_ < 10', [None, '9', None]), [False, True, False]), TCData((HWCentralConditionalAnswerFormat.TEXTUAL, 1, '_value_.isupper()', []), [False]), TCData((HWCentralConditionalAnswerFormat.TEXTUAL, 3, '_value_.isupper()', []), [False, False, False]), TCData((HWCentralConditionalAnswerFormat.TEXTUAL, 3, '_value_.isupper()', [' FOO BAR\t ', 'BANANA', 'W A T\t\t E RMELON']), [True, True, True]), TCData((HWCentralConditionalAnswerFormat.TEXTUAL, 1, '_value_.isupper()', ['foobar']), [False]), TCData((HWCentralConditionalAnswerFormat.TEXTUAL, 3, '_value_.isupper()', [None, ' FU BAR', None]), [False, True, False]) ] for test_case in test_cases: subpart_question_mock = NonCallableMagicMock(spec_set=['answer']) subpart_question_mock.answer = NonCallableMagicMock( spec_set=['answer_format', 'num_answers', 'condition']) subpart_question_mock.answer.answer_format = test_case.input[0] subpart_question_mock.answer.num_answers = test_case.input[1] subpart_question_mock.answer.condition = test_case.input[2] conditional_answer = ConditionalAnswer(test_case.input[3], None) conditional_answer.check_answer(subpart_question_mock) self.assertEqual(conditional_answer.correct, test_case.expected_output)
def setUp(t): t.getLogger_patcher = patch( "{src}.getLogger".format(**PATH), autospec=True, ) t.getLogger = t.getLogger_patcher.start() t.addCleanup(t.getLogger_patcher.stop) t._Running_patcher = patch( "{src}._Running".format(**PATH), autospec=True, ) t._Running = t._Running_patcher.start() t.addCleanup(t._Running_patcher.stop) t.reactor = Mock(spec=reactor) t.worklist = NonCallableMagicMock(spec=ZenHubWorklist) t.workers = NonCallableMagicMock(spec=WorkerPool) t.name = "default" t.executor = WorkerPoolExecutor( t.name, t.worklist, t.workers, ) t.logger = t.getLogger(t.executor)
def setUp(self): super(DesignateBackendTestCase, self).setUp() self.stdlog = fixtures.StandardLogging() self.useFixture(self.stdlog) self.zone = objects.Zone( id='e2bed4dc-9d01-11e4-89d3-123b93f75cba', name='example.com.', email='*****@*****.**', ) self.target = { 'id': '4588652b-50e7-46b9-b688-a9bad40a873e', 'type': 'designate', 'masters': [ {'host': '192.0.2.1', 'port': 53}, ], 'options': [ {'key': 'auth_url', 'value': 'auth_url'}, {'key': 'username', 'value': 'user'}, {'key': 'password', 'value': 'secret'}, {'key': 'project_name', 'value': 'project'}, {'key': 'project_domain_name', 'value': 'project_domain'}, {'key': 'user_domain_name', 'value': 'user_domain'}, {'key': 'region_name', 'value': 'RegionOne'}, ], } self.backend = impl_designate.DesignateBackend( objects.PoolTarget.from_dict(self.target) ) # Mock client self.client = NonCallableMagicMock() zones = NonCallableMagicMock(spec_set=['create', 'delete']) self.client.configure_mock(zones=zones) self.backend._client = self.client
def setUp(self): self.getLogger_patcher = patch( "{src}.getLogger".format(**PATH), autospec=True, ) self.getLogger = self.getLogger_patcher.start() self.addCleanup(self.getLogger_patcher.stop) self._Running_patcher = patch( "{src}._Running".format(**PATH), autospec=True, ) self._Running = self._Running_patcher.start() self.addCleanup(self._Running_patcher.stop) self.reactor = Mock(spec=reactor) self.worklist = NonCallableMagicMock(spec=ZenHubWorklist) self.workers = NonCallableMagicMock(spec=WorkerPool) self.name = "default" self.executor = WorkerPoolExecutor( self.name, self.worklist, self.workers, ) self.logger = self.getLogger(self.executor)
def test_get_default_profile(self): """ get_default_profile should return a default profile attached to an architecture, or raise value error if there is none. """ machine = NonCallableMagicMock(spec_set=Machine) architecture = NonCallableMagicMock(spec_set=Architecture) architecture.default_profile = "test_profile" machine.architecture = architecture self.assertEqual(cobbler.get_default_profile(machine), "test_profile") architecture.default_profile = None self.assertRaises(ValueError, cobbler.get_default_profile, machine)
def test_spawn_when_at_max(self): host = Mock(spec=Host, address='ip1') session = self.make_session() conn = NonCallableMagicMock(spec=Connection, in_flight=0, is_defunct=False, is_closed=False) session.cluster.connection_factory.return_value = conn # core conns = 1, max conns = 2 session.cluster.get_max_connections_per_host.return_value = 2 pool = HostConnectionPool(host, HostDistance.LOCAL, session) session.cluster.connection_factory.assert_called_once_with(host.address) pool.borrow_connection(timeout=0.01) self.assertEqual(1, conn.in_flight) # make this conn full conn.in_flight = MAX_STREAM_PER_CONNECTION # we don't care about making this borrow_connection call succeed for the # purposes of this test, as long as it results in a new connection # creation being scheduled self.assertRaises(NoConnectionsAvailable, pool.borrow_connection, 0) session.submit.assert_called_once_with(pool._create_new_connection)
def test_all_connections_trashed(self): host = Mock(spec=Host, address='ip1') session = self.make_session() conn = NonCallableMagicMock(spec=Connection, in_flight=0, is_defunct=False, is_closed=False, max_request_id=100, lock=Lock()) session.cluster.connection_factory.return_value = conn session.cluster.get_core_connections_per_host.return_value = 1 # manipulate the core connection setting so that we can # trash the only connection pool = HostConnectionPool(host, HostDistance.LOCAL, session) session.cluster.get_core_connections_per_host.return_value = 0 pool._maybe_trash_connection(conn) session.cluster.get_core_connections_per_host.return_value = 1 submit_called = Event() def fire_event(*args, **kwargs): submit_called.set() session.submit.side_effect = fire_event def get_conn(): conn.reset_mock() c, request_id = pool.borrow_connection(1.0) self.assertIs(conn, c) self.assertEqual(1, conn.in_flight) conn.set_keyspace_blocking.assert_called_once_with( 'foobarkeyspace') pool.return_connection(c) t = Thread(target=get_conn) t.start() submit_called.wait() self.assertEqual(1, pool._scheduled_for_creation) session.submit.assert_called_once_with(pool._create_new_connection) # now run the create_new_connection call pool._create_new_connection() t.join() self.assertEqual(0, conn.in_flight)
def test_borrow_and_return(self): host = Mock(spec=Host, address='ip1') session = self.make_session() conn = NonCallableMagicMock(spec=Connection, in_flight=0, is_defunct=False, is_closed=False) session.cluster.connection_factory.return_value = conn pool = HostConnectionPool(host, HostDistance.LOCAL, session) session.cluster.connection_factory.assert_called_once_with(host.address) c = pool.borrow_connection(timeout=0.01) self.assertIs(c, conn) self.assertEqual(1, conn.in_flight) conn.set_keyspace.assert_called_once_with('foobarkeyspace') pool.return_connection(conn) self.assertEqual(0, conn.in_flight) self.assertNotIn(conn, pool._trash)
def setUp(self): self.endpoint = ["1.2.3.4"] self.client_mock = NonCallableMagicMock() patcher = patch( 'controller.array_action.array_mediator_ds8k.RESTClient') self.connect_mock = patcher.start() self.addCleanup(patcher.stop) self.connect_mock.return_value = self.client_mock self.client_mock.get_system.return_value = Munch({ "id": "dsk array id", "name": "mtc032h", "state": "online", "release": "7.4", "bundle": "87.51.47.0", "MTM": "2421-961", "sn": "75DHZ81", "wwnn": "5005076306FFD2F0", "cap": "440659", "capalloc": "304361", "capavail": "136810", "capraw": "73282879488" }) socket_patcher = patch( 'controller.array_action.storage_agent._socket_connect_test') self.socket_mock = socket_patcher.start() self.addCleanup(socket_patcher.stop) self.socket_mock.side_effect = _fake_socket_connect_test self.agent = StorageAgent([ "ds8k_host", ], "", "")
def test_borrow_and_return(self): host = Mock(spec=Host, address='ip1') session = self.make_session() conn = NonCallableMagicMock(spec=Connection, in_flight=0, is_defunct=False, is_closed=False, max_request_id=100) session.cluster.connection_factory.return_value = conn pool = self.PoolImpl(host, HostDistance.LOCAL, session) session.cluster.connection_factory.assert_called_once_with(host.endpoint) c, request_id = pool.borrow_connection(timeout=0.01) self.assertIs(c, conn) self.assertEqual(1, conn.in_flight) conn.set_keyspace_blocking.assert_called_once_with('foobarkeyspace') pool.return_connection(conn) self.assertEqual(0, conn.in_flight) if not self.uses_single_connection: self.assertNotIn(conn, pool._trash)
class DesignateBackendTestCase(tests.TestCase): def setUp(self): super(DesignateBackendTestCase, self).setUp() self.zone = objects.Zone( id='e2bed4dc-9d01-11e4-89d3-123b93f75cba', name='example.com.', email='*****@*****.**', ) self.target = { 'id': '4588652b-50e7-46b9-b688-a9bad40a873e', 'type': 'designate', 'masters': [ {'host': '192.0.2.1', 'port': 53}, ], 'options': [ {'key': 'username', 'value': 'user'}, {'key': 'password', 'value': 'secret'}, {'key': 'project_name', 'value': 'project'}, {'key': 'project_zone_name', 'value': 'project_zone'}, {'key': 'user_zone_name', 'value': 'user_zone'}, ], } self.backend = impl_designate.DesignateBackend( objects.PoolTarget.from_dict(self.target) ) # Mock client self.client = NonCallableMagicMock() zones = NonCallableMagicMock(spec_set=[ 'create', 'delete']) self.client.configure_mock(zones=zones) def test_create_zone(self): masters = ["%(host)s:%(port)s" % self.target['masters'][0]] with patch.object(self.backend, '_get_client', return_value=self.client): self.backend.create_zone(self.admin_context, self.zone) self.client.zones.create.assert_called_once_with( self.zone.name, 'SECONDARY', masters=masters) def test_delete_zone(self): with patch.object(self.backend, '_get_client', return_value=self.client): self.backend.delete_zone(self.admin_context, self.zone) self.client.zones.delete.assert_called_once_with(self.zone.name) def test_delete_zone_notfound(self): self.client.delete.side_effect = exceptions.NotFound with patch.object(self.backend, '_get_client', return_value=self.client): self.backend.delete_zone(self.admin_context, self.zone) self.client.zones.delete.assert_called_once_with(self.zone.name) def test_delete_zone_exc(self): self.client.zones.delete.side_effect = Exception with testtools.ExpectedException(Exception): with patch.object(self.backend, '_get_client', return_value=self.client): self.backend.delete_zone(self.admin_context, self.zone) self.client.zones.delete.assert_called_once_with(self.zone.name)
class DesignateBackendTest(oslotest.base.BaseTestCase): def setUp(self): super(DesignateBackendTest, self).setUp() opts = RoObject( username="******", password="******", project_name="project", project_domain_name="project_domain", user_domain_name="user_domain", ) self.target = RoObject( { "id": "4588652b-50e7-46b9-b688-a9bad40a873e", "type": "dyndns", "masters": [RoObject({"host": "192.0.2.1", "port": 53})], "options": opts, } ) # Backends blow up when trying to self.admin_context = ... due to # policy not being initialized self.admin_context = Mock() get_context_patcher = patch("designate.context.DesignateContext.get_admin_context") get_context = get_context_patcher.start() get_context.return_value = self.admin_context self.backend = impl_designate.DesignateBackend(self.target) # Mock client self.client = NonCallableMagicMock() zones = NonCallableMagicMock(spec_set=["create", "delete"]) self.client.configure_mock(zones=zones) def test_create_domain(self): zone = create_zone() masters = ["%(host)s:%(port)s" % self.target.masters[0]] with patch.object(self.backend, "_get_client", return_value=self.client): self.backend.create_domain(self.admin_context, zone) self.client.zones.create.assert_called_once_with(zone.name, "SECONDARY", masters=masters) def test_delete_domain(self): zone = create_zone() with patch.object(self.backend, "_get_client", return_value=self.client): self.backend.delete_domain(self.admin_context, zone) self.client.zones.delete.assert_called_once_with(zone.name) def test_delete_domain_notfound(self): zone = create_zone() self.client.delete.side_effect = exceptions.NotFound with patch.object(self.backend, "_get_client", return_value=self.client): self.backend.delete_domain(self.admin_context, zone) self.client.zones.delete.assert_called_once_with(zone.name) def test_delete_domain_exc(self): class Exc(Exception): pass zone = create_zone() self.client.zones.delete.side_effect = Exc() with testtools.ExpectedException(Exc): with patch.object(self.backend, "_get_client", return_value=self.client): self.backend.delete_domain(self.admin_context, zone) self.client.zones.delete.assert_called_once_with(zone.name)
class DesignateBackendTest(oslotest.base.BaseTestCase): def setUp(self): super(DesignateBackendTest, self).setUp() opts = RoObject( username='******', password='******', project_name='project', project_zone_name='project_zone', user_zone_name='user_zone' ) self.target = RoObject({ 'id': '4588652b-50e7-46b9-b688-a9bad40a873e', 'type': 'dyndns', 'masters': [RoObject({'host': '192.0.2.1', 'port': 53})], 'options': opts }) # Backends blow up when trying to self.admin_context = ... due to # policy not being initialized self.admin_context = Mock() get_context_patcher = patch( 'designate.context.DesignateContext.get_admin_context') get_context = get_context_patcher.start() get_context.return_value = self.admin_context self.backend = impl_designate.DesignateBackend(self.target) # Mock client self.client = NonCallableMagicMock() zones = NonCallableMagicMock(spec_set=[ 'create', 'delete']) self.client.configure_mock(zones=zones) def test_create_zone(self): zone = create_zone() masters = ["%(host)s:%(port)s" % self.target.masters[0]] with patch.object( self.backend, '_get_client', return_value=self.client): self.backend.create_zone(self.admin_context, zone) self.client.zones.create.assert_called_once_with( zone.name, 'SECONDARY', masters=masters) def test_delete_zone(self): zone = create_zone() with patch.object( self.backend, '_get_client', return_value=self.client): self.backend.delete_zone(self.admin_context, zone) self.client.zones.delete.assert_called_once_with(zone.name) def test_delete_zone_notfound(self): zone = create_zone() self.client.delete.side_effect = exceptions.NotFound with patch.object( self.backend, '_get_client', return_value=self.client): self.backend.delete_zone(self.admin_context, zone) self.client.zones.delete.assert_called_once_with(zone.name) def test_delete_zone_exc(self): class Exc(Exception): pass zone = create_zone() self.client.zones.delete.side_effect = Exc() with testtools.ExpectedException(Exc): with patch.object( self.backend, '_get_client', return_value=self.client): self.backend.delete_zone(self.admin_context, zone) self.client.zones.delete.assert_called_once_with(zone.name)
def test_volume_page_search(self, mocksolr_interface, mockpaginator, mockrepo): mockobj = NonCallableMock() mockobj.pid = 'vol:1' mockobj.title = 'Lecoq, the detective' mockobj.date = ['1801'] mockrepo.return_value.get_object.return_value = mockobj mocksolr = mocksolr_interface.return_value # simulate sunburnt's fluid interface mocksolr.query.return_value = mocksolr.query for method in ['query', 'facet_by', 'sort_by', 'field_limit', 'highlight', 'exclude', 'filter', 'join', 'paginate', 'results_as']: getattr(mocksolr.query, method).return_value = mocksolr.query # set up mock results for collection query and facet counts solr_result = NonCallableMagicMock(spec_set=['__iter__', 'facet_counts']) # *only* mock iter, to avoid weirdness with django templates & callables solr_results = [ SolrPage(**{'pid': 'page:1', 'page_order': '1', 'score': 0.5, 'solr_highlights': {'page_text': ['snippet with search term']}, 'identifier': ['http://testpid.co/ark:/1234/11/']}), SolrPage(**{'pid': 'page:233', 'page_order': '123', 'score': 0.02, 'solr_highlights': {'page_text': ['sample text result from content']}, 'identifier': ['http://testpid.co/ark:/1234/22/']}), ] solr_result.__iter__.return_value = solr_results mocksolr.query.__iter__.return_value = iter(solr_result) mocksolr.count.return_value = 2 mockpage = NonCallableMock() mockpaginator.return_value.page.return_value = mockpage results = NonCallableMagicMock(spec=['__iter__', 'facet_counts', 'highlighting']) results.__iter__.return_value = iter(solr_result) mockpage.object_list = results mockpage.has_other_pages = False mockpage.paginator.count = 2 mockpage.paginator.page_range = [1] # patch in highlighting - apparent change in sunburnt behavior results.highlighting = { 'page:1': {'page_text': ['snippet with search term']}, 'page:233': {'page_text': ['sample text result from content']} } vol_url = reverse('books:volume', kwargs={'pid': mockobj.pid}) response = self.client.get(vol_url, {'keyword': 'determine'}) self.assertEqual(response.templates[0].name, views.VolumeDetail.search_template_name, 'volume search template should be used for valid search submission') for page in iter(solr_result): self.assertContains(response, reverse('books:page-image', kwargs={'vol_pid': mockobj.pid, 'pid': page.pid, 'mode': 'mini-thumbnail'}), msg_prefix='search results should include mini page thumbnail url') self.assertContains(response, "Page %(page_order)s" % page, msg_prefix='search results should include page number') self.assertContains(response, page['score'], msg_prefix='search results should display page relevance score') self.assertContains(response, reverse('books:page', kwargs={'vol_pid': mockobj.pid, 'pid': page['pid']}), msg_prefix='search results should link to full page view') self.assertContains(response, '... %s ...' % page['solr_highlights']['page_text'][0], msg_prefix='solr snippets should display when available') # ajax request with patch('readux.books.views.VolumeDetail.get_context_data') as mock_ctx: results = NonCallableMagicMock(spec=['__iter__', 'facet_counts', 'highlighting']) results.__iter__.return_value = iter(solr_result) results.highlighting = { solr_results[0].pid: { 'page_text': 'sample highlighting snippet' }, solr_results[1].pid: { 'page_text': 'another highlighting snippet' } } mockpage = NonCallableMagicMock(spec=['__iter__']) mockpage.object_list = results mock_ctx.return_value = { 'pages': mockpage, } response = self.client.get(vol_url, {'keyword': 'determine'}, HTTP_X_REQUESTED_WITH='XMLHttpRequest') self.assertEqual('application/json', response['content-type']) data = json.loads(response.content) for idx in range(len(data)): self.assertEqual(solr_results[idx].pid, data[idx]['pid']) self.assertEqual('p. %s' % solr_results[idx]['page_order'], data[idx]['label']) self.assertEqual(reverse('books:page-image', kwargs={'vol_pid': mockobj.pid, 'pid': solr_results[idx].pid, 'mode': 'mini-thumbnail'}), data[idx]['thumbnail']) self.assertEqual(results.highlighting[solr_results[idx].pid]['page_text'], data[idx]['highlights'])