def test_tiingo_no_api_key(symbols): from test.support import EnvironmentVarGuard env = EnvironmentVarGuard() env.unset('TIINGO_API_KEY') with env: with pytest.raises(ValueError): TiingoMetaDataReader(symbols=symbols)
def test_proxy_with_kwargs(self): env = EnvironmentVarGuard() env.unset('KAGGLE_USER_SECRETS_TOKEN') with env: client = bigquery.Client( default_query_job_config=bigquery.QueryJobConfig(maximum_bytes_billed=1e9)) self._test_proxy(client, should_use_proxy=True)
def test_proxy_with_kwargs(self): env = EnvironmentVarGuard() env.unset('KAGGLE_USER_SECRETS_TOKEN') with env: client = bigquery.Client( default_query_job_config=bigquery.QueryJobConfig(maximum_bytes_billed=int(1e9))) self._test_proxy(client)
def test_monkeypatching_idempotent(self): env = EnvironmentVarGuard() env.unset('KAGGLE_USER_SECRETS_TOKEN') with env: client1 = bigquery.Client init_bigquery() client2 = bigquery.Client self.assertEqual(client1, client2)
def test_proxy_with_kwargs(self): env = EnvironmentVarGuard() env.unset('KAGGLE_BQ_USER_JWT') with env: client = bigquery.Client( default_query_job_config=bigquery.QueryJobConfig( maximum_bytes_billed=1e9)) self._test_proxy(client, should_use_proxy=True)
def test_aud_claim(self): """Test aud claim function.""" env = EnvironmentVarGuard() env.set("JWT_AUD", "aud1,aud2") result = verify_aud_claim() # Because it is false we expect it not to be parsed expected = (False, []) self.assertEqual(result, expected) env.unset("JWT_AUD")
class TrustedIdentityTestCase(TestCase): shared_secret = "ImaSecret" def setUp(self): self.env = EnvironmentVarGuard() self.env.set(SHARED_SECRET_ENV_VAR, self.shared_secret) def _build_id(self): identity = from_bearer_token(self.shared_secret) return identity def test_validation(self): identity = self._build_id() with self.env: validate(identity) def test_validation_with_invalid_identity(self): identity = from_bearer_token("InvalidPassword") with self.assertRaises(ValueError): validate(identity) def test_validation_env_var_not_set(self): identity = self._build_id() self.env.unset(SHARED_SECRET_ENV_VAR) with self.env: with self.assertRaises(ValueError): validate(identity) def test_validation_token_is_None(self): tokens = [None, ""] for token in tokens: with self.subTest(token_value=token): with self.assertRaises(ValueError): Identity(token=token) def test_is_trusted_system(self): identity = self._build_id() self.assertEqual(identity.is_trusted_system, True) def test_account_number_is_not_set_for_trusted_system(self): identity = self._build_id() self.assertEqual(identity.account_number, None)
class TestBasicFunctionsKeyserver(unittest.TestCase): """Keyserver Base. Testing basic functions from keyserver. """ def setUp(self): """Initialise fixtures.""" self.env = EnvironmentVarGuard() self.env.set('LEGA_PASSWORD', 'value') self.env.set('KEYS_PASSWORD', 'value') def tearDown(self): """Remove setup variables.""" self.env.unset('LEGA_PASSWORD') self.env.unset('KEYS_PASSWORD') @tempdir() @mock.patch('lega.keyserver._cache') def test_unlock_key_public_error(self, mock_cache, filedir): """Trying to unlock public key should return assertion error.""" pub_keyfile = filedir.write('pub_key.asc', pgp_data.PGP_PUBKEY.encode('utf-8')) with self.env: mock_cache.return_value = Cache() with self.assertRaises(AssertionError): _unlock_key(pgp_data.PGP_NAME, path=pub_keyfile) filedir.cleanup() @tempdir() @mock.patch('lega.keyserver._active') @mock.patch('lega.keyserver._cache') def test_unlock_key_private(self, mock_cache, mock_active, filedir): """Trying to unlock private key.""" pub_keyfile = filedir.write('pub_key.asc', pgp_data.PGP_PRIVKEY.encode('utf-8')) with self.env: mock_cache.return_value = Cache() _unlock_key(pgp_data.PGP_NAME, path=pub_keyfile, passphrase=pgp_data.PGP_PASSPHRASE) mock_cache.set.assert_called() filedir.cleanup()
class TestFileStorage(unittest.TestCase): """FileStorage. Testing storage on disk. """ def setUp(self): """Initialise fixtures.""" self._dir = TempDirectory() self.outputdir = self._dir.makedir('output') self.env = EnvironmentVarGuard() self.env.set('ARCHIVE_LOCATION', self.outputdir + '/%s/') self._store = FileStorage('archive', 'lega') def tearDown(self): """Remove setup variables.""" self.env.unset('ARCHIVE_LOCATION') self._dir.cleanup_all() def test_location(self): """Test file location.""" result = self._store.location('12') self.assertEqual( os.path.join('/', '000', '000', '000', '000', '000', '000', '12'), result) def test_copy(self): """Test copy file.""" path = self._dir.write('output/lega/test.file', 'data1'.encode('utf-8')) path1 = self._dir.write('output/lega/test1.file', ''.encode('utf-8')) result = self._store.copy(open(path, 'rb'), path1) self.assertEqual(os.stat(path).st_size, result) def test_open(self): """Test open file.""" path = self._dir.write('output/lega/test.file', 'data1'.encode('utf-8')) print(path) with self._store.open('test.file') as resource: self.assertEqual(BufferedReader, type(resource))
class TestS3Storage(unittest.TestCase): """S3Storage. Testing storage on S3 solution. """ def setUp(self): """Initialise fixtures.""" self._dir = TempDirectory() self.env = EnvironmentVarGuard() self.env.set('ARCHIVE_S3_URL', 'http://*****:*****@mock.patch.object(boto3, 'client') def test_init_s3storage(self, mock_boto): """Initialise S3 storage.""" S3Storage('archive', 'lega') mock_boto.assert_called() @mock.patch.object(boto3, 'client') def test_init_location(self, mock_boto): """Initialise S3 storage.""" storage = S3Storage('archive', 'lega') result = storage.location('file_id') self.assertEqual('file_id', result) mock_boto.assert_called() @mock.patch.object(boto3, 'client') def test_upload(self, mock_boto): """Test copy to S3, should call boto3 client.""" path = self._dir.write('test.file', 'data1'.encode('utf-8')) storage = S3Storage('archive', 'lega') storage.copy(path, 'lega') mock_boto.assert_called_with('s3', aws_access_key_id='test', aws_secret_access_key='test', endpoint_url='http://*****:*****@mock.patch.object(boto3, 'client') def test_open(self, mock_boto): """Test open , should call S3FileReader.""" path = self._dir.write('test.file', 'data1'.encode('utf-8')) storage = S3Storage('archive', 'lega') with storage.open(path) as resource: self.assertEqual(S3FileReader, type(resource))
class AppTestCaseForbidden(AioHTTPTestCase): """Test for Web app 403. Testing web app for wrong issuer. """ @asynctest.mock.patch('beacon_api.app.initialize', side_effect=create_db_mock) async def get_application(self, pool_mock): """Retrieve web Application for test.""" token, public_key = generate_token('something') self.env = EnvironmentVarGuard() self.env.set('PUBLIC_KEY', json.dumps(public_key)) self.env.set('TOKEN', token) return await init() @unittest_run_loop async def tearDown(self): """Finish up tests.""" self.env.unset('PUBLIC_KEY') self.env.unset('TOKEN') await caches.get('default').delete("jwk_key") @asynctest.mock.patch('beacon_api.app.parse_request_object', side_effect=mock_parse_request_object) @asynctest.mock.patch('beacon_api.app.query_request_handler', side_effect=json.dumps(PARAMS)) @unittest_run_loop async def test_forbidden_token_get_query(self, mock_handler, mock_object): """Test forbidden GET query endpoint, invalid scheme.""" token = os.environ.get('TOKEN') resp = await self.client.request( "POST", "/query", data=json.dumps(PARAMS), headers={'Authorization': f"Bearer {token}"}) assert 403 == resp.status
class testVerify(unittest.TestCase): """Verify. Testing verify functionalities. """ def setUp(self): """Initialise fixtures.""" self.env = EnvironmentVarGuard() self._dir = TempDirectory() self.outputdir = self._dir.makedir('output') self.env = EnvironmentVarGuard() self.env.set('ARCHIVE_LOCATION', self.outputdir + '/%s/') self.env.set('LEGA_PASSWORD', 'value') self.env.set('QUALITY_CONTROL_VERIFY_PEER', 'True') self.env.set('QUALITY_CONTROL_VERIFY_HOSTNAME', 'False') def tearDown(self): """Remove setup variables.""" self.env.unset('ARCHIVE_LOCATION') self._dir.cleanup_all() self.env.unset('LEGA_PASSWORD') self.env.unset('QUALITY_CONTROL_VERIFY_PEER') self.env.unset('QUALITY_CONTROL_VERIFY_HOSTNAME') @tempdir() @mock.patch('lega.verify.header_to_records') @mock.patch('lega.verify.get_key_id') def test_get_records(self, mock_key, mock_records, filedir): """Should call the url in order to provide the records.""" infile = filedir.write('infile.in', bytearray.fromhex(pgp_data.ENC_FILE)) returned_data = KeyServerResponse( 200, io.BytesIO(pgp_data.PGP_PRIVKEY.encode())) with PatchContextManager('lega.verify.urlopen', returned_data) as mocked: print(returned_data.status) with open(infile, 'rb') as f: get_records(f) mocked.assert_called() filedir.cleanup() @tempdir() @mock.patch('lega.verify.header_to_records') @mock.patch('lega.verify.get_key_id') def test_get_records_no_verify(self, mock_key, mock_records, filedir): """Should call the url in order to provide the records even without a verify turned off.""" self.env.set('QUALITY_CONTROL_VERIFY_PEER', 'False') self.env.set('QUALITY_CONTROL_VERIFY_HOSTNAME', 'False') infile = filedir.write('infile.in', bytearray.fromhex(pgp_data.ENC_FILE)) returned_data = KeyServerResponse( 200, io.BytesIO(pgp_data.PGP_PRIVKEY.encode())) with PatchContextManager('lega.verify.urlopen', returned_data) as mocked: with open(infile, 'rb') as f: get_records(f) mocked.assert_called() filedir.cleanup() @tempdir() @mock.patch('lega.verify.header_to_records') @mock.patch('lega.verify.get_key_id') def test_get_records_key_error(self, mock_key, mock_records, filedir): """The PGP key was not found, should raise PGPKeyError error.""" infile = filedir.write('infile.in', bytearray.fromhex(pgp_data.ENC_FILE)) with mock.patch('lega.verify.urlopen') as urlopen_mock: urlopen_mock.side_effect = HTTPError('url', 404, 'msg', None, None) with self.assertRaises(PGPKeyError): with open(infile, 'rb') as f: get_records(f) filedir.cleanup() @tempdir() @mock.patch('lega.verify.header_to_records') @mock.patch('lega.verify.get_key_id') def test_get_records_server_error(self, mock_key, mock_records, filedir): """Some keyserver error occured, should raise KeyserverError error.""" infile = filedir.write('infile.in', bytearray.fromhex(pgp_data.ENC_FILE)) with mock.patch('lega.verify.urlopen') as urlopen_mock: urlopen_mock.side_effect = HTTPError('url', 400, 'msg', None, None) with self.assertRaises(KeyserverError): with open(infile, 'rb') as f: get_records(f) filedir.cleanup() @tempdir() @mock.patch('lega.verify.header_to_records') @mock.patch('lega.verify.get_key_id') def test_get_records_error(self, mock_key, mock_records, filedir): """Some general error occured, should raise Exception error.""" self.env.set('QUALITY_CONTROL_VERIFY_PEER', 'False') self.env.set('QUALITY_CONTROL_VERIFY_HOSTNAME', 'False') infile = filedir.write('infile.in', bytearray.fromhex(pgp_data.ENC_FILE)) with mock.patch('lega.verify.urlopen') as urlopen_mock: urlopen_mock.side_effect = Exception with self.assertRaises(Exception): with open(infile, 'rb') as f: get_records(f) filedir.cleanup() @mock.patch('lega.ingest.getattr') @mock.patch('lega.verify.get_connection') @mock.patch('lega.verify.consume') def test_main(self, mock_consume, mock_connection, mock_getattr): """Test main verify, by mocking cosume call.""" mock_consume.return_value = mock.MagicMock() main() mock_consume.assert_called() @tempdir() @mock.patch('lega.verify.db') @mock.patch('lega.verify.body_decrypt') @mock.patch('lega.verify.get_records') def test_work(self, mock_records, mock_decrypt, mock_db, filedir): """Test verify worker, should send a messge.""" # Mocking a lot of stuff, ast it is previously tested mock_db.status.return_value = mock.Mock() mock_records.return_value = ['data'], 'key_id' mock_decrypt.return_value = mock.Mock() store = mock.MagicMock() store.open.return_value = mock.MagicMock() mock_broker = mock.MagicMock(name='channel') mock_broker.channel.return_value = mock.Mock() infile = filedir.write('infile.in', 'text'.encode("utf-8")) data = { 'header': pgp_data.ENC_FILE, 'stable_id': '1', 'archive_path': infile, 'file_id': '123', 'org_msg': {} } result = work('10', store, mock_broker, data) self.assertTrue({'status': { 'state': 'COMPLETED', 'details': '1' }}, result) filedir.cleanup()
class CacheTestCase(unittest.TestCase): """KeyServer Cache. Testing in memory cache. """ def setUp(self): """Initialise fixtures.""" self.FMT = '%d/%b/%y %H:%M:%S' self.env = EnvironmentVarGuard() self.env.set('LEGA_PASSWORD', 'value') self.env.set('KEYS_PASSWORD', 'value') self._key, _ = pgpy.PGPKey.from_blob(pgp_data.PGP_PRIVKEY) with self.env: self._cache = Cache() def tearDown(self): """Remove setup variables.""" self.env.unset('LEGA_PASSWORD') self.env.unset('KEYS_PASSWORD') def test_clear(self): """Test clearing Cache, should return empty cache.""" with self._key.unlock(pgp_data.PGP_PASSPHRASE) as privkey: self._cache.set('test_key', privkey) self._cache.clear() self.assertEqual(self._cache.get('test_key', 'private'), None) def test_key_expired(self): """Setting key expired, should make key invisible in cache.""" with self._key.unlock(pgp_data.PGP_PASSPHRASE) as privkey: self._cache.set('test_key', privkey, "30/MAR/00 08:00:00") self.assertEqual(self._cache.get('test_key', 'private'), None) self._cache.clear() def test_set_value(self): """Retrived cached Value, should return the proper cached value.""" with self._key.unlock(pgp_data.PGP_PASSPHRASE) as privkey: self._cache.set('test_key', privkey) self.assertEqual( self._cache.get('test_key', 'public').hex(), pgp_data.PGP_PUBKEY_BIN) self._cache.clear() def test_check_ttl(self): """Check TTL of keys, should return a value.""" date_1 = datetime.datetime.strptime( datetime.datetime.now().strftime(self.FMT), self.FMT) end_date = date_1 + datetime.timedelta(days=10) with self._key.unlock(pgp_data.PGP_PASSPHRASE) as privkey: self._cache.set('test_key', privkey, end_date.strftime('%d/%b/%y %H:%M:%S')) today = datetime.datetime.today().strftime(self.FMT) tdelta = end_date - datetime.datetime.strptime(today, self.FMT) tdelta = datetime.timedelta(days=tdelta.days, seconds=tdelta.seconds) days = tdelta.days hours = tdelta.days * 24 + tdelta.seconds // 3600 minutes = tdelta.seconds % 3600 // 60 seconds = tdelta.seconds expected_value = [{ "keyID": "test_key", "ttl": f"{days} days {hours} hours {minutes} minutes {seconds} seconds" }] self.assertEqual(self._cache.check_ttl(), expected_value) self._cache.clear()
def test_proxy_no_project(self): env = EnvironmentVarGuard() env.unset('KAGGLE_USER_SECRETS_TOKEN') with env: client = bigquery.Client() self._test_proxy(client)
def test_proxy_using_library(self): env = EnvironmentVarGuard() env.unset('KAGGLE_USER_SECRETS_TOKEN') with env: client = PublicBigqueryClient() self._test_proxy(client)
def test_proxy_using_library(self): env = EnvironmentVarGuard() env.unset('KAGGLE_BQ_USER_JWT') with env: client = PublicBigqueryClient() self._test_proxy(client, should_use_proxy=True)
def test_proxy_no_project(self): env = EnvironmentVarGuard() env.unset('KAGGLE_USER_SECRETS_TOKEN') with env: client = bigquery.Client() self._test_proxy(client, should_use_proxy=True)
def test_proxy_no_project(self): env = EnvironmentVarGuard() env.unset('KAGGLE_BQ_USER_JWT') with env: client = bigquery.Client() self._test_proxy(client, should_use_proxy=True)
def test_no_token_fails(self): env = EnvironmentVarGuard() env.unset(_KAGGLE_USER_SECRETS_TOKEN_ENV_VAR_NAME) with env: with self.assertRaises(CredentialError): client = UserSecretsClient()
class TestS3Storage(unittest.TestCase): """S3Storage. Testing storage on S3 solution over TLS. """ def setUp(self): """Initialise fixtures.""" self._dir = TempDirectory() self.env = EnvironmentVarGuard() self.env.set('ARCHIVE_S3_URL', 'https://*****:*****@mock.patch.object(botocore.client, 'Config') @mock.patch.object(boto3, 'client') def test_upload(self, mock_boto, mock_botocore): """Test copy to S3, should call boto3 client.""" path = self._dir.write('test.file', 'data1'.encode('utf-8')) storage = S3Storage('archive', 'lega') storage.copy(path, 'lega') mock_botocore.assert_called_with(connect_timeout=60, client_cert=('/etc/ega/ssl.cert', '/etc/ega/ssl.key')) mock_boto.assert_called_with('s3', aws_access_key_id='test', aws_secret_access_key='test', endpoint_url='https://localhost:5000', region_name='lega', use_ssl=True, verify='/etc/ega/CA.cert', config=mock_botocore())
class AppTestCase(AioHTTPTestCase): """Test for Web app. Testing web app endpoints. """ @asynctest.mock.patch('beacon_api.app.initialize', side_effect=create_db_mock) async def get_application(self, pool_mock): """Retrieve web Application for test.""" token, public_key = generate_token('http://test.csc.fi') self.bad_token, _ = generate_bad_token() self.env = EnvironmentVarGuard() self.env.set('PUBLIC_KEY', json.dumps(public_key)) self.env.set('TOKEN', token) return await init() @unittest_run_loop async def tearDown(self): """Finish up tests.""" self.env.unset('PUBLIC_KEY') self.env.unset('TOKEN') await caches.get('default').delete("jwk_key") @unittest_run_loop async def test_info(self): """Test the info endpoint. The status should always be 200. """ with asynctest.mock.patch('beacon_api.app.beacon_info', side_effect={"smth": "value"}): resp = await self.client.request("GET", "/") assert 200 == resp.status @unittest_run_loop async def test_ga4gh_info(self): """Test the GA4GH Discovery info endpoint. The status should always be 200. """ with asynctest.mock.patch('beacon_api.app.beacon_info', side_effect={"smth": "value"}): resp = await self.client.request("GET", "/service-info") assert 200 == resp.status @unittest_run_loop async def test_post_info(self): """Test the info endpoint with POST. The status should always be 405. """ resp = await self.client.request("POST", "/") assert 405 == resp.status @unittest_run_loop async def test_empty_get_query(self): """Test empty GET query endpoint.""" resp = await self.client.request("GET", "/query") assert 400 == resp.status @unittest_run_loop async def test_empty_post_query(self): """Test empty POST query endpoint.""" resp = await self.client.request("POST", "/query", data=json.dumps({})) assert 400 == resp.status @unittest_run_loop async def test_bad_start_post_query(self): """Test bad start combination POST query endpoint.""" bad_start = { "referenceName": "MT", "endMin": 10, "end": 20, "startMin": 10, "startMax": 10, "referenceBases": "T", "variantType": "MNP", "assemblyId": "GRCh38", "includeDatasetResponses": "HIT" } resp = await self.client.request("POST", "/query", data=json.dumps(bad_start)) assert 400 == resp.status @unittest_run_loop async def test_bad_start2_post_query(self): """Test bad start combination 2 POST query endpoint.""" bad_start = { "referenceName": "MT", "start": 10, "end": 20, "startMin": 10, "startMax": 10, "referenceBases": "T", "variantType": "MNP", "assemblyId": "GRCh38", "includeDatasetResponses": "HIT" } resp = await self.client.request("POST", "/query", data=json.dumps(bad_start)) assert 400 == resp.status @unittest_run_loop async def test_bad_startend_post_query(self): """Test end smaller than start POST query endpoint.""" bad_start = { "referenceName": "MT", "start": 10, "end": 9, "referenceBases": "T", "variantType": "MNP", "assemblyId": "GRCh38", "includeDatasetResponses": "HIT" } resp = await self.client.request("POST", "/query", data=json.dumps(bad_start)) assert 400 == resp.status @unittest_run_loop async def test_bad_startminmax_post_query(self): """Test start min greater than start Max POST query endpoint.""" bad_start = { "referenceName": "MT", "startMin": 10, "startMax": 9, "referenceBases": "T", "variantType": "MNP", "assemblyId": "GRCh38", "includeDatasetResponses": "HIT" } resp = await self.client.request("POST", "/query", data=json.dumps(bad_start)) assert 400 == resp.status @unittest_run_loop async def test_bad_endminmax_post_query(self): """Test end min greater than start Max POST query endpoint.""" bad_start = { "referenceName": "MT", "endMin": 10, "endMax": 9, "referenceBases": "T", "variantType": "MNP", "assemblyId": "GRCh38", "includeDatasetResponses": "HIT" } resp = await self.client.request("POST", "/query", data=json.dumps(bad_start)) assert 400 == resp.status @asynctest.mock.patch('beacon_api.app.parse_request_object', side_effect=mock_parse_request_object) @asynctest.mock.patch('beacon_api.app.query_request_handler') @unittest_run_loop async def test_good_start_post_query(self, mock_handler, mock_object): """Test good start combination POST query endpoint.""" good_start = { "referenceName": "MT", "start": 10, "referenceBases": "T", "variantType": "MNP", "assemblyId": "GRCh38", "includeDatasetResponses": "HIT" } mock_handler.side_effect = json.dumps(good_start) resp = await self.client.request("POST", "/query", data=json.dumps(good_start)) assert 200 == resp.status @asynctest.mock.patch('beacon_api.app.parse_request_object', side_effect=mock_parse_request_object) @asynctest.mock.patch('beacon_api.app.query_request_handler') @unittest_run_loop async def test_good_start2_post_query(self, mock_handler, mock_object): """Test good start combination 2 POST query endpoint.""" good_start = { "referenceName": "MT", "start": 10, "end": 20, "referenceBases": "T", "variantType": "MNP", "assemblyId": "GRCh38", "includeDatasetResponses": "HIT" } mock_handler.side_effect = json.dumps(good_start) resp = await self.client.request("POST", "/query", data=json.dumps(good_start)) assert 200 == resp.status @asynctest.mock.patch('beacon_api.app.parse_request_object', side_effect=mock_parse_request_object) @asynctest.mock.patch('beacon_api.app.query_request_handler') @unittest_run_loop async def test_good_start3_post_query(self, mock_handler, mock_object): """Test good start combination 3 POST query endpoint.""" good_start = { "referenceName": "MT", "startMin": 10, "startMax": 20, "referenceBases": "T", "variantType": "MNP", "assemblyId": "GRCh38", "includeDatasetResponses": "HIT" } mock_handler.side_effect = json.dumps(good_start) resp = await self.client.request("POST", "/query", data=json.dumps(good_start)) assert 200 == resp.status @unittest_run_loop async def test_unauthorized_no_token_post_query(self): """Test unauthorized POST query endpoint, with no token.""" resp = await self.client.request("POST", "/query", data=json.dumps(PARAMS), headers={'Authorization': "Bearer"}) assert 401 == resp.status @unittest_run_loop async def test_unauthorized_token_post_query(self): """Test unauthorized POST query endpoint, bad token.""" resp = await self.client.request( "POST", "/query", data=json.dumps(PARAMS), headers={'Authorization': f"Bearer {self.bad_token}"}) assert 403 == resp.status @unittest_run_loop async def test_invalid_scheme_get_query(self): """Test unauthorized GET query endpoint, invalid scheme.""" params = '?assemblyId=GRCh38&referenceName=1&start=10000&referenceBases=A&alternateBases=T&datasetIds=dataset1' resp = await self.client.request("GET", f"/query{params}", headers={'Authorization': "SMTH x"}) assert 401 == resp.status @asynctest.mock.patch('beacon_api.app.parse_request_object', side_effect=mock_parse_request_object) @asynctest.mock.patch('beacon_api.app.query_request_handler', side_effect=json.dumps(PARAMS)) @unittest_run_loop async def test_valid_token_get_query(self, mock_handler, mock_object): """Test valid token GET query endpoint.""" token = os.environ.get('TOKEN') resp = await self.client.request( "POST", "/query", data=json.dumps(PARAMS), headers={'Authorization': f"Bearer {token}"}) assert 200 == resp.status @unittest_run_loop async def test_bad_json_post_query(self): """Test bad json POST query endpoint.""" resp = await self.client.request("POST", "/query", data="") assert 500 == resp.status @asynctest.mock.patch('beacon_api.app.parse_request_object', side_effect=mock_parse_request_object) @asynctest.mock.patch('beacon_api.app.query_request_handler', side_effect=json.dumps(PARAMS)) @unittest_run_loop async def test_valid_get_query(self, mock_handler, mock_object): """Test valid GET query endpoint.""" params = '?assemblyId=GRCh38&referenceName=1&start=10000&referenceBases=A&alternateBases=T' with asynctest.mock.patch('beacon_api.app.initialize', side_effect=create_db_mock): resp = await self.client.request("GET", f"/query{params}") assert 200 == resp.status @asynctest.mock.patch('beacon_api.app.parse_request_object', side_effect=mock_parse_request_object) @asynctest.mock.patch('beacon_api.app.query_request_handler', side_effect=json.dumps(PARAMS)) @unittest_run_loop async def test_valid_post_query(self, mock_handler, mock_object): """Test valid POST query endpoint.""" resp = await self.client.request("POST", "/query", data=json.dumps(PARAMS)) assert 200 == resp.status
def test_proxy_using_library(self): env = EnvironmentVarGuard() env.unset('KAGGLE_USER_SECRETS_TOKEN') with env: client = PublicBigqueryClient() self._test_proxy(client, should_use_proxy=True)