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)
