def test_iteration_yields_bound_headers(self):
HEADERS = (
Header('field_a'),
Header('field_b', 'Test Label'),
Header('test_name', 'Test Name', column_name='field_c'),
Header('created_at', is_sortable=False),
)
form = mock.NonCallableMagicMock(forms.Form)
form.prefix = None
header_set = HeaderSet(form, HEADERS)
self.assertTrue(
all((isinstance(header, BoundHeader) for header in header_set)))
def cloud_node_mock(node_num=99, size=MockSize(1), **extra):
node = mock.NonCallableMagicMock([
'id', 'name', 'state', 'public_ips', 'private_ips', 'driver', 'size',
'image', 'extra'
],
name='cloud_node')
node.id = str(node_num)
node.name = node.id
node.size = size
node.public_ips = []
node.private_ips = [ip_address_mock(node_num)]
node.extra = extra
return node
def test_create_token_non_callable_expires_in(self):
"""
When a non callable expires in is set this should just be set to the request
"""
expires_in_mock = mock.NonCallableMagicMock()
request_mock = mock.MagicMock()
token = JWTToken(expires_in=expires_in_mock,
request_validator=mock.MagicMock())
token.create_token(request=request_mock)
self.assertFalse(expires_in_mock.called)
self.assertEqual(request_mock.expires_in, expires_in_mock)
def testCollectAgentTraceDataEmptyTrace(self, mock_get_results):
# Make GetResults() in the mock systrace atrace agent return an empty
# trace.
empty_atrace_output = '# tracer: nop'
mock_get_results.return_value.raw_data = empty_atrace_output
atrace_agent = atrace_tracing_agent.AtraceTracingAgent(
self._mock_platform_backend)
mock_trace_builder = mock.NonCallableMagicMock(spec=['AddTraceFor'])
atrace_agent.CollectAgentTraceData(mock_trace_builder)
mock_trace_builder.AddTraceFor.assert_called_once_with(
trace_data.ATRACE_PART,
empty_atrace_output,
allow_unstructured=True)
def patch_initctl(request):
# Mock subprocess calls used by container build
fake_popen = mock.NonCallableMagicMock()
fake_popen.stdout = BytesIO("foo")
fake_popen.returncode = 0
fake_popen.poll.side_effect = lambda: 0
subprocess_patcher = mock.patch("gevent.subprocess.Popen",
side_effect=lambda *a, **kw: fake_popen)
subprocess_patcher.start()
def end():
subprocess_patcher.stop()
request.addfinalizer(end)
def _dummy_request_put(self,
url='http://example/status',
path=None,
revision=None,
content=None):
request = self._dummy_request_get(url, path, revision)
# The request to make.
request.method = 'PUT'
if content is not None:
request.content = mock.NonCallableMagicMock()
request.content.getvalue = mock.Mock(return_value=content)
return request
def _setup_response(modifier, get, status_type):
response_file = os.path.join(os.path.dirname(__file__),
status_type + ".yml")
with open(response_file) as fobj:
response_data = yaml.safe_load(fobj)
modifier(response_data)
response = mock.NonCallableMagicMock()
response.json.return_value = response_data
def _get(url, **kwargs):
if url.endswith("{}/".format(status_type)):
return response
else:
raise NotFound()
get.side_effect = _get
def test_index_and_key_lookups(self):
HEADERS = (
Header('field_a'),
Header('field_b', 'Test Label'),
Header('test_name', 'Test Name', column_name='field_c'),
Header('created_at', is_sortable=False),
)
form = mock.NonCallableMagicMock(forms.Form)
form.prefix = None
header_set = HeaderSet(form, HEADERS)
self.assertIsInstance(header_set[0], BoundHeader)
self.assertEqual(header_set[0].header, HEADERS[0])
self.assertIsInstance(header_set['field_b'], BoundHeader)
self.assertEqual(header_set['field_b'].header, HEADERS[1])
def test_cobbler_deploy(self):
domain = NonCallableMagicMock(spec_set=Domain)
server = cobbler.CobblerServer("test.foo.bar", domain)
server._cobbler_path = "/cobbler/path"
conn = mock.NonCallableMagicMock()
conn.execute.return_value = ["", "", 0]
server._conn = conn
server.is_running = mock.MagicMock(return_value=False)
server.is_installed = mock.MagicMock(return_value=False)
self.assertRaises(CobblerException, server.deploy)
server.is_installed.return_value = True
self.assertRaises(CobblerException, server.deploy)
server.is_running.return_value = True
conn.mock_calls = []
server.deploy()
expected = [
mock.call.execute("test1.foo.bar-update"),
mock.call.execute("test2.foo.bar-add")
]
for exp in expected:
self.assertIn(exp, conn.mock_calls)
def test_archive_listing_parses_correctly_basics(self):
instance_mock = mock.NonCallableMagicMock()
lines = [
b"712fded485ebd593f5954e38acb78ea437c15997-1416279400.0-mrgl",
b"712fded485ebd593f5954e38acb78ea437c1599f-1416280000.0-brgl",
b"712fded485ebd593f5954e38acb78ea437c15997-1416369139.0-mrgl"
]
instance_mock.stdout = io.BytesIO(b"\n".join(lines))
instance_mock.wait = lambda: 0
with mock.patch("subprocess.Popen",
return_value=instance_mock) as mock_popen:
results = self.backend.existing_archives_for_name("mrgl")
self.assertEqual(len(results), 2)
for result in results:
self.assertIs(result.backend, self.backend)
for archive, fullname in zip(
results, [line for line in lines if b"mrgl" in line]):
self.assertEqual(archive.fullname, fullname.decode('utf-8'))
for archive, time in zip(results, [1416279400, 1416369139]):
self.assertEqual(archive.timestamp, time)
def test_from_response(self):
response = mock.NonCallableMagicMock(spec=requests.Response)
response.headers = {
'content-type': 'multipart/related; boundary="samp1"'
}
cnt = io.BytesIO()
cnt.write(b'\r\n--samp1\r\n')
cnt.write(b'Header-1: Header-Value-1\r\n')
cnt.write(b'Header-2: Header-Value-2\r\n')
cnt.write(b'\r\n')
cnt.write(b'Body 1, Line 1\r\n')
cnt.write(b'Body 1, Line 2\r\n')
cnt.write(b'--samp1\r\n')
cnt.write(b'\r\n')
cnt.write(b'Body 2, Line 1\r\n')
cnt.write(b'--samp1--\r\n')
response.content = cnt.getvalue()
decoder_2 = MultipartDecoder.from_response(response)
assert decoder_2.content_type == response.headers['content-type']
assert (
decoder_2.parts[0].content == b'Body 1, Line 1\r\nBody 1, Line 2')
assert decoder_2.parts[0].headers[b'Header-1'] == b'Header-Value-1'
assert len(decoder_2.parts[1].headers) == 0
assert decoder_2.parts[1].content == b'Body 2, Line 1'
def test_patch_all(patched_modules, _):
module_mock = mock.NonCallableMagicMock(patch=mock.MagicMock())
patched_modules.MODULES = {'test': module_mock}
epsagon.patcher.patch_all()
module_mock.patch.assert_called()
def test_non_multipart_response_fails(self):
jpeg_response = mock.NonCallableMagicMock(spec=requests.Response)
jpeg_response.headers = {'content-type': 'image/jpeg'}
with pytest.raises(NonMultipartContentTypeException):
MultipartDecoder.from_response(jpeg_response)
def mock_session(self):
return mock.NonCallableMagicMock()
def cluster(self):
cluster = mock.NonCallableMagicMock(name="cluster")
cluster.find_deployment_configs.return_value = (DeploymentConfig(
"testapp", "test1", "stable"), )
return cluster
def setUp(self):
self.meetup = self.patch("meetups.logic.meetup")
self.user = mock.NonCallableMagicMock()
def create(self, name):
return mock.NonCallableMagicMock(name=name)
def setUp(self):
self._mock_platform_backend = mock.NonCallableMagicMock()
