def setUpClass(cls): cls.db = db() cls.app = TestApp(build_app().wsgifunc()) syncdb()
def test_index(self): middleware = [] testApp = TestApp(app.wsgifunc(*middleware)) r = testApp.get('/') assert_equal(r.status, 200) r.mustcontain('Hello, World!')
def setUp(self): self.headers = getDefaultHTTPHeaders(YOMP.app.config) self.app = TestApp(settings_api.app.wsgifunc())
def setUp(self): TestWSGIController.setUp(self) app = SetupCacheGlobal(ControllerWrap(ValidatingController), self.environ) app = RegistryManager(app) self.app = TestApp(app)
def setUpClass(cls): """ Setup steps for all test cases. Focus for these is to cover all API checks for ModelDataHandler. Hence, this does all setup creating metric, waiting for metricData across all testcases, all API call for querying metricData will be against single metric created in setup Setup Process 1) Update conf with aws credentials, ManagedTempRepository will not work in this test 2) Select test instance such that its running from longer time, We are using instance older than 15 days 3) Create Metric, wait for min metricData rows to become available Set to 100, configurable 4) Pick testRowId, set it lower value this will make sure to have Non NULL value for anomaly_score field for given row while invoking GET with consitions, set to 5 5) Decide queryParams for anomalyScore, to and from timestamp """ cls.headers = getDefaultHTTPHeaders(grok.app.config) # All other sevices needs AWS credentials to work # Set AWS credentials grok.app.config.loadConfig() # Select test instance such that its running from longer time g_logger.info("Getting long-running EC2 Instances") instances = aws_utils.getLongRunningEC2Instances( "us-west-2", grok.app.config.get("aws", "aws_access_key_id"), grok.app.config.get("aws", "aws_secret_access_key"), 15) testInstance = instances[randrange(1, len(instances))] createModelData = { "region": "us-west-2", "namespace": "AWS/EC2", "datasource": "cloudwatch", "metric": "CPUUtilization", "dimensions": { "InstanceId": testInstance.id } } # Number of minimum rows cls.minDataRows = 100 cls.app = TestApp(models_api.app.wsgifunc()) # create test metric g_logger.info("Creating test metric; modelSpec=%s", createModelData) response = cls.app.put("/", utils.jsonEncode(createModelData), headers=cls.headers) postResult = utils.jsonDecode(response.body) maxWaitTime = 600 waitTimeMetricData = 0 waitAnomalyScore = 0 # Wait for enough metric data to be available cls.uid = postResult[0]["uid"] engine = repository.engineFactory() with engine.connect() as conn: cls.metricData = [ row for row in repository.getMetricData(conn, cls.uid) ] with engine.connect() as conn: cls.testMetric = repository.getMetric(conn, cls.uid) # Confirm that we have enough metricData g_logger.info("Waiting for metric data") while (len(cls.metricData) < cls.minDataRows and waitTimeMetricData < maxWaitTime): g_logger.info( "not ready, waiting for metric data: got %d of %d ...", len(cls.metricData), cls.minDataRows) time.sleep(5) waitTimeMetricData += 5 with engine.connect() as conn: cls.metricData = [ row for row in repository.getMetricData(conn, cls.uid) ] # taking lower value for testRowId, this will make sure to have # Non NULL value for anomaly_score field for given row cls.testRowId = 5 with engine.connect() as conn: cls.testMetricRow = (repository.getMetricData( conn, cls.uid, rowid=cls.testRowId).fetchone()) # Make sure we did not receive None etc for anomaly score g_logger.info("cls.testMetricRow.anomaly_score=%r", cls.testMetricRow.anomaly_score) g_logger.info("waitAnomalyScore=%r", waitAnomalyScore) while (cls.testMetricRow.anomaly_score is None and waitAnomalyScore < maxWaitTime): g_logger.info("anomaly_score not ready, sleeping...") time.sleep(5) waitAnomalyScore += 5 with engine.connect() as conn: cls.testMetricRow = (repository.getMetricData( conn, cls.uid, rowid=cls.testRowId).fetchone()) # Decide queryParams for anomalyScore, to and from timestamp cls.testAnomalyScore = cls.testMetricRow.anomaly_score cls.testTimeStamp = cls.testMetricRow.timestamp
def test_create_and_list_subscription_by_id(self): """ SUBSCRIPTION (REST): Test the creation of a new subscription and get by subscription id """ mw = [] headers1 = { 'X-Rucio-Account': 'root', 'X-Rucio-Username': '******', 'X-Rucio-Password': '******' } headers1.update(self.vo_header) res1 = TestApp(auth_app.wsgifunc(*mw)).get('/userpass', headers=headers1, expect_errors=True) assert_equal(res1.status, 200) token = str(res1.header('X-Rucio-Auth-Token')) subscription_name = uuid() headers2 = {'X-Rucio-Auth-Token': str(token)} data = dumps({ 'options': { 'filter': { 'project': self.projects, 'datatype': [ 'AOD', ], 'excluded_pattern': self.pattern1, 'account': [ 'tier0', ] }, 'replication_rules': [{ 'lifetime': 86400, 'rse_expression': 'MOCK|MOCK2', 'copies': 2, 'activity': 'Data Brokering' }], 'lifetime': 100000, 'retroactive': 0, 'dry_run': 0, 'comments': 'blahblah' } }) res2 = TestApp(subs_app.wsgifunc(*mw)).post('/root/%s' % (subscription_name), headers=headers2, params=data, expect_errors=True) assert_equal(res2.status, 201) subscription_id = res2.body res3 = TestApp(subs_app.wsgifunc(*mw)).get('/Id/%s' % (subscription_id), headers=headers2, expect_errors=True) assert_equal(res3.status, 200) assert_equal( loads(loads(res3.body)['filter'])['project'][0], 'data12_900GeV')
def test_list_rules_states(self): """ SUBSCRIPTION (REST): Test listing of rule states for subscription """ tmp_scope = InternalScope('mock_' + uuid()[:8], **self.vo) root = InternalAccount('root', **self.vo) add_scope(tmp_scope, root) mw = [] site_a = 'RSE%s' % uuid().upper() site_b = 'RSE%s' % uuid().upper() site_a_id = add_rse(site_a, **self.vo) site_b_id = add_rse(site_b, **self.vo) # Add quota set_account_limit(root, site_a_id, -1) set_account_limit(root, site_b_id, -1) # add a new dataset dsn = 'dataset-%s' % uuid() add_did(scope=tmp_scope, name=dsn, type=DIDType.DATASET, account=root) subscription_name = uuid() subid = add_subscription(name=subscription_name, account='root', filter={ 'account': [ 'root', ], 'scope': [ tmp_scope.external, ] }, replication_rules=[{ 'lifetime': 86400, 'rse_expression': 'MOCK|MOCK2', 'copies': 2, 'activity': 'Data Brokering' }], lifetime=100000, retroactive=0, dry_run=0, comments='We want a shrubbery', issuer='root', **self.vo) # Add two rules add_rule(dids=[{ 'scope': tmp_scope, 'name': dsn }], account=root, copies=1, rse_expression=site_a, grouping='NONE', weight=None, lifetime=None, locked=False, subscription_id=subid) add_rule(dids=[{ 'scope': tmp_scope, 'name': dsn }], account=root, copies=1, rse_expression=site_b, grouping='NONE', weight=None, lifetime=None, locked=False, subscription_id=subid) headers1 = { 'X-Rucio-Account': 'root', 'X-Rucio-Username': '******', 'X-Rucio-Password': '******' } headers1.update(self.vo_header) res1 = TestApp(auth_app.wsgifunc(*mw)).get('/userpass', headers=headers1, expect_errors=True) assert_equal(res1.status, 200) token = str(res1.header('X-Rucio-Auth-Token')) headers2 = {'X-Rucio-Auth-Token': str(token)} res2 = TestApp(subs_app.wsgifunc(*mw)).get('/%s/%s/Rules/States' % ('root', subscription_name), headers=headers2, expect_errors=True) for line in res2.body.split('\n'): print(line) rs = loads(line) if rs[1] == subscription_name: break assert_equal(rs[3], 2)
def setUp(self): middleware = [] self.testApp = TestApp(app.wsgifunc(*middleware))
def test_location_get(self): middleware = [] testApp = TestApp(app.wsgifunc(*middleware)) r = testApp.get('/location') assert_equal(r.status, 200) r.mustcontain('hello world!')
def setUpLoggerhead(self, **kw): branch_app = BranchWSGIApp(self.tree.branch, '', **kw).app return TestApp(HTTPExceptionHandler(branch_app))
def setUp(self): super(TestWSGICombo, self).setUp() self.root = self.makeDir() self.app = TestApp(combo_app(self.root))
def test_view_folder(self): app = TestApp(BranchWSGIApp(self.tree.branch, '').app) e = self.assertRaises(HTTPMovedPermanently, app.get, '/view/head:/folder') self.assertEqual(e.location(), '/files/head:/folder')
def setUpClass(cls): cls.app = TestApp(models_api.app.wsgifunc())
def test_redirect_metalink_list_replicas(self): """ ROOT (REDIRECT REST): Test internal proxy prepend with metalink""" mw = [] # default behaviour - no location -> no proxy res = TestApp(redirect_app.wsgifunc(*mw)).get( '/mock/half-life_1/metalink', expect_errors=True) body = res.body.decode() assert_in( 'root://root.blackmesa.com:1409//training/facility/mock/c9/df/half-life_1', body) assert_in( 'root://root.aperture.com:1409//test/chamber/mock/c9/df/half-life_1', body) assert_not_in('proxy', body) res = TestApp(redirect_app.wsgifunc(*mw)).get( '/mock/half-life_2/metalink', expect_errors=True) body = res.body.decode() assert_in( 'root://root.blackmesa.com:1409//training/facility/mock/c1/8d/half-life_2', body) assert_in( 'root://root.aperture.com:1409//test/chamber/mock/c1/8d/half-life_2', body) assert_not_in('proxy', body) res = TestApp(redirect_app.wsgifunc(*mw)).get( '/mock/half-life_3/metalink', expect_errors=True) body = res.body.decode() assert_in( 'root://root.blackmesa.com:1409//training/facility/mock/16/30/half-life_3', body) assert_in( 'root://root.aperture.com:1409//test/chamber/mock/16/30/half-life_3', body) assert_not_in('proxy', body) # site without proxy res = TestApp(redirect_app.wsgifunc(*mw)).get( '/mock/half-life_1/metalink?%s' % urlencode(self.client_location_without_proxy), expect_errors=True) body = res.body.decode() assert_in( 'root://root.blackmesa.com:1409//training/facility/mock/c9/df/half-life_1', body) assert_in( 'root://root.aperture.com:1409//test/chamber/mock/c9/df/half-life_1', body) assert_not_in('proxy', body) res = TestApp(redirect_app.wsgifunc(*mw)).get( '/mock/half-life_2/metalink?%s' % urlencode(self.client_location_without_proxy), expect_errors=True) body = res.body.decode() assert_in( 'root://root.blackmesa.com:1409//training/facility/mock/c1/8d/half-life_2', body) assert_in( 'root://root.aperture.com:1409//test/chamber/mock/c1/8d/half-life_2', body) assert_not_in('proxy', body) res = TestApp(redirect_app.wsgifunc(*mw)).get( '/mock/half-life_3/metalink?%s' % urlencode(self.client_location_without_proxy), expect_errors=True) body = res.body.decode() assert_in( 'root://root.blackmesa.com:1409//training/facility/mock/16/30/half-life_3', res) assert_in( 'root://root.aperture.com:1409//test/chamber/mock/16/30/half-life_3', res) assert_not_in('proxy', res) # at location with outgoing proxy, prepend for wan replica res = TestApp(redirect_app.wsgifunc(*mw)).get( '/mock/half-life_1/metalink?%s' % urlencode(self.client_location_with_proxy), expect_errors=True) body = res.body.decode() assert_in( 'root://proxy.aperture.com:1094//root://root.blackmesa.com:1409//training/facility/mock/c9/df/half-life_1', body) assert_in( 'root://root.aperture.com:1409//test/chamber/mock/c9/df/half-life_1', body) res = TestApp(redirect_app.wsgifunc(*mw)).get( '/mock/half-life_2/metalink?%s' % urlencode(self.client_location_with_proxy), expect_errors=True) body = res.body.decode() assert_in( 'root://proxy.aperture.com:1094//root://root.blackmesa.com:1409//training/facility/mock/c1/8d/half-life_2', body) assert_in( 'root://root.aperture.com:1409//test/chamber/mock/c1/8d/half-life_2', body) res = TestApp(redirect_app.wsgifunc(*mw)).get( '/mock/half-life_3/metalink?%s' % urlencode(self.client_location_with_proxy), expect_errors=True) body = res.body.decode() assert_in( 'root://proxy.aperture.com:1094//root://root.blackmesa.com:1409//training/facility/mock/16/30/half-life_3', body) assert_in( 'root://root.aperture.com:1409//test/chamber/mock/16/30/half-life_3', body)
def test_error(): wrapped = ConfigMiddleware(app_with_exception, {'test': 1}) test_app = TestApp(wrapped) assert_raises(Bug, test_app.get, '/')
def get(self, server, url, request_method='GET', expect_errors=False): a = TestApp(server._wsgi_func) response = a.get(url, expect_errors=expect_errors) return self._respond(response, expect_errors)
def get_app(): return TestApp('config:%s' % INI)
def setUp(self): self.app = TestApp(models_api.app.wsgifunc()) self.headers = getDefaultHTTPHeaders(grok.app.config) data = open(os.path.join(grok.app.GROK_HOME, "tests/py/data/app/webservices/models_api_integration_test.json")).read() self.modelsTestData = json.loads(data)
def test_create_existing_subscription(self): """ SUBSCRIPTION (REST): Test the creation of a existing subscription """ mw = [] headers1 = { 'X-Rucio-Account': 'root', 'X-Rucio-Username': '******', 'X-Rucio-Password': '******' } headers1.update(self.vo_header) res1 = TestApp(auth_app.wsgifunc(*mw)).get('/userpass', headers=headers1, expect_errors=True) assert_equal(res1.status, 200) token = str(res1.header('X-Rucio-Auth-Token')) subscription_name = uuid() headers2 = {'X-Rucio-Auth-Token': str(token)} data = dumps({ 'options': { 'name': subscription_name, 'filter': { 'project': self.projects, 'datatype': [ 'AOD', ], 'excluded_pattern': self.pattern1, 'account': [ 'tier0', ] }, 'replication_rules': [{ 'lifetime': 86400, 'rse_expression': 'MOCK|MOCK2', 'copies': 2, 'activity': 'Data Brokering' }], 'lifetime': 100000, 'retroactive': 0, 'dry_run': 0, 'comments': 'We are the knights who say Ni !' } }) res2 = TestApp(subs_app.wsgifunc(*mw)).post('/root/' + subscription_name, headers=headers2, params=data, expect_errors=True) assert_equal(res2.status, 201) res3 = TestApp(subs_app.wsgifunc(*mw)).post('/root/' + subscription_name, headers=headers2, params=data, expect_errors=True) assert_equal(res3.header('ExceptionClass'), 'SubscriptionDuplicate') assert_equal(res3.status, 409)
def setUp(self): #self.headers = getDefaultHTTPHeaders(htm.it.app.config) self.app = TestApp(webapp.app.wsgifunc())
def setUp(self): self.headers = getDefaultHTTPHeaders(grok.app.config) self.app = TestApp(metrics_api.app.wsgifunc())
def test_notfound(self): middleware = [] testApp = TestApp(app.wsgifunc(*middleware)) r = testApp.get('/storage/test', status="*") self.assertEqual(r.status, 404)
def setUp(self): wsgi_app = self._makeWsgiDAVApp(False) self.app = TestApp(wsgi_app)
def test_bad_json(self): return ["this is neat"] test_bad_json = jsonify(test_bad_json) def test_good_json(self): return dict(fred=42) test_good_json = jsonify(test_good_json) environ = {} app = ControllerWrap(CacheController) app = sap = SetupCacheGlobal(app, environ) app = RegistryManager(app) app = TestApp(app) class TestJsonifyDecorator(TestWSGIController): def setUp(self): self.app = app TestWSGIController.setUp(self) environ.update(self.environ) warnings.simplefilter('error', Warning) def tearDown(self): warnings.simplefilter('always', Warning) def test_bad_json(self): try: response = self.get_response(action='test_bad_json')
op = OptionParser( "%prog [-h] [...] ENDPOINT_URL BASEDIR") op.add_option('-p', '--port', type=int, default=7070, help="Port to serve as web app.") op.add_option('-l', '--default-locale', default="en") op.add_option('-o', '--one-off-url', default=None, help="Process given url once and print to stdout (" "doesn't start server).") opts, args = op.parse_args() if len(args) != 2: op.print_usage() op.exit() endpoint_url = args[0] basedir = args[1] once_url = opts.one_off_url access = discover_access(endpoint_url) app = WebApp(access, opts.default_locale, basedir) if once_url: from paste.fixture import TestApp print TestApp(app).get(once_url) else: logging.basicConfig(level=logging.INFO) serve_wsgi(app, port=opts.port)
from paste.fixture import TestApp from paste.gzipper import middleware import gzip import six def simple_app(environ, start_response): start_response('200 OK', [('content-type', 'text/plain'), ('content-length', '0')]) return [b'this is a test'] if environ['REQUEST_METHOD'] != 'HEAD' else [] wsgi_app = middleware(simple_app) app = TestApp(wsgi_app) def test_gzip(): res = app.get('/', extra_environ=dict(HTTP_ACCEPT_ENCODING='gzip')) assert int(res.header('content-length')) == len(res.body) assert res.body != b'this is a test' actual = gzip.GzipFile(fileobj=six.BytesIO(res.body)).read() assert actual == b'this is a test' def test_gzip_head(): res = app.head('/', extra_environ=dict(HTTP_ACCEPT_ENCODING='gzip')) assert int(res.header('content-length')) == 0 assert res.body == b''
def client(self): return TestApp(self.app.wsgifunc())
def test_PUT(self): middleware = [] testApp = TestApp(app.wsgifunc(*middleware)) # Return 200 OK for putting a valid setting r = testApp.put('/thermostats/100/cool_setPoint', params=json.dumps(cool_setPoint)) json_data = json.loads(r.body) assert_equal(r.status, 200) assert_equal(json_data, thermostat_cool_set) # Return 403 forbidden for assigning string for int value r = testApp.put('/thermostats/100/id', params=json.dumps(cool_setPoint_string), status="*") assert_equal(r.status, 403) r.mustcontain('forbidden') # Return 403 forbidden for read only setting r = testApp.put('/thermostats/100/id', params=json.dumps(new_id), status="*") assert_equal(r.status, 403) r.mustcontain('forbidden') # Return 400 bad request if put is attempted without a specific setting r = testApp.put('/thermostats/100', params=json.dumps(new_id), status="*") assert_equal(r.status, 400) r.mustcontain('bad request') # Return 400 bad request for non-existent setting r = testApp.put('/thermostats/100/clock_display', params=json.dumps(new_temp), status="*") assert_equal(r.status, 400) r.mustcontain('bad request') # Return 400 bad request for setting values higher than bounds r = testApp.put('/thermostats/100/cool_setPoint', params=json.dumps(high_temp), status="*") assert_equal(r.status, 400) r.mustcontain('bad request') # Return 400 bad request for setting values lower than bounds r = testApp.put('/thermostats/100/cool_setPoint', params=json.dumps(low_temp), status="*") assert_equal(r.status, 400) r.mustcontain('bad request') # Return 400 bad request for setting values out of scope r = testApp.put('/thermostats/100/operating_mode', params=json.dumps(operating_mode), status="*") assert_equal(r.status, 400) r.mustcontain('bad request') # Return 404 for non-existent thermostat r = testApp.put('/thermostats/108/cool_setPoint', params=json.dumps(cool_setPoint), status="*") assert_equal(r.status, 404) r.mustcontain('not found')
def setUp(self): self.app = TestApp(instances_api.app.wsgifunc()) self.headers = getDefaultHTTPHeaders(config)
def setUp(self): self.test_app = TestApp(core.federer.app.wsgifunc()) self.fixtures_path = 'core/tests/fixtures/' self.event_store = EventStore()