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_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
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'])
