def test_one_attended(self):
students = [{'Curso': '', 'Nombre': '', 'Apellido': ''}]
attended_cert = create_autospec(Certificate)
certified_cert = create_autospec(Certificate)
all_students_certificates(students, attended_cert, certified_cert)
self.assertTrue(attended_cert.generate.called)
self.assertFalse(certified_cert.generate.called)
def test_read():
self = create_autospec(TopLevelTickStore)
tsl = TickStoreLibrary(create_autospec(TickStore), create_autospec(DateRange))
self._get_libraries.return_value = [tsl, tsl]
dr = create_autospec(DateRange)
with patch("pandas.concat") as concat:
res = TopLevelTickStore.read(
self, sentinel.symbol, dr, columns=sentinel.include_columns, include_images=sentinel.include_images
)
assert concat.call_args_list == [call([tsl.library.read.return_value, tsl.library.read.return_value])]
assert res == concat.return_value
assert tsl.library.read.call_args_list == [
call(
sentinel.symbol,
tsl.date_range.intersection.return_value,
sentinel.include_columns,
include_images=sentinel.include_images,
),
call(
sentinel.symbol,
tsl.date_range.intersection.return_value,
sentinel.include_columns,
include_images=sentinel.include_images,
),
]
def test_create_autospec(self):
mock = create_autospec(X)
instance = mock()
self.assertRaises(TypeError, instance)
mock = create_autospec(X())
self.assertRaises(TypeError, mock)
def test_mongo_date_range_query():
self = create_autospec(TickStore)
self._collection = create_autospec(Collection)
self._symbol_query.return_value = {"sy": {"$in" : ["s1" , "s2"]}}
self._collection.aggregate.return_value = iter([{"_id": "s1", "start": dt(2014, 1, 1, 0, 0, tzinfo=mktz())},
{"_id": "s2", "start": dt(2014, 1, 1, 12, 0, tzinfo=mktz())}])
self._collection.find_one.side_effect = [
{'e': dt(2014, 1, 1, 15, 0, tzinfo=mktz())},
{'e': dt(2014, 1, 2, 12, 0, tzinfo=mktz())}]
query = TickStore._mongo_date_range_query(self, 'sym', DateRange(dt(2014, 1, 2, 0, 0, tzinfo=mktz()),
dt(2014, 1, 3, 0, 0, tzinfo=mktz())))
assert self._collection.aggregate.call_args_list == [call([
{"$match": {"s": {"$lte": dt(2014, 1, 2, 0, 0, tzinfo=mktz())}, "sy": {"$in" : ["s1" , "s2"]}}},
{"$project": {"_id": 0, "s": 1, "sy": 1}},
{"$group": {"_id": "$sy", "start": {"$max": "$s"}}},
{"$sort": {"start": 1}}])]
assert self._collection.find_one.call_args_list == [
call({'sy': 's1', 's': dt(2014, 1, 1, 0, 0, tzinfo=mktz())}, {'e': 1}),
call({'sy': 's2', 's': dt(2014, 1, 1, 12, 0, tzinfo=mktz())}, {'e': 1})]
assert query == {'s': {'$gte': dt(2014, 1, 1, 12, 0, tzinfo=mktz()), '$lte': dt(2014, 1, 3, 0, 0, tzinfo=mktz())}}
def setUp(self):
self.vlan_id_gen = 'gen_id'
self.name_gen = 'gen_name'
self.spec = Mock()
self.vm = Mock()
self.pv_service = Mock()
self.pv_service.find_by_uuid = Mock(self.vm)
self.si = Mock()
self.vm_uuid = 'uuid'
self.vlan_id = 100
self.spec_type = Mock()
vnic_device_mapper = create_autospec(spec=VNicDeviceMapper)
vnic_device_mapper.vnic = create_autospec(spec=vim.vm.device.VirtualEthernetCard)
vnic_device_mapper.vnic.macAddress = 'AA-BB'
vnic_device_mapper.vnic.deviceInfo = Mock()
vnic_device_mapper.vnic.deviceInfo.label = 'AA-BB'
vnic_device_mapper.network = Mock()
vnic_device_mapper.network.name = 'the network'
vnic_device_mapper.network.key = 'keyyyyyey'
vnic_device_mapper.requested_vnic = 'requested'
self.dv_connector = Mock()
self.dv_connector.connect_by_mapping = Mock(return_value=[vnic_device_mapper])
self.dv_port_name_gen = Mock()
self.vlan_spec_factory = Mock()
self.vlan_id_range_parser = Mock()
self.vlan_id_range_parser.parse_vlan_id = Mock(return_value=self.vlan_id_gen)
self.dv_port_name_gen.generate_port_group_name = Mock(return_value=self.name_gen)
self.vlan_spec_factory.get_vlan_spec = Mock(return_value=self.spec)
def test_handle_exception_toomanyredirects(self, mock_print_function):
mock_request = mock.create_autospec(Request).return_value
mock_request.url = "htt;//mockurl.mock"
mock_exception = mock.create_autospec(exceptions.TooManyRedirects).return_value
mock_exception.__str__.return_value = "Number of maximum redirections exceeded"
self.request_sender.handle_request_exception(mock_request, mock_exception)
self.assertEquals(mock_print_function.call_count, 2)
def test_handle_exception_timeout(self, mock_print_function):
mock_request = mock.create_autospec(Request).return_value
mock_request.url = "http://mockurl.mock"
mock_exception = mock.create_autospec(exceptions.Timeout).return_value
mock_exception.__str__.return_value = "Timeout reached"
self.request_sender.handle_request_exception(mock_request, mock_exception)
self.assertEquals(mock_print_function.call_count, 2)
def test_handle_exception_httperror(self, mock_print_function):
mock_request = mock.create_autospec(Request).return_value
mock_request.url = "http://mockurl.mock"
mock_exception = mock.create_autospec(exceptions.HTTPError).return_value
mock_exception.__str__.return_value = "Invalid HTTP respons"
self.request_sender.handle_request_exception(mock_request, mock_exception)
self.assertEquals(mock_print_function.call_count, 2)
def test_handle_exception_urlrequired(self, mock_print_function):
mock_request = mock.create_autospec(Request).return_value
mock_request.url = "htt;//mockurl.mock"
mock_exception = mock.create_autospec(exceptions.URLRequired).return_value
mock_exception.__str__.return_value = "Invalid url"
self.request_sender.handle_request_exception(mock_request, mock_exception)
self.assertEquals(mock_print_function.call_count, 2)
def test_get_binary(self):
mock_request = mock.create_autospec(Request).return_value
mock_response = mock.create_autospec(Response).return_value
mock_response.content = "<html><a href='url1'>text1</a><a href='url2'>text2</a></html>"
self.request_sender.session.send.return_value = mock_response
result = self.request_sender.get_binary(mock_request)
self.assertEquals(result, mock_response.content)
def test_handle_exception_connection_error(self, mock_print_function):
mock_request = mock.create_autospec(Request).return_value
mock_request.url = "htt;//mockurl.mock"
mock_exception = mock.create_autospec(exceptions.ConnectionError).return_value
mock_exception.__str__.return_value = "DNS failure"
self.request_sender.handle_request_exception(mock_request, mock_exception)
self.assertEquals(mock_print_function.call_count, 2)
def setUp(self):
mock_config = mock_factory.create_mock_config()
mock_item_queue = mock.create_autospec(queue).return_value
mock_item_writer = mock.create_autospec(ItemWriter).return_value
self.item_processor = ItemProcessor(mock_config, mock_item_queue)
self.item_processor.item_writer = mock_item_writer
self.item_processor.no_items_received = True
def test_handle_exception_baseexception(self, mock_print_function):
mock_request = mock.create_autospec(Request).return_value
mock_request.url = "http://mockurl.mock"
mock_exception = mock.create_autospec(BaseException).return_value
mock_exception.__str__.return_value = "BaseException message"
self.request_sender.handle_request_exception(mock_request, mock_exception)
self.assertEquals(mock_print_function.call_count, 2)
def test_get_verbose_status_of_marathon_app_column_alignment():
fake_app = mock.create_autospec(marathon.models.app.MarathonApp)
fake_app.version = '2015-01-15T05:30:49.862Z'
fake_app.id = '/fake--service'
fake_task1 = mock.create_autospec(marathon.models.app.MarathonTask)
fake_task1.id = 'fake_task1_id'
fake_task1.host = 'fake_deployed_host'
fake_task1.ports = [6666]
fake_task1.staged_at = datetime.datetime.fromtimestamp(0)
fake_task1.health_check_results = []
fake_task2 = mock.create_autospec(marathon.models.app.MarathonTask)
fake_task2.id = 'fake_task2_id'
fake_task2.host = 'fake_deployed_host_with_a_really_long_name'
fake_task2.ports = [6666]
fake_task2.staged_at = datetime.datetime.fromtimestamp(0)
fake_task2.health_check_results = []
fake_app.tasks = [fake_task1, fake_task2]
tasks, out = marathon_serviceinit.get_verbose_status_of_marathon_app(fake_app)
(_, _, _, headers_line, task1_line, task2_line) = out.split('\n')
assert headers_line.index('Host deployed to') == task1_line.index('fake_deployed_host')
assert headers_line.index('Host deployed to') == task2_line.index('fake_deployed_host_with_a_really_long_name')
assert headers_line.index('Deployed at what localtime') == task1_line.index('1970-01-01T00:00')
assert headers_line.index('Deployed at what localtime') == task2_line.index('1970-01-01T00:00')
def test_evaluate_initializer_with_fallback_calls_fallback():
init = mock.create_autospec(Initializer())
fallback = mock.create_autospec(Initializer())
fallback.side_effect = lambda x: np.array(1)
init.side_effect = InitializationError
evaluate_initializer(init, (7, 5), fallback)
fallback.assert_called_once_with((7, 5))
def test_authenticate(self):
self.auth_backend._authentication_preprocessing = mock.create_autospec(
self.auth_backend._authentication_preprocessing, return_value=None
)
self.auth_backend._start_authentication = mock.create_autospec(
self.auth_backend._start_authentication, return_value=None
)
self.auth_backend._process_challenge = mock.create_autospec(
self.auth_backend._process_challenge, return_value=None
)
self.auth_backend._extract_data = mock.create_autospec(self.auth_backend._extract_data, return_value=None)
self.auth_backend._verify_session = mock.create_autospec(self.auth_backend._verify_session, return_value=None)
d = self.auth_backend.authenticate(self.TEST_USER, self.TEST_PASS)
def check(*args):
self.auth_backend._authentication_preprocessing.assert_called_once_with(
username=self.TEST_USER, password=self.TEST_PASS
)
self.auth_backend._start_authentication.assert_called_once_with(None, username=self.TEST_USER)
self.auth_backend._process_challenge.assert_called_once_with(None, username=self.TEST_USER)
self.auth_backend._extract_data.assert_called_once_with(None)
self.auth_backend._verify_session.assert_called_once_with(None)
d.addCallback(check)
return d
def setUp(self):
super(ImageBackendFixture, self).setUp()
# Mock template functions passed to cache
self.mock_fetch_image = mock.create_autospec(libvirt_utils.fetch_image)
self.useFixture(fixtures.MonkeyPatch(
'nova.virt.libvirt.utils.fetch_image', self.mock_fetch_image))
self.mock_fetch_raw_image = \
mock.create_autospec(libvirt_utils.fetch_raw_image)
self.useFixture(fixtures.MonkeyPatch(
'nova.virt.libvirt.utils.fetch_raw_image',
self.mock_fetch_raw_image))
self.mock_create_ephemeral = \
mock.create_autospec(driver.LibvirtDriver._create_ephemeral)
self.useFixture(fixtures.MonkeyPatch(
'nova.virt.libvirt.driver.LibvirtDriver._create_ephemeral',
self.mock_create_ephemeral))
self.mock_create_swap = \
mock.create_autospec(driver.LibvirtDriver._create_swap)
self.useFixture(fixtures.MonkeyPatch(
'nova.virt.libvirt.driver.LibvirtDriver._create_swap',
self.mock_create_swap))
# Backend.backend creates all Image objects
self.useFixture(fixtures.MonkeyPatch(
'nova.virt.libvirt.imagebackend.Backend.backend',
self._mock_backend))
def setup_job(self):
self.last_success = mock.Mock(run_time=datetime.datetime(2012, 3, 14))
mock_scheduler = mock.create_autospec(scheduler.ConstantScheduler)
run_collection = mock.create_autospec(JobRunCollection,
last_success=self.last_success)
self.job = job.Job("jobname", mock_scheduler, run_collection=run_collection)
self.context = command_context.JobContext(self.job)
def testBasicCall(self):
api = rest_api._RestApi('scope')
self.assertEqual(api.scopes, ['scope'])
fut_get_token = ndb.Future()
fut_get_token.set_result('blah')
api.get_token_async = mock.create_autospec(api.get_token_async,
return_value=fut_get_token)
fut_urlfetch = ndb.Future()
fut_urlfetch.set_result(
test_utils.MockUrlFetchResult(200, {'foo': 'bar'}, 'yoohoo'))
api.urlfetch_async = mock.create_autospec(api.urlfetch_async,
return_value=fut_urlfetch)
res = api.do_request('http://example.com')
self.assertEqual(res, (200, {'foo': 'bar'}, 'yoohoo'))
api.urlfetch_async.assert_called_once_with(
'http://example.com',
headers={'authorization': 'OAuth blah'},
follow_redirects=False,
payload=None,
method='GET',
deadline=None,
callback=None)
def test_get_object_by_path_checks_childEntity(self):
"""
Checks whether the function can grab from child entities
"""
"#arrange"
pv_service = pyVmomiService(None, None)
def search_child(*args, **keys):
if args[0].name == pv_service.ChildEntity:
return True
return False
class FolderMock:
childEntity = None
folder = Mock(spec=FolderMock())
folder.name = pv_service.ChildEntity
get_folder = MagicMock(return_value=folder)
pv_service.get_folder = get_folder
si = create_autospec(spec=vim.ServiceInstance)
si.RetrieveContent = Mock()
si.content = create_autospec(spec=vim.ServiceInstanceContent())
si.content.searchIndex = Mock()
si.content.searchIndex.FindChild = MagicMock(side_effect=search_child)
"#act"
result = pv_service.find_obj_by_path(si, "", "", "")
"#assert"
self.assertTrue(result)
def test_create_page_processor(self, mock_item_processor_class):
mock_config = mock.create_autospec(Config).return_value
mock_item_queue = mock.create_autospec(queue).return_value
mock_item_processor = mock.create_autospec(ItemProcessor).return_value
mock_item_processor_class.return_value = mock_item_processor
result = self.thread_factory.create_item_processor(mock_config, mock_item_queue)
self.assertEquals(result, mock_item_processor)
def create_blank_response(cls, code, msg): # TODO(wfarner): Don't use a mock here. response = create_autospec(spec=Response, instance=True) response.responseCode = code response.result = create_autospec(spec=Result, instance=True) response.details = [ResponseDetail(message=msg)] return response
def setup_resource(self):
self.mcp = mock.create_autospec(mcp.MasterControlProgram)
self.resource = www.ConfigResource(self.mcp)
self.controller = self.resource.controller = mock.create_autospec(
controller.ConfigController)
with mock.patch('tron.api.www.respond', autospec=True) as self.respond:
yield
def test_create_empty(self):
# Create a minimal fake GAPIC with a dummy response.
from google.cloud.firestore_v1beta1.document import DocumentReference
from google.cloud.firestore_v1beta1.document import DocumentSnapshot
firestore_api = mock.Mock(spec=['commit'])
document_reference = mock.create_autospec(DocumentReference)
snapshot = mock.create_autospec(DocumentSnapshot)
snapshot.exists = True
document_reference.get.return_value = snapshot
commit_response = mock.Mock(
write_results=[document_reference],
get=[snapshot],
spec=['write_results'])
firestore_api.commit.return_value = commit_response
# Attach the fake GAPIC to a real client.
client = _make_client('dignity')
client._firestore_api_internal = firestore_api
client.get_all = mock.MagicMock()
client.get_all.exists.return_value = True
# Actually make a document and call create().
document = self._make_one('foo', 'twelve', client=client)
document_data = {}
write_result = document.create(document_data)
self.assertTrue(write_result.get().exists)
def setup_resource(self):
instances = mock.create_autospec(serviceinstance.ServiceInstanceCollection)
self.service = mock.create_autospec(service.Service,
instances=instances, enabled=True, config=mock.Mock())
self.resource = www.ServiceResource(self.service)
self.resource.controller = mock.create_autospec(
controller.ServiceController)
def setup_jobrun(self):
self.action_graph = mock.create_autospec(actiongraph.ActionGraph)
self.run_time = datetime.datetime(2012, 3, 14, 15, 9, 26)
self.path = ['base', 'path']
self.output_path = mock.create_autospec(filehandler.OutputPath)
self.node_pool = mock.create_autospec(node.NodePool)
self.action_run_state_data = [{
'job_run_id': 'thejobname.22',
'action_name': 'blingaction',
'state': 'succeeded',
'run_time': 'sometime',
'start_time': 'sometime',
'end_time': 'sometime',
'command': 'doit',
'node_name': 'thenode',
}]
self.state_data = {
'job_name': 'thejobname',
'run_num': 22,
'run_time': self.run_time,
'node_name': 'thebox',
'end_time': 'the_end',
'start_time': 'start_time',
'runs': self.action_run_state_data,
'cleanup_run': None,
'manual': True,
}
self.context = mock.Mock()
def test_job_runs_from_state(self):
state_data = [
dict(
run_num=i,
job_name="thename",
run_time="sometime",
start_time="start_time",
end_time="sometime",
cleanup_run=None,
runs=[],
) for i in range(3, -1, -1)
]
action_graph = mock.create_autospec(actiongraph.ActionGraph)
output_path = mock.create_autospec(filehandler.OutputPath)
context = mock.Mock()
node_pool = mock.create_autospec(node.NodePool)
runs = jobrun.job_runs_from_state(
state_data,
action_graph,
output_path,
context,
node_pool,
)
assert len(runs) == 4
assert all([type(job) == jobrun.JobRun for job in runs])
def create_mock_scheduled_tasks(cls):
jobs = []
for name in ['foo', 'bar', 'baz']:
job = create_autospec(spec=ScheduledTask, instance=True)
job.failure_count = 0
job.assignedTask = create_autospec(spec=AssignedTask, instance=True)
job.assignedTask.slaveHost = 'slavehost'
job.assignedTask.task = create_autospec(spec=TaskConfig, instance=True)
job.assignedTask.task.maxTaskFailures = 1
job.assignedTask.task.executorConfig = ExecutorConfig(name='name', data='fake data')
job.assignedTask.task.metadata = []
job.assignedTask.task.job = JobKey(role=cls.TEST_ROLE, environment=cls.TEST_ENV, name=name)
job.assignedTask.task.owner = Identity(role='mchucarroll')
job.assignedTask.task.environment = 'test'
job.assignedTask.task.jobName = 'woops'
job.assignedTask.task.numCpus = 2
job.assignedTask.task.ramMb = 2
job.assignedTask.task.diskMb = 2
job.assignedTask.instanceId = 4237894
job.assignedTask.assignedPorts = None
job.status = ScheduleStatus.RUNNING
mockEvent = create_autospec(spec=TaskEvent, instance=True)
mockEvent.timestamp = 28234726395
mockEvent.status = ScheduleStatus.RUNNING
mockEvent.message = "Hi there"
job.taskEvents = [mockEvent]
jobs.append(job)
return jobs
def test_acquired(self):
"""
Test the acquiring primitives
"""
self.locker._sequence = '4'
retval = ('/_locks/test_lock/4', None)
self.locker._get_locker = mock.create_autospec(
self.locker._get_locker, return_value=retval)
self.assertTrue(self.locker._acquired())
self.assertTrue(self.locker.is_taken)
retval = ('/_locks/test_lock/1', '/_locks/test_lock/4')
self.locker._get_locker = mock.MagicMock(return_value=retval)
self.assertFalse(self.locker._acquired(blocking=False))
self.assertFalse(self.locker.is_taken)
d = {
u'action': u'delete',
u'node': {
u'modifiedIndex': 190,
u'key': u'/_locks/test_lock/1',
u'value': self.locker.uuid
}
}
self._mock_api(200, d)
returns = [('/_locks/test_lock/1', '/_locks/test_lock/4'), ('/_locks/test_lock/4', None)]
def side_effect():
return returns.pop()
self.locker._get_locker = mock.create_autospec(
self.locker._get_locker, side_effect=side_effect)
self.assertTrue(self.locker._acquired())
def test_invoke__triggers_max_errors():
with open('imhotep/fixtures/10line.diff') as f:
ten_diff = f.read()
reporter = mock.create_autospec(PRReporter)
tool = mock.create_autospec(Tool)
manager = mock.create_autospec(RepoManager)
tool.get_configs.side_effect = AttributeError
tool.invoke.return_value = {
'f1.txt': {
'1': 'there was an error',
'2': 'there was an error',
'3': 'there was an error',
'4': 'there was an error',
'5': 'there was an error',
'6': 'there was an error',
'7': 'there was an error',
'8': 'there was an error',
'9': 'there was an error',
}
}
manager.clone_repo.return_value.diff_commit.return_value = ten_diff
manager.clone_repo.return_value.tools = [tool]
imhotep = Imhotep(
pr_number=1,
repo_manager=manager,
commit_info=mock.Mock(),
)
imhotep.invoke(reporter=reporter, max_errors=2)
assert reporter.report_line.call_count == 2
assert reporter.post_comment.called
def test_basic(self):
for spec in (SomeClass, SomeClass()):
mock = create_autospec(spec)
self._check_someclass_mock(mock)
def setUp(self):
self.naming = mock.create_autospec(naming.Naming)
def setupConfig(self, config_dict, startWorker=True):
"""
Setup and start a master configured
by the function configFunc defined in the test module.
@type config_dict: dict
@param configFunc: The BuildmasterConfig dictionary.
"""
# mock reactor.stop (which trial *really* doesn't
# like test code to call!)
stop = mock.create_autospec(reactor.stop)
self.patch(reactor, 'stop', stop)
if startWorker:
if self.proto == 'pb':
proto = {"pb": {"port": "tcp:0:interface=127.0.0.1"}}
workerclass = worker.Worker
elif self.proto == 'null':
proto = {"null": {}}
workerclass = worker.LocalWorker
config_dict['workers'] = [workerclass("local1", password=Interpolate("localpw"), missing_timeout=0)]
config_dict['protocols'] = proto
m = yield getMaster(self, reactor, config_dict)
self.master = m
self.assertFalse(stop.called,
"startService tried to stop the reactor; check logs")
if not startWorker:
return
if self.proto == 'pb':
# We find out the worker port automatically
workerPort = list(itervalues(m.pbmanager.dispatchers))[
0].port.getHost().port
# create a worker, and attach it to the master, it will be started, and stopped
# along with the master
worker_dir = FilePath(self.mktemp())
worker_dir.createDirectory()
sandboxed_worker_path = os.environ.get(
"SANDBOXED_WORKER_PATH", None)
if sandboxed_worker_path is None:
self.w = Worker(
"127.0.0.1", workerPort, "local1", "localpw", worker_dir.path,
False)
else:
self.w = SandboxedWorker(
"127.0.0.1", workerPort, "local1", "localpw", worker_dir.path,
sandboxed_worker_path)
self.addCleanup(self.w.shutdownWorker)
elif self.proto == 'null':
self.w = None
if self.w is not None:
self.w.setServiceParent(m)
@defer.inlineCallbacks
def dump():
if not self._passed:
dump = StringIO()
print(u"FAILED! dumping build db for debug", file=dump)
builds = yield self.master.data.get(("builds",))
for build in builds:
yield self.printBuild(build, dump, withLogs=True)
raise self.failureException(dump.getvalue())
self.addCleanup(dump)
def _create_mock(failing):
m = mock.create_autospec(DaemonThread)
m.is_alive.return_value = not failing
return m
class F(ModelChoiceFilter):
get_queryset = mock.create_autospec(ModelChoiceFilter.get_queryset,
return_value=qs)
def test_builtins(self):
# used to fail with infinite recursion
create_autospec(1)
create_autospec(int)
create_autospec('foo')
create_autospec(str)
create_autospec({})
create_autospec(dict)
create_autospec([])
create_autospec(list)
create_autospec(set())
create_autospec(set)
create_autospec(1.0)
create_autospec(float)
create_autospec(1j)
create_autospec(complex)
create_autospec(False)
create_autospec(True)
def test_create_autospec_keyword_arguments(self):
class Foo(object):
a = 3
m = create_autospec(Foo, a='3')
self.assertEqual(m.a, '3')
def fake_process(**kwargs): proc = mock.create_autospec(psutil.Process, spec_set=True) [setattr(getattr(proc, k), 'return_value', v) for k, v in kwargs.items()] return proc
def group_service():
return mock.create_autospec(GroupService, spec_set=True, instance=True)
def items(self):
return map(lambda _: mock.create_autospec(ResultItemWidget), range(5))
from cluster import *
from . import utils
import mock
PROPOSAL1 = Proposal(caller='cli', client_id=123, input='one')
PROPOSAL2 = Proposal(caller='cli', client_id=125, input='two')
PROPOSAL3 = Proposal(caller='cli', client_id=127, input='tre')
Commander = mock.create_autospec(Commander)
Scout = mock.create_autospec(Scout)
class Tests(utils.ComponentTestCase):
def setUp(self):
super(Tests, self).setUp()
Scout.reset_mock()
Commander.reset_mock()
self.ldr = Leader(self.node, ['p1', 'p2'],
commander_cls=Commander,
scout_cls=Scout)
def assertScoutStarted(self, ballot_num):
Scout.assert_called_once_with(self.node, ballot_num, ['p1', 'p2'])
scout = Scout(self.node, ballot_num, ['p1', 'p2'])
scout.start.assert_called_once_with()
def assertNoScout(self):
self.assertFalse(self.ldr.scouting)
def assertCommanderStarted(self, ballot_num, slot, proposal):
Commander.assert_called_once_with(self.node, ballot_num, slot,
if table_name == 'IDMap' and column_names == 'identifier_id, ref_table':
return [(u'supply_type_id', u'SupplyTypes'),
(u'ghg_id', u'GreenhouseGases')]
elif table_name == 'SupplyTypes' and column_names == 'id, name':
return [(1, u'Blend'), (2, u'Conversion'), (3, u'Delivery'),
(4, u'Import'), (5, u'Primary'), (6, u'Storage')]
elif table_name == 'GreenhouseGases' and column_names == 'id, name':
return [(1, u'CO2'), (2, u'CH4'), (3, u'N2O')]
# if we've gotten this far without returning, something is amiss
raise ValueError("Mock doesn't know how to provide this table read: " +
str(table_name) + ", " + str(column_names) + ", " +
str(filters))
mock_sql_read_table = mock.create_autospec(sql_read_table,
side_effect=read_table)
@mock.patch('energyPATHWAYS.util.sql_read_table', mock_sql_read_table)
class TestIdToName(unittest.TestCase):
def test_basic_lookup(self):
self.assertEqual(id_to_name('supply_type_id', 1), 'Blend')
self.assertEqual(id_to_name('ghg_id', 2), 'CH4')
def test_lookup_none_att(self):
self.assertIsNone(id_to_name('supply_type_id', None))
def test_tuple_lookup(self):
self.assertEqual(id_to_name('supply_type_id', 1, 'tuple'),
('supply_type', 'Blend'))
def test_check_quota_Zero():
self = create_autospec(ArcticLibraryBinding)
self.quota = 0
ArcticLibraryBinding.check_quota(self)
def setUp(self):
super(TunnelTest, self).setUp()
cfg.CONF.set_default('firewall_driver',
'neutron.agent.firewall.NoopFirewallDriver',
group='SECURITYGROUP')
cfg.CONF.set_override('report_interval', 0, 'AGENT')
self.INT_BRIDGE = 'integration_bridge'
self.TUN_BRIDGE = 'tunnel_bridge'
self.MAP_TUN_BRIDGE = 'tun_br_map'
self.AUX_BRIDGE = 'ancillary_bridge'
self.NET_MAPPING = ['net1:%s' % self.MAP_TUN_BRIDGE]
self.INT_OFPORT = 11111
self.TUN_OFPORT = 22222
self.MAP_TUN_INT_OFPORT = 33333
self.MAP_TUN_PHY_OFPORT = 44444
self.LVM = self.mod_agent.LocalVLANMapping(
LV_ID, 'gre', None, LS_ID, VIF_PORTS)
self.LVM_FLAT = self.mod_agent.LocalVLANMapping(
LV_ID, 'flat', 'net1', LS_ID, VIF_PORTS)
self.LVM_VLAN = self.mod_agent.LocalVLANMapping(
LV_ID, 'vlan', 'net1', LS_ID, VIF_PORTS)
self.inta = mock.Mock()
self.intb = mock.Mock()
mock.patch.object(ovs_lib.BaseOVS, 'config',
new_callable=mock.PropertyMock,
return_value={}).start()
self.ovs_bridges = {
self.INT_BRIDGE: mock.create_autospec(
self.br_int_cls('br-int')),
self.TUN_BRIDGE: mock.create_autospec(
self.br_tun_cls('br-tun')),
self.MAP_TUN_BRIDGE: mock.create_autospec(
self.br_phys_cls('br-phys')),
self.AUX_BRIDGE: mock.create_autospec(
ovs_lib.OVSBridge('br-aux')),
}
self.ovs_int_ofports = {
'patch-tun': self.TUN_OFPORT,
'int-%s' % self.MAP_TUN_BRIDGE: self.MAP_TUN_INT_OFPORT
}
def lookup_br(br_name, *args, **kwargs):
return self.ovs_bridges[br_name]
self.mock_int_bridge_cls = mock.patch(self._BR_INT_CLASS,
autospec=True).start()
self.mock_int_bridge_cls.side_effect = lookup_br
self.mock_phys_bridge_cls = mock.patch(self._BR_PHYS_CLASS,
autospec=True).start()
self.mock_phys_bridge_cls.side_effect = lookup_br
self.mock_tun_bridge_cls = mock.patch(self._BR_TUN_CLASS,
autospec=True).start()
self.mock_tun_bridge_cls.side_effect = lookup_br
self.mock_aux_bridge_cls = mock.patch(
'neutron.agent.common.ovs_lib.OVSBridge',
autospec=True).start()
self.mock_aux_bridge_cls.side_effect = lookup_br
self.mock_int_bridge = self.ovs_bridges[self.INT_BRIDGE]
self.mock_int_bridge.add_port.return_value = self.MAP_TUN_INT_OFPORT
self.mock_int_bridge.add_patch_port.side_effect = (
lambda tap, peer: self.ovs_int_ofports[tap])
self.mock_int_bridge.port_exists.return_value = False
self.mock_int_bridge.get_vif_ports.return_value = []
self.mock_int_bridge.get_ports_attributes.return_value = []
self.mock_int_bridge.db_get_val.return_value = {}
self.mock_map_tun_bridge = self.ovs_bridges[self.MAP_TUN_BRIDGE]
self.mock_map_tun_bridge.br_name = self.MAP_TUN_BRIDGE
self.mock_map_tun_bridge.add_port.return_value = (
self.MAP_TUN_PHY_OFPORT)
self.mock_map_tun_bridge.add_patch_port.return_value = (
self.MAP_TUN_PHY_OFPORT)
self.mock_map_tun_bridge.port_exists.return_value = False
self.mock_tun_bridge = self.ovs_bridges[self.TUN_BRIDGE]
self.mock_tun_bridge.add_port.return_value = self.INT_OFPORT
self.mock_tun_bridge.add_patch_port.return_value = self.INT_OFPORT
self.ipdevice = mock.patch.object(ip_lib, 'IPDevice').start()
self.ipwrapper = mock.patch.object(ip_lib, 'IPWrapper').start()
add_veth = self.ipwrapper.return_value.add_veth
add_veth.return_value = [self.inta, self.intb]
self.get_bridges = mock.patch.object(ovs_lib.BaseOVS,
'get_bridges').start()
self.get_bridges.return_value = [self.INT_BRIDGE,
self.TUN_BRIDGE,
self.MAP_TUN_BRIDGE,
self.AUX_BRIDGE]
self.get_bridge_external_bridge_id = mock.patch.object(
ovs_lib.BaseOVS,
'get_bridge_external_bridge_id').start()
self.get_bridge_external_bridge_id.side_effect = (
lambda bridge: bridge if bridge in self.ovs_bridges else None)
self.execute = mock.patch('neutron.agent.common.utils.execute').start()
self._define_expected_calls()
def test_set_quota():
self = create_autospec(ArcticLibraryBinding)
ArcticLibraryBinding.set_quota(self, 10000)
self.set_library_metadata.assert_called_once_with('QUOTA', 10000)
assert self.quota_countdown == 0
assert self.quota == 10000
def test_check_quota_countdown():
self = create_autospec(ArcticLibraryBinding)
self.quota = 10
self.quota_countdown = 10
ArcticLibraryBinding.check_quota(self)
assert self.quota_countdown == 9
def config(self):
config = create_autospec(Configuration([]), spec_set=True)
config.datadog_container_image = None
return config
def test_get_quota():
self = create_autospec(ArcticLibraryBinding)
self.get_library_metadata.return_value = 42
assert ArcticLibraryBinding.get_quota(self) == 42
self.get_library_metadata.assert_called_once_with('QUOTA')
def v2(self):
return create_autospec(BaseTransformer,
spec_set=True,
return_value={"version": 3})
def user_service(pyramid_config):
service = mock.create_autospec(UserService, spec_set=True, instance=True)
pyramid_config.register_service(service, name="user")
return service
def test_export_staging_delegate_validation_failed(self) -> None:
metric_view_one = MetricBigQueryViewBuilder(
dataset_id="dataset",
view_id="view1",
view_query_template="select * from table",
dimensions=("a", "b", "c"),
).build()
export_config_one = ExportBigQueryViewConfig(
view=metric_view_one,
view_filter_clause="WHERE state_code = 'US_XX'",
intermediate_table_name="intermediate_table",
output_directory=GcsfsDirectoryPath.from_absolute_path(
"gs://bucket1/US_XX"),
)
export_config_one_staging = ExportBigQueryViewConfig(
view=metric_view_one,
view_filter_clause="WHERE state_code = 'US_XX'",
intermediate_table_name="intermediate_table",
output_directory=GcsfsDirectoryPath.from_absolute_path(
"gs://bucket1/staging/US_XX"),
)
metric_view_two = MetricBigQueryViewBuilder(
dataset_id="dataset",
view_id="view2",
view_query_template="select * from view2",
dimensions=("d", "e", "f"),
).build()
export_config_two = ExportBigQueryViewConfig(
view=metric_view_two,
view_filter_clause="WHERE state_code = 'US_XX'",
intermediate_table_name="intermediate_table2",
output_directory=GcsfsDirectoryPath.from_absolute_path(
"gs://bucket2/US_XX"),
)
export_config_two_staging = ExportBigQueryViewConfig(
view=metric_view_two,
view_filter_clause="WHERE state_code = 'US_XX'",
intermediate_table_name="intermediate_table2",
output_directory=GcsfsDirectoryPath.from_absolute_path(
"gs://bucket2/staging/US_XX"),
)
mock_fs = create_autospec(GCSFileSystem)
delegate_one = create_autospec(BigQueryViewExporter)
delegate_two = create_autospec(BigQueryViewExporter)
delegate_one.export_and_validate.return_value = [
export_config_one_staging.output_path("json"),
export_config_two_staging.output_path("json"),
]
delegate_two.export_and_validate.return_value = [
export_config_one_staging.output_path("txt"),
export_config_two_staging.output_path("txt"),
]
delegate_one = create_autospec(BigQueryViewExporter)
delegate_one_staging_paths = [
export_config_one_staging.output_path("json"),
export_config_two_staging.output_path("json"),
]
delegate_one.export_and_validate.return_value = delegate_one_staging_paths
delegate_two = create_autospec(BigQueryViewExporter)
delegate_two.export_and_validate.side_effect = ViewExportValidationError(
"Validation failed")
# Make the actual call
with pytest.raises(ViewExportValidationError) as e:
export_views_with_exporters(
mock_fs,
[export_config_one, export_config_two],
{
ExportOutputFormatType.JSON: delegate_one,
ExportOutputFormatType.METRIC: delegate_two,
},
)
self.assertIn("Validation failed", str(e.value))
def v3(self, app_spec):
return create_autospec(BaseFactory,
spec_set=True,
version=3,
return_value=app_spec)
def mock_flash_function():
"""Return a mock object with the same API as request.session.flash()."""
return mock.create_autospec(DummyRequest().session.flash,
return_value=None)
def test_export_happy_path(self) -> None:
metric_view_one = MetricBigQueryViewBuilder(
dataset_id="dataset",
view_id="view1",
view_query_template="select * from table",
dimensions=("a", "b", "c"),
).build()
export_config_one = ExportBigQueryViewConfig(
view=metric_view_one,
view_filter_clause="WHERE state_code = 'US_XX'",
intermediate_table_name="intermediate_table",
output_directory=GcsfsDirectoryPath.from_absolute_path(
"gs://bucket1/US_XX"),
)
export_config_one_staging = ExportBigQueryViewConfig(
view=metric_view_one,
view_filter_clause="WHERE state_code = 'US_XX'",
intermediate_table_name="intermediate_table",
output_directory=GcsfsDirectoryPath.from_absolute_path(
"gs://bucket1/staging/US_XX"),
)
metric_view_two = MetricBigQueryViewBuilder(
dataset_id="dataset",
view_id="view2",
view_query_template="select * from view2",
dimensions=("d", "e", "f"),
).build()
export_config_two = ExportBigQueryViewConfig(
view=metric_view_two,
view_filter_clause="WHERE state_code = 'US_XX'",
intermediate_table_name="intermediate_table2",
output_directory=GcsfsDirectoryPath.from_absolute_path(
"gs://bucket2/US_XX"),
)
export_config_two_staging = ExportBigQueryViewConfig(
view=metric_view_two,
view_filter_clause="WHERE state_code = 'US_XX'",
intermediate_table_name="intermediate_table2",
output_directory=GcsfsDirectoryPath.from_absolute_path(
"gs://bucket2/staging/US_XX"),
)
mock_fs = create_autospec(GCSFileSystem)
mock_fs.exists.return_value = True
delegate_one = create_autospec(BigQueryViewExporter)
delegate_one_staging_paths = [
export_config_one_staging.output_path("json"),
export_config_two_staging.output_path("json"),
]
delegate_one.export_and_validate.return_value = delegate_one_staging_paths
delegate_two = create_autospec(BigQueryViewExporter)
delegate_two_staging_paths = [
export_config_one_staging.output_path("txt"),
export_config_two_staging.output_path("txt"),
]
delegate_two.export_and_validate.return_value = delegate_two_staging_paths
# Make the actual call
export_views_with_exporters(
mock_fs,
[export_config_one, export_config_two],
{
ExportOutputFormatType.JSON: delegate_one,
ExportOutputFormatType.METRIC: delegate_two,
},
)
# Assert all mocks called as expected
delegate_one.export_and_validate.assert_has_calls([
call([export_config_one_staging, export_config_two_staging]),
])
delegate_two.export_and_validate.assert_has_calls([
call([export_config_one_staging, export_config_two_staging]),
])
mock_fs.copy.assert_has_calls(
[
call(
GcsfsFilePath(bucket_name="bucket1",
blob_name="staging/US_XX/view1.json"),
GcsfsFilePath(bucket_name="bucket1",
blob_name="US_XX/view1.json"),
),
call(
GcsfsFilePath(bucket_name="bucket2",
blob_name="staging/US_XX/view2.json"),
GcsfsFilePath(bucket_name="bucket2",
blob_name="US_XX/view2.json"),
),
call(
GcsfsFilePath(bucket_name="bucket1",
blob_name="staging/US_XX/view1.txt"),
GcsfsFilePath(bucket_name="bucket1",
blob_name="US_XX/view1.txt"),
),
call(
GcsfsFilePath(bucket_name="bucket2",
blob_name="staging/US_XX/view2.txt"),
GcsfsFilePath(bucket_name="bucket2",
blob_name="US_XX/view2.txt"),
),
],
any_order=True,
)
mock_fs.delete.assert_has_calls(
[
call(
GcsfsFilePath(bucket_name="bucket1",
blob_name="staging/US_XX/view1.json")),
call(
GcsfsFilePath(bucket_name="bucket2",
blob_name="staging/US_XX/view2.json")),
call(
GcsfsFilePath(bucket_name="bucket1",
blob_name="staging/US_XX/view1.txt")),
call(
GcsfsFilePath(bucket_name="bucket2",
blob_name="staging/US_XX/view2.txt")),
],
any_order=True,
)
def _make_rpc_error(error_cls, trailing_metadata=None):
import grpc
grpc_error = mock.create_autospec(grpc.Call, instance=True)
grpc_error.trailing_metadata.return_value = trailing_metadata
return error_cls("error", errors=(grpc_error, ))
def test__thread_main_max_latency(self, time):
# Note: this test is a bit brittle as it assumes the operation of
# _get_many invokes queue.get() followed by queue._get(). It fails
# the "change detector" test in that way. However, this is still a
# useful test to verify the queue timeout is appropriately calculated.
from google.cloud.logging_v2.handlers.transports import background_thread
# Use monotonically increasing time.
time.side_effect = range(1, 6)
worker = self._make_one(_Logger(self.NAME),
max_latency=2,
max_batch_size=10)
worker._queue = mock.create_autospec(queue.Queue, instance=True)
worker._queue.get.side_effect = [
{
"message": 1
}, # Single record.
queue.Empty(), # Emulate a queue.get() timeout.
{
"message": "2"
}, # Second record.
background_thread._WORKER_TERMINATOR, # Stop the thread.
queue.Empty(), # Emulate a queue.get() timeout.
]
worker._thread_main()
self.assertEqual(worker._cloud_logger._num_batches, 2)
self.assertTrue(worker._cloud_logger._batch.commit_called)
self.assertEqual(worker._cloud_logger._batch.commit_count, 1)
# Time should have been called five times.
#
# For the first batch, it should have been called:
# * Once to get the start time. (1)
# * Once to get the elapsed time while grabbing the second item.
# (2)
#
# For the second batch, it should have been called:
# * Once to get start time. (3)
# * Once to get the elapsed time while grabbing the second item.
# (3)
# * Once to get the elapsed time while grabbing the final
# item. (4)
# * Once final time to get the elapsed time while receiving
# the empty queue.
#
self.assertEqual(time.call_count, 5)
# Queue.get should've been called 5 times as well, but with different
# timeouts due to the monotonically increasing time.
#
# For the first batch, it will be called once without a timeout
# (for the first item) and then with timeout=1, as start will be
# 1 and now will be 2.
#
# For the second batch, it will be called once without a timeout
# (for the first item) and then with timeout=1, as start will be
# 3 and now will be 4, and finally with timeout=0 as start will be 3
# and now will be 5.
#
worker._queue.get.assert_has_calls([
mock.call(),
mock.call(timeout=1),
mock.call(),
mock.call(timeout=1),
mock.call(timeout=0),
])
def _next_page(self):
return mock.create_autospec(page_iterator.Page, instance=True)
def __init__(self, fs: FakeGCSFileSystem):
super().__init__(create_autospec(gcsfs.GCSFileSystem))
self.fs = fs
def setUp(self): super(PcapFilter, self).setUp() self.naming = mock.create_autospec(naming.Naming)
def test_masterDeactivated(self):
self.master.db.insertTestData([
fakedb.Master(id=14, name='other', active=0, last_active=0),
# set up a running build with some steps
fakedb.Builder(id=77, name='b1'),
fakedb.Worker(id=13, name='sl'),
fakedb.Buildset(id=8822),
fakedb.BuildRequest(id=82, builderid=77, buildsetid=8822),
fakedb.BuildRequestClaim(brid=82, masterid=14,
claimed_at=SOMETIME),
fakedb.Build(id=13,
builderid=77,
masterid=14,
workerid=13,
buildrequestid=82,
number=3,
results=None),
fakedb.Step(id=200, buildid=13),
fakedb.Log(id=2000, stepid=200, num_lines=2),
fakedb.LogChunk(logid=2000,
first_line=1,
last_line=2,
content=u'ab\ncd')
])
# mock out the _masterDeactivated methods this will call
for rtype in 'builder', 'scheduler', 'changesource':
rtype_obj = getattr(self.master.data.rtypes, rtype)
m = mock.Mock(name='%s._masterDeactivated' % rtype,
spec=rtype_obj._masterDeactivated)
m.side_effect = lambda masterid: defer.succeed(None)
rtype_obj._masterDeactivated = m
# and the update methods..
for meth in 'finishBuild', 'finishStep', 'finishLog':
m = mock.create_autospec(getattr(self.master.data.updates, meth))
m.side_effect = lambda *args, **kwargs: defer.succeed(None)
setattr(self.master.data.updates, meth, m)
yield self.rtype._masterDeactivated(14, 'other')
self.master.data.rtypes.builder._masterDeactivated. \
assert_called_with(masterid=14)
self.master.data.rtypes.scheduler._masterDeactivated. \
assert_called_with(masterid=14)
self.master.data.rtypes.changesource._masterDeactivated. \
assert_called_with(masterid=14)
# see that we finished off that build and its steps and logs
updates = self.master.data.updates
updates.finishLog.assert_called_with(logid=2000)
updates.finishStep.assert_called_with(stepid=200,
results=RETRY,
hidden=False)
updates.finishBuild.assert_called_with(buildid=13, results=RETRY)
self.assertEqual(self.master.mq.productions, [
(('masters', '14', 'stopped'),
dict(masterid=14, name='other', active=False)),
])
