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)