def test_get_request_id_from_request_id_header():
builder = EnvironBuilder()
builder.headers['NotifyRequestID'] = 'from-header'
builder.headers['NotifyDownstreamNotifyRequestID'] = 'from-downstream'
request = CustomRequest(builder.get_environ())
request_id = request._get_request_id('NotifyRequestID',
'NotifyDownstreamRequestID')
assert request_id == 'from-header'
def wsgi_output(application):
data = {}
def start_response(status, headers):
data['status'] = status
data['headers'] = headers
data['output'] = application(
EnvironBuilder(path='/', method='GET').get_environ(), start_response)
return data
def test_get_request_id_generates_id(uuid4_mock):
builder = EnvironBuilder()
request = CustomRequest(builder.get_environ())
uuid4_mock.return_value = 'generated'
request_id = request._get_request_id('NotifyRequestID',
'NotifyDownstreamRequestID')
assert uuid4_mock.call_count == 1
assert request_id == 'generated'
def connect(self, namespace=None):
"""Connect the client."""
environ = EnvironBuilder('/socket.io').get_environ()
environ['flask.app'] = self.app
self.socketio.server._handle_eio_connect(self.sid, environ)
if namespace is not None and namespace != '/':
pkt = packet.Packet(packet.CONNECT, namespace=namespace)
with self.app.app_context():
self.socketio.server._handle_eio_message(
self.sid, pkt.encode())
def test_get_request_id_with_no_downstream_header_configured(uuid4_mock):
builder = EnvironBuilder()
builder.headers[''] = 'from-downstream'
request = CustomRequest(builder.get_environ())
uuid4_mock.return_value = 'generated'
request_id = request._get_request_id('NotifyRequestID', '')
assert uuid4_mock.call_count == 1
assert request_id == 'generated'
def test_user_lookup_handler_missing(conn):
values = {'format': 'json', 'client': 'app1key', 'user': '******'}
builder = EnvironBuilder(method='POST', data=values)
handler = UserLookupHandler(connect=provider(conn))
resp = handler.handle(Request(builder.get_environ()))
assert_equals('application/json; charset=UTF-8', resp.content_type)
assert_equals('400 BAD REQUEST', resp.status)
data = json.loads(resp.data)
assert_equal('error', data['status'])
assert_equal(6, data['error']['code'])
def test_api_key(key_file, key, referrer, permitted):
a = APIKeys(key_file)
headers = []
if referrer:
headers.append(('Referer', referrer))
builder = EnvironBuilder(method='GET',
query_string={'key': key},
headers=headers)
req = Request(builder.get_environ())
assert a.is_permitted(req) == permitted
def test_content_type_with_options(self):
"""Content-Type can also have options."""
builder = EnvironBuilder(
method='POST',
content_type='application/x-www-form-urlencoded; charset=utf-8')
request = Request(builder.get_environ())
# Must populate form field manually with non-default content-type.
request.form = {'foo': 'bar'}
data = decode_request(request)
assert data['foo'] == 'bar'
def test_user_lookup_handler(conn):
values = {'format': 'json', 'client': 'app1key', 'user': '******'}
builder = EnvironBuilder(method='POST', data=values)
handler = UserLookupHandler(connect=provider(conn))
resp = handler.handle(Request(builder.get_environ()))
assert_equals('application/json; charset=UTF-8', resp.content_type)
assert_equals('200 OK', resp.status)
data = json.loads(resp.data)
assert_equal('ok', data['status'])
assert_equal('user1key', data['user']['apikey'])
def test_video_unable_to_write(self):
with mock.patch('os.makedirs') as omd:
omd.side_effect = IOError
filename = 'avi-sample.avi'
with open('tests/videos/valid/'+filename,'rb') as fb:
builder = EnvironBuilder(method='POST', data={'file': (fb, filename)})
ufile = builder.files.popitem()[1]
res = upload.send_video(ufile,'Title test','testbucket','user-test')
self.assertEqual('error',res['status'])
self.assertEqual('Unable to write on temporary folder',res['message'])
def test_uri_from_img_request(self):
img_path = '/%s/full/full/0/default.jpg' % (self.test_jp2_color_id, )
builder = EnvironBuilder(path=img_path)
env = builder.get_environ()
req = Request(env)
base_uri, ident, params, request_type = self.app._dissect_uri(req)
expected = '/'.join((self.URI_BASE, self.test_jp2_color_id))
self.assertEqual(base_uri, expected)
def test_inject_body(self):
'''Body argument is extracted from the request and injected.'''
builder = EnvironBuilder(data='{"foo": "bar"}',
method='POST',
content_type='application/json')
request = Request(builder.get_environ())
expected = {'var_one': {'foo': 'bar'}}
wkargs = {}
utils.inject_extra_args(dummy.body_func, request, wkargs)
self.assertEqual(expected, wkargs)
def test_serve_metrics():
request = EnvironBuilder(method="GET",
path="/metrics",
headers={
"Accept": "text/html"
}).get_request()
# replace metrics mock with a real dependency from nameko-prometheus
service = worker_factory(MyService, metrics=MetricsServer())
response = service.serve_metrics(request)
assert response.status_code == 200
def test_sync_1(self, remote_bare_repo, mock_create_labbooks_no_lfs,
mock_config_file):
# Setup responses mock for this test
responses.add(responses.GET,
'https://usersrv.gigantum.io/key',
json={'key': 'afaketoken'},
status=200)
test_user_lb = LabBook(mock_create_labbooks_no_lfs[0])
test_user_lb.from_name('default', 'default', 'labbook1')
test_user_wf = GitWorkflow(test_user_lb)
test_user_wf.publish('default')
# Mock the request context so a fake authorization header is present
builder = EnvironBuilder(path='/labbook',
method='POST',
headers={'Authorization': 'Bearer AJDFHASD'})
env = builder.get_environ()
req = Request(environ=env)
remote_url = test_user_lb.root_dir
assert remote_url
sally_lb = LabBook(mock_config_file[0])
sally_lb.from_remote(remote_url,
username="******",
owner="default",
labbook_name="labbook1")
sally_wf = GitWorkflow(sally_lb)
assert sally_lb.active_branch == "gm.workspace-sally"
sally_lb.makedir(relative_path='code/sally-dir',
create_activity_record=True)
sally_wf.sync('sally')
sync_query = """
mutation x {
syncLabbook(input: {
labbookName: "labbook1",
owner: "default"
}) {
updateCount
updatedLabbook {
isRepoClean
}
}
}
"""
r = mock_create_labbooks_no_lfs[2].execute(sync_query,
context_value=req)
assert 'errors' not in r
assert r['data']['syncLabbook']['updateCount'] == 1
assert r['data']['syncLabbook']['updatedLabbook']['isRepoClean'] is True
assert test_user_lb.active_branch == 'gm.workspace-default'
def mock_livestatus(
with_context: bool = False,
with_html: bool = False
) -> Generator[MockLiveStatusConnection, None, None]:
live = MockLiveStatusConnection()
env = EnvironBuilder().get_environ()
req = http.Request(env)
resp = http.Response()
app_context: ContextManager
req_context: ContextManager
if with_html:
html_obj = None
else:
html_obj = html(
request=req,
response=resp,
output_funnel=OutputFunnel(resp),
output_format="html",
)
if with_context:
app_context = AppContext(None)
req_context = RequestContext(
html_obj=html_obj,
req=req,
resp=resp,
funnel=OutputFunnel(resp),
config_obj=make_config_object(get_default_config()),
user=LoggedInNobody(),
display_options=DisplayOptions(),
prefix_logs_with_url=False,
)
else:
app_context = contextlib.nullcontext()
req_context = contextlib.nullcontext()
with app_context, req_context, mock.patch(
"cmk.gui.sites._get_enabled_and_disabled_sites",
new=live.enabled_and_disabled_sites), mock.patch(
"livestatus.MultiSiteConnection.expect_query",
new=live.expect_query,
create=True), mock.patch(
"livestatus.SingleSiteConnection._create_socket",
new=live.create_socket), mock.patch.dict(
os.environ, {
"OMD_ROOT": "/",
"OMD_SITE": "NO_SITE"
}):
# We don't want to be polluted by other tests.
omd_site.cache_clear()
yield live
# We don't want to pollute other tests.
omd_site.cache_clear()
def test_verify_cookie_high_score(self):
config = self.config
self.headers['cookie'] = '_px3=bf46ceff75278ae166f376cbf741a7639060581035dd4e93641892c905dd0d67:EGFGcwQ2rum7KRmQCeSXBAUt1+25mj2DFJYi7KJkEliF3cBspdXtD2X03Csv8N8B6S5Bte/4ccCcETkBNDVxTw==:1000:x9x+oI6BISFhlKEERpf8HpZD2zXBCW9lzVfuRURHaAnbaMnpii+XjPEd7a7EGGUSMch5ramy3y+KOxyuX3F+LbGYwvn3OJb+u40zU+ixT1w5N15QltX+nBMhC7izC1l8QtgMuG/f3Nts5ebnec9j2V7LS5Y1/5b73rd9s7AMnug='
builder = EnvironBuilder(headers=self.headers)
env = builder.get_environ()
request = Request(env)
ctx = PxContext(request, PxConfig({'app_id': 'fake_app_id'}))
verified = px_cookie_validator.verify(ctx, config)
self.assertTrue(verified)
self.assertEqual('none', ctx.s2s_call_reason)
del self.headers['cookie']
def test_uri_from_info_request(self):
info_path = '/%s/%s' % (self.test_jp2_color_id, 'info.json')
# See http://werkzeug.pocoo.org/docs/test/#environment-building
builder = EnvironBuilder(path=info_path)
env = builder.get_environ()
req = Request(env)
base_uri, ident, params, request_type = self.app._dissect_uri(req)
expected = '/'.join((self.URI_BASE, self.test_jp2_color_id))
self.assertEqual(base_uri, expected)
def test_on_no_link_header(self):
client = Client(application)
builder = EnvironBuilder(path="/2016/http://www.espn.com",
headers=[("Prefer", "no_link_header")])
env = builder.get_environ()
app_iter, status, headers = client.run_wsgi_app(env)
assert "200" in status
assert not headers.get("Link")
assert headers.get("Memento-Datetime") is not None
def test_verify_no_cookie(self):
config = self.config
builder = EnvironBuilder(headers= self.headers)
env = builder.get_environ()
request = Request(env)
ctx = PxContext(request, PxConfig({'app_id': 'fake_app_id'}))
verified = px_cookie_validator.verify(ctx, config)
self.assertFalse(verified)
self.assertEqual('no_cookie', ctx.s2s_call_reason)
def test_authorization_raises_exception_if_user_is_not_valid(self):
"Should raise an Unauthorized exception if is_valid_user function returns False"
is_valid_mock = mock.MagicMock(return_value=False)
builder = EnvironBuilder()
request = Request(builder.get_environ())
request.authorization = {'username': '******', 'password': '******'}
with self.assertRaises(Unauthorized):
BasicAuth(is_valid_user=is_valid_mock).authenticate(request)
is_valid_mock.assert_called_once_with('john', 'xxx')
def test_authorization_raises_exception_if_authorization_is_not_set(self):
"Should raise an exception and the is_valid_user function should never be invoked"
is_valid_mock = mock.MagicMock(return_value=False)
builder = EnvironBuilder()
request = Request(builder.get_environ())
request.authorization = None
with self.assertRaises(Unauthorized):
BasicAuth(is_valid_user=is_valid_mock).authenticate(request)
self.assertEqual(is_valid_mock.call_count, 0)
def test_verify_whitelist(self):
config = PxConfig({
'app_id': 'PXfake_app_id',
'whitelist_routes': ['whitelisted']
})
builder = EnvironBuilder(headers=self.headers, path='/whitelisted')
env = builder.get_environ()
request = Request(env)
context = PxContext(request, config)
response = self.request_handler.verify_request(context, request)
self.assertEqual(response, True)
def test_get_data_ok_form():
fld_name = 'field'
fld_value = 'value'
builder = EnvironBuilder(path='/endpoint',
method='POST',
data={fld_name: fld_value})
env = builder.get_environ()
req = Request(env)
rv = req.get_data()
assert isinstance(rv, str)
assert rv == f'{fld_name}={fld_value}'
def test_is_hidden_field_empty_full(self):
"""
Tests is_hidden_field_empty with contents in 'last_name' field
is_hidden_field_empty checks that the last_name field in the form
is empty. This function call should return false.
"""
builder = EnvironBuilder(method='POST', data={'last_name': 'nope'})
env = builder.get_environ()
req = Request(env)
self.assertFalse(handler.is_hidden_field_empty(req))
def test_tg_200(self):
client = Client(application)
builder = EnvironBuilder(path="/tg/http://www.espn.com",
headers=[("Prefer", "tg_200")])
env = builder.get_environ()
app_iter, status, headers = client.run_wsgi_app(env)
assert "200" in status
assert headers.get("Link")
assert "accept-datetime" in headers.get("Vary", "")
assert headers.get("memento-datetime") is not None
def test_on_no_vary_header(self):
client = Client(application)
builder = EnvironBuilder(path="/tg/http://www.espn.com",
headers=[("Prefer", "no_vary_header")])
env = builder.get_environ()
app_iter, status, headers = client.run_wsgi_app(env)
assert "302" in status
assert headers.get("Link")
assert headers.get("Vary") is None
def test_valid(self):
csrf_token = FooForm().csrf_token.current_token
builder = EnvironBuilder(method='POST',
data={
'name': 'foo',
'csrf_token': csrf_token
})
env = builder.get_environ()
req = Request(env)
f = FooForm(req.form)
self.assertTrue(f.validate())
def test_delete_collaborator(self, mock_create_labbooks, property_mocks_fixture, snapshot,
docker_socket_fixture):
"""Test deleting a collaborator from a LabBook"""
# Setup REST mocks
responses.add(responses.GET, 'https://repo.gigantum.io/api/v4/users?username=person100',
json=[
{
"id": 100,
"name": "New Person",
"username": "******",
"state": "active",
}
],
status=200)
responses.add(responses.DELETE, 'https://repo.gigantum.io/api/v4/projects/default%2Flabbook1/members/100',
status=204)
responses.add(responses.GET, 'https://repo.gigantum.io/api/v4/projects/default%2Flabbook1',
json=[{
"id": 27,
"description": "",
}],
status=200)
responses.add(responses.GET, 'https://repo.gigantum.io/api/v4/projects/default%2Flabbook1/members',
json=[
{
"id": 29,
"name": "Jane Doe",
"username": "******",
"access_level": 40,
"expires_at": None
}
],
status=200)
# Mock the request context so a fake authorization header is present
builder = EnvironBuilder(path='/labbook', method='DELETE', headers={'Authorization': 'Bearer AJDFHASD'})
env = builder.get_environ()
req = Request(environ=env)
query = """
mutation DeleteCollaborator {
deleteCollaborator(
input: {
owner: "default",
labbookName: "labbook1",
username: "******"
}) {
updatedLabbook {
collaborators
}
}
}
"""
snapshot.assert_match(mock_create_labbooks[2].execute(query, context_value=req))
def test_is_json_response(self):
px_blocker = PXBlocker()
builder = EnvironBuilder(headers=self.headers,
path='/fake_app_id/init.js')
env = builder.get_environ()
request = Request(env)
context = PxContext(request, self.config)
self.assertFalse(px_blocker.is_json_response(context))
context.headers['Accept'] = 'application/json'
self.assertTrue(px_blocker.is_json_response(context))
def test_callback_view_with_jwt(self, mock_wp, mock_os):
"""Test that the notification callback view works with JWT."""
mock_os.path.isfile.return_value = True
hass = MagicMock()
data = {
'device': SUBSCRIPTION_1,
}
m = mock_open(read_data=json.dumps(data))
with patch('homeassistant.components.notify.html5.open',
m,
create=True):
hass.config.path.return_value = 'file.conf'
service = html5.get_service(hass, {'gcm_sender_id': '100'})
assert service is not None
# assert hass.called
assert len(hass.mock_calls) == 3
service.send_message('Hello',
target=['device'],
data={'icon': 'beer.png'})
assert len(mock_wp.mock_calls) == 2
# WebPusher constructor
assert mock_wp.mock_calls[0][1][0] == \
SUBSCRIPTION_1['subscription']
# Call to send
push_payload = json.loads(mock_wp.mock_calls[1][1][0])
assert push_payload['body'] == 'Hello'
assert push_payload['icon'] == 'beer.png'
view = hass.mock_calls[2][1][0]
view.registrations = data
bearer_token = "Bearer {}".format(push_payload['data']['jwt'])
builder = EnvironBuilder(method='POST',
data=json.dumps({
'type': 'push',
}),
headers={'Authorization': bearer_token})
Request = request_class()
resp = view.post(Request(builder.get_environ()))
assert resp.status_code == 200, resp.response
returned = resp.response[0].decode('utf-8')
expected = '{"event": "push", "status": "ok"}'
assert json.loads(returned) == json.loads(expected)
