def test_render_POST_empty_authorization(self):
resource = StatusHandlerResource(sentinel.status_worker)
request = DummyRequest([])
request.requestHeaders.addRawHeader(b"authorization", "")
output = resource.render_POST(request)
self.assertEquals(b"", output)
self.assertEquals(401, request.responseCode)
def test_non_xml_compliant_banner_will_send_default_invalid_format_banner(
self):
request = DummyRequest([''])
banner_file_name = 'banner.txt'
xml_invalid_banner = '<p>some unclosed paragraph'
self._write(banner_file_name, xml_invalid_banner)
self.resource._disclaimer_banner = 'service/_trial_temp/' + banner_file_name
d = self.web.get(request)
def assert_default_invalid_banner_disclaimer_rendered(_):
self.assertEqual(200, request.responseCode)
written_response = ''.join(request.written)
self.assertIn(
"Invalid XML template format for service/_trial_temp/banner.txt.",
written_response)
def tear_down(_):
os.remove(banner_file_name)
d.addCallback(assert_default_invalid_banner_disclaimer_rendered)
d.addCallback(tear_down)
return d
def testDeferredResource(self):
r = resource.Resource()
r.isLeaf = 1
s = SDResource(r)
d = DummyRequest(['foo', 'bar', 'baz'])
resource.getChildForRequest(s, d)
self.assertEqual(d.postpath, ['bar', 'baz'])
def setUp(self):
self.services_factory = mock()
self.portal = mock()
self.provider = mock()
self.resource = LoginResource(self.services_factory, self.portal)
self.web = DummySite(self.resource)
self.request = DummyRequest([''])
username = '******'
self.request.addArg('username', username)
password = '******'
self.username = username
self.password = password
self.request.addArg('password', password)
self.request.method = 'POST'
leap_session = mock(LeapSession)
user_auth = mock()
user_auth.uuid = 'some_user_uuid'
leap_session.user_auth = user_auth
config = mock()
config.leap_home = 'some_folder'
leap_session.config = config
leap_session.fresh_account = False
self.leap_session = leap_session
self.user_auth = user_auth
def test_missing(self):
"""
minimally-defined static servers just need anonymous-storage-FURL
and permutation-seed-base32. The WUI used to have problems
rendering servers that lacked nickname and version. This tests that
we can render such minimal servers.
"""
ann = {"anonymous-storage-FURL": "pb://w2hqnbaa25yw4qgcvghl5psa3srpfgw3@tcp:127.0.0.1:51309/vucto2z4fxment3vfxbqecblbf6zyp6x",
"permutation-seed-base32": "w2hqnbaa25yw4qgcvghl5psa3srpfgw3",
}
srv = NativeStorageServer("server_id", ann, None, {}, EMPTY_CLIENT_CONFIG)
srv.get_connection_status = lambda: ConnectionStatus(False, "summary", {}, 0, 0)
class FakeClient(_Client):
def __init__(self):
service.MultiService.__init__(self)
self.storage_broker = StorageFarmBroker(
permute_peers=True,
tub_maker=None,
node_config=EMPTY_CLIENT_CONFIG,
)
self.storage_broker.test_add_server("test-srv", srv)
root = RootElement(FakeClient(), time.time)
req = DummyRequest(b"")
tag = Tag(b"")
# Pick all items from services table.
items = root.services_table(req, tag).item(req, tag)
# Coerce `items` to list and pick the first item from it.
item = list(items)[0]
self.assertEqual(item.slotData.get("version"), "")
self.assertEqual(item.slotData.get("nickname"), "")
def test_returns_the_key_as_json_if_found(self):
request = DummyRequest(['/keys'])
request.addArg('search', 'some@key')
when(self.keymanager).fetch_key('some@key').thenReturn(
defer.succeed(OpenPGPKey('some@key')))
d = self.web.get(request)
expected = {
"tags": ["keymanager-key"],
"fingerprint": '',
"private": False,
'sign_used': False,
'refreshed_at': 0,
"expiry_date": 0,
"address": 'some@key',
'encr_used': False,
'last_audited_at': 0,
'key_data': '',
'length': 0,
'key_id': '',
'validation': 'Weak_Chain',
'type': 'OpenPGPKey',
}
def assert_response(_):
actual = json.loads(ast.literal_eval(request.written[0]))
self.assertEquals(expected, actual)
d.addCallback(assert_response)
return d
def test_render(self):
"""
L{ResourceScriptDirectory.getChild} returns a resource which renders a
response with the HTTP 200 status code and the content of the rpy's
C{request} global.
"""
tmp = FilePath(self.mktemp())
tmp.makedirs()
tmp.child("test.rpy").setContent(b"""
from twisted.web.resource import Resource
class TestResource(Resource):
isLeaf = True
def render_GET(self, request):
return b'ok'
resource = TestResource()""")
resource = ResourceScriptDirectory(tmp._asBytesPath())
request = DummyRequest([b''])
child = resource.getChild(b"test.rpy", request)
d = _render(child, request)
def cbRendered(ignored):
self.assertEqual(b"".join(request.written), b"ok")
d.addCallback(cbRendered)
return d
def test_post_new_attachment(self, mock_fields):
request = DummyRequest(['/attachment'])
request.method = 'POST'
request.content = 'mocked'
attachment_id = 'B5B4ED80AC3B894523D72E375DACAA2FC6606C18EDF680FE95903086C8B5E14A'
_file = MagicMock()
_file.value = 'some mocked value'
_file.type = 'some mocked type'
_file.filename = 'filename.txt'
mock_fields.return_value = {'attachment': _file}
when(self.mail_service).save_attachment(
'some mocked value',
'some mocked type').thenReturn(defer.succeed(attachment_id))
d = self.web.get(request)
def assert_response(_):
self.assertEqual(201, request.code)
self.assertEqual('/attachment/%s' % attachment_id,
request.headers['Location'])
response_json = {
'ident': attachment_id,
'content-type': 'some mocked type',
'name': 'filename.txt',
'size': 17,
'encoding': 'base64'
}
self.assertEqual(response_json, json.loads(request.written[0]))
verify(self.mail_service).save_attachment('some mocked value',
'some mocked type')
d.addCallback(assert_response)
return d
def test_render_GET_should_set_sandbox_csp_header(self):
request = DummyRequest(['/sandbox'])
request.method = 'GET'
request.isSecure = lambda: True
request.redirect = lambda _: 'irrelevant'
expected_csp_headers = "sandbox allow-popups allow-scripts;" \
"default-src 'self';" \
"style-src *;" \
"script-src *;" \
"font-src *;" \
"img-src *;" \
"object-src 'none';" \
"connect-src 'none';"
yield self.web.get(request)
self.assertEquals(
expected_csp_headers,
request.outgoingHeaders.get('X-Content-Security-Policy'.lower()))
self.assertEquals(
expected_csp_headers,
request.outgoingHeaders.get('Content-Security-Policy'.lower()))
self.assertEquals(expected_csp_headers,
request.outgoingHeaders.get('X-Webkit-CSP'.lower()))
def test_post_attachment_fails(self, mock_fields):
request = DummyRequest(['/attachment'])
request.method = 'POST'
request.content = 'mocked'
_file = MagicMock()
_file.value = 'some mocked value'
_file.type = 'some mocked type'
mock_fields.return_value = {'attachment': _file}
when(self.mail_service).save_attachment('some mocked value',
'some mocked type').thenReturn(
defer.fail(Exception))
d = self.web.get(request)
def assert_response(_):
self.assertEqual(500, request.code)
self.assertFalse(
request.responseHeaders.hasHeader('Location'.lower()))
self.assertIn("message", json.loads(request.written[0]))
verify(self.mail_service).save_attachment('some mocked value',
'some mocked type')
d.addCallback(assert_response)
return d
def test_pathInfo(self):
"""
L{twcgi.CGIScript.render} sets the process environment
I{PATH_INFO} from the request path.
"""
class FakeReactor:
"""
A fake reactor recording the environment passed to spawnProcess.
"""
def spawnProcess(self, process, filename, args, env, wdir):
"""
Store the C{env} L{dict} to an instance attribute.
@param process: Ignored
@param filename: Ignored
@param args: Ignored
@param env: The environment L{dict} which will be stored
@param wdir: Ignored
"""
self.process_env = env
_reactor = FakeReactor()
resource = twcgi.CGIScript(self.mktemp(), reactor=_reactor)
request = DummyRequest(["a", "b"])
request.client = address.IPv4Address("TCP", "127.0.0.1", 12345)
_render(resource, request)
self.assertEqual(_reactor.process_env["PATH_INFO"], "/a/b")
def test_useReactorArgument(self):
"""
L{twcgi.FilteredScript.runProcess} uses the reactor passed as an
argument to the constructor.
"""
class FakeReactor:
"""
A fake reactor recording whether spawnProcess is called.
"""
called = False
def spawnProcess(self, *args, **kwargs):
"""
Set the C{called} flag to C{True} if C{spawnProcess} is called.
@param args: Positional arguments.
@param kwargs: Keyword arguments.
"""
self.called = True
fakeReactor = FakeReactor()
request = DummyRequest(["a", "b"])
request.client = address.IPv4Address("TCP", "127.0.0.1", 12345)
resource = twcgi.FilteredScript("dummy-file", reactor=fakeReactor)
_render(resource, request)
self.assertTrue(fakeReactor.called)
def test_returns_the_key_as_json_if_found(self):
request = DummyRequest(['/keys'])
request.addArg('search', 'some@key')
when(self.keymanager).fetch_key('some@key').thenReturn(
defer.succeed(OpenPGPKey('some@key')))
d = self.web.get(request)
expected = {
u'address': u'some@key',
u'encr_used': False,
u'fingerprint': u'',
u'last_audited_at': 0,
u'private': False,
u'sign_used': False,
u'tags': [u'keymanager-active'],
u'type': u'OpenPGPKey-active',
u'validation': u'Weak_Chain',
u'version': 1,
}
def assert_response(_):
actual = json.loads(ast.literal_eval(request.written[0]))
self.assertEquals(expected, actual)
d.addCallback(assert_response)
return d
def test__error_when_starting_changes_page_to_error(self):
service = self.make_webapp()
self.addCleanup(service.stopService)
mock_prepare = self.patch_autospec(service, "prepareApplication")
mock_prepare.side_effect = factory.make_exception()
# No error is returned.
with TwistedLoggerFixture():
service.startService()
# The site's page (for any path) shows the error.
request = DummyRequest("any/where".split("/"))
resource = service.site.getResourceFor(request)
content = resource.render(request)
page = html.fromstring(content)
self.expectThat(
page.find(".//title").text_content(),
Equals("503 - MAAS failed to start"))
self.expectThat(
page.find(".//h1").text_content(), Equals("MAAS failed to start"))
self.assertDocTestMatches(
dedent("""\
Traceback (most recent call last):
...
maastesting.factory.TestException#...
"""),
page.find(".//pre").text_content())
def request_same_or_different_thread_thread(self):
hr = HendrixWSGIResource(reactor, self.tp, self.wsgi_thing)
request1 = DummyRequest('r1')
request1.isSecure = lambda: False
request1.content = "llamas"
d = deferToThreadPool(reactor, self.tp, hr.render, request1)
return d
def test_respond_json_deferred_should_populate_response(self):
request = DummyRequest([''])
body = respond_json_deferred({"test": "yep"}, request)
self.assertEqual(200, request.code)
self.assertEqual(b"{\"test\": \"yep\"}", request.written[0])
self.assertEqual([b"application/json"],
request.responseHeaders.getRawHeaders("Content-Type"))
def test__render_POST_bad_authorization(self):
resource = StatusHandlerResource(sentinel.status_worker)
request = DummyRequest([])
request.requestHeaders.addRawHeader(b'authorization',
factory.make_name('auth'))
output = resource.render_POST(request)
self.assertEquals(b'', output)
self.assertEquals(401, request.responseCode)
def test_getResourceFor_wraps_render_wo_underlay_raises_no_method(self):
root = Resource()
maas = Resource()
root.putChild(b"MAAS", maas)
site = OverlaySite(root)
request = DummyRequest([b"MAAS"])
resource = site.getResourceFor(request)
self.assertThat(resource, Is(maas))
self.assertRaises(UnsupportedMethod, resource.render, request)
def test_read_blob(self, get_path):
path = os.path.join(self.tempdir, 'blob')
with open(path, 'w') as f:
f.write('bl0b')
get_path.return_value = path
backend = _blobs.FilesystemBlobsBackend(blobs_path=self.tempdir)
consumer = DummyRequest([''])
yield backend.read_blob('user', 'blob_id', consumer)
self.assertEqual(['bl0b'], consumer.written)
def test_render_get(self, pay_mock):
# add requests
request1 = DummyRequest(postpath=[b'user', b'bob'])
request2 = DummyRequest(postpath=[b'user', b'bob'])
self.sse.render_GET(request=request1)
self.sse.render_GET(request=request2)
self.assertEqual(
len(self.sse.subscribers.connections['user']
['bob.id.fedoraproject.org']), 2)
# req1 started the looping call so it gets an extra message
self.assertEqual(request1.written, [
b'',
b"data: unittest\r\n\r\n",
])
# req2 is waiting for the next cycle for it to be sent a message so its
# empty
self.assertEqual(request2.written, [b''])
def request_same_or_different_thread_thread(self):
hr = HendrixWSGIResource(reactor, self.tp, self.wsgi_thing)
request1 = DummyRequest([b'r1'])
request1.isSecure = lambda: False
request1.content = b"llamas"
request1.client = IPv4Address("TCP", b"50.0.50.0", 5000)
d = deferToThreadPool(reactor, self.tp, hr.render, request1)
d.addCallback(lambda _: request1.notifyFinish())
return d
def test_handle_request_valid(self, alc_mock, dlce_mock):
alc_mock.return_value = None
dlce_mock.return_value = True
request = DummyRequest(postpath=['user', 'bob'])
self.sse.handle_request(request)
# handle request does not format the path
self.assertTrue('user' in self.sse.subscribers.connections)
self.assertTrue('bob' in self.sse.subscribers.connections['user'])
def make_request(self, content=None, token=None):
request = DummyRequest([])
if token is None:
token = factory.make_name('token')
request.requestHeaders.addRawHeader(b'authorization',
'oauth_token=%s' % token)
if content is not None:
request.content = BytesIO(content)
return request
def test_exhaustedPostPath(self):
"""
L{getChildForRequest} returns whatever resource has been reached by the
time the request's C{postpath} is empty.
"""
request = DummyRequest([])
resource = Resource()
result = getChildForRequest(resource, request)
self.assertIdentical(resource, result)
def test_param_resource_override_name():
request = DummyRequest("/")
request.addArg(b"id", b"1234")
request.addArg(b"def", b"true")
resource = DemoPage()
args = resource.parse_args(request)
assert args["def"] is True
def test_leafResource(self):
"""
L{getChildForRequest} returns the first resource it encounters with a
C{isLeaf} attribute set to C{True}.
"""
request = DummyRequest([b"foo", b"bar"])
resource = Resource()
resource.isLeaf = True
result = getChildForRequest(resource, request)
self.assertIdentical(resource, result)
def test_defaultHEAD(self):
"""
When not otherwise overridden, L{Resource.render} treats a I{HEAD}
request as if it were a I{GET} request.
"""
expected = b"insert response here"
request = DummyRequest([])
request.method = b"HEAD"
resource = BytesReturnedRenderable(expected)
self.assertEqual(expected, resource.render(request))
def test_getResourceFor_returns_resource_from_underlay(self):
underlay_root = Resource()
underlay_maas = Resource()
underlay_root.putChild(b"MAAS", underlay_maas)
overlay_root = Resource()
site = OverlaySite(overlay_root)
site.underlay = Site(underlay_root)
request = DummyRequest([b"MAAS"])
resource = site.getResourceFor(request)
self.assertThat(resource, Is(underlay_maas))
def setUp(self):
self.request = DummyRequest(b"/uri")
self.request.fields = {}
def prepathURL():
return b"http://127.0.0.1.99999/" + b"/".join(self.request.prepath)
self.request.prePathURL = prepathURL
self.client = Mock()
self.res = URIHandler(self.client)
def test_param_resource():
request = DummyRequest("/")
request.addArg(b"id", b"1234")
request.addArg(b"show_details", b"false")
resource = DemoPage()
args = resource.parse_args(request)
assert args["id"] == "1234"
assert args["show_details"] is False
