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 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 test_get_listed_users(self, conn): 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(conn.return_value, '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) conn.return_value.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 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 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_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 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): 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_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_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 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_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_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 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 mock_http_with_digest_file(request, mock_digests_and_files): digest_file_lines = (' '.join(pair) for pair in mock_digests_and_files) mock_response = NonCallableMagicMock() mock_response.iter_lines = MagicMock(return_value=digest_file_lines) mock_requests = NonCallableMagicMock() mock_requests.get = MagicMock(return_value=mock_response) mock_requests._mock_response = mock_response patcher = patch( target='fabric_ovirt.lib.remote_files.requests', new=mock_requests, ) def finalizer(): patcher.stop() return patcher.start()
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_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_get_filename(self): """ get_filename should return the right filename attribute. Machine > Group > Architecture > None """ machine = NonCallableMagicMock(spec_set=Machine) machine.dhcp_filename = "machine" group = NonCallableMagicMock(spec_set=MachineGroup) group.dhcp_filename = "group" machine.group = group architecture = NonCallableMagicMock(spec_set=Architecture) architecture.dhcp_filename = "architecture" machine.architecture = architecture self.assertEqual(cobbler.get_filename(machine), "machine") machine.dhcp_filename = None self.assertEqual(cobbler.get_filename(machine), "group") group.dhcp_filename = None self.assertEqual(cobbler.get_filename(machine), "architecture") architecture.dhcp_filename = None self.assertIsNone(cobbler.get_filename(machine))
def test_create_cobbler_options(self): machine = mock.NonCallableMock(spec_set=Machine) machine.ipv4 = "17.17.17.17" machine.fqdn = "test.foo.bar" machine.ipv6 = None machine.dhcp_filename = None group = NonCallableMagicMock(spec=MachineGroup) group.dhcp_filename = None architecture = NonCallableMagicMock(spec=Architecture) architecture.dhcp_filename = None machine.group = group machine.architecture = architecture options = cobbler.create_cobbler_options(machine) self.assertTrue(" --name=test.foo.bar" in options) self.assertTrue(" --ip-address=17.17.17.17" in options) self.assertFalse("ipv6" in options) self.assertFalse("filename" in options) self.assertTrue(" --interface=default" in options) self.assertTrue(" --management=True" in options) self.assertTrue(" --interface-master=True" in options) machine.ipv6 = "2001:db8::8a2e:370:7334" options = cobbler.create_cobbler_options(machine) self.assertFalse("filename" in options) self.assertTrue(" --ipv6-address=2001:db8::8a2e:370:7334" in options) machine.ipv6 = None machine.dhcp_filename = "file.name" options = cobbler.create_cobbler_options(machine) self.assertFalse("ipv6" in options) self.assertTrue(" --filename=file.name" in options) machine.ipv6 = "2001:db8::8a2e:370:7334" options = cobbler.create_cobbler_options(machine) self.assertTrue(" --filename=file.name" in options) self.assertTrue(" --ipv6-address=2001:db8::8a2e:370:7334" in options)
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(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 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 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_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_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)