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_no_token_fails(self):
env = EnvironmentVarGuard()
env.unset(_KAGGLE_USER_SECRETS_TOKEN_ENV_VAR_NAME)
with env:
with self.assertRaises(CredentialError):
client = UserSecretsClient()
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)
