def openapi():
yield '5f5141cbae5ca099d3f420f9c42c94cf'
refresh()
try: # teardown
APIDoc.get('5f5141cbae5ca099d3f420f9c42c94cf').delete()
except elasticsearch.exceptions.NotFoundError:
pass
def test_delete(myvariant):
mv = SmartAPI.get(myvariant)
mv.delete()
refresh()
assert not APIDoc.exists(myvariant)
URL = "http://example.com/valid.json"
with open(os.path.join(dirname, './validate/openapi-pass.json'), 'rb') as file:
smartapi = SmartAPI(URL)
smartapi.raw = file.read()
with pytest.raises(NotFoundError):
smartapi.delete()
def setup_fixture():
"""
Index 2 documents.
"""
reset()
# save initial docs with paths already transformed
mygene = APIDoc(meta={'id': MYGENE_ID}, **MYGENE_ES)
mygene._raw = decoder.compress(MYGENE_RAW)
mygene.save()
mychem = APIDoc(meta={'id': MYCHEM_ID}, **MYCHEM_ES)
mychem._raw = decoder.compress(MYCHEM_RAW)
mychem.save()
# refresh index
refresh()
def test_uptime_status():
mygene = SmartAPI.get(MYGENE_ID)
assert mygene.uptime.status[0] is None
mygene.uptime.update(('good', None))
assert mygene.uptime.status[0] == 'good'
mygene.save()
refresh()
mygene_doc = APIDoc.get(MYGENE_ID)
assert mygene_doc._status.uptime_status == 'good'
mygene.uptime.update((None, None))
assert mygene.uptime.status[0] is None
mygene.save()
refresh()
mygene_doc = APIDoc.get(MYGENE_ID)
assert mygene_doc._status.uptime_status is None
def setup():
"""
setup state called once for the class
"""
reset()
mygene = SmartAPI(MYGENE_URL)
mygene.username = '******'
mygene.refresh()
mygene.check()
mygene.save()
mychem = SmartAPI(MYCHEM_URL)
mychem.username = '******'
mychem.refresh()
mychem.check()
mychem.save()
refresh()
def myvariant():
with open(os.path.join(dirname, 'myvariant.es.json'), 'r') as file:
MYVARIANT_ES = json.load(file)
with open(os.path.join(dirname, 'myvariant.yml'), 'rb') as file:
MYVARIANT_RAW = file.read()
MYVARIANT_ID = MYVARIANT_ES.pop("_id")
myvariant = APIDoc(meta={'id': MYVARIANT_ID}, **MYVARIANT_ES)
myvariant._raw = decoder.compress(MYVARIANT_RAW)
myvariant.save()
refresh()
yield MYVARIANT_ID
refresh()
try:
APIDoc.get(MYVARIANT_ID).delete()
except elasticsearch.exceptions.NotFoundError:
pass
def test_uptime_update():
mygene = SmartAPI.get(MYGENE_ID)
mygene.check() # minimum api document
assert mygene.uptime.status[0] == 'unknown' # TODO VERIFY THIS IS IN FACT CORRECT
mygene.save()
refresh()
mygene_doc = APIDoc.get(MYGENE_ID)
assert mygene_doc._status.uptime_status == 'unknown'
mychem = SmartAPI.get(MYCHEM_ID)
mychem.check() # full api document
assert mychem.uptime.status[0] == 'unknown'
mychem.save()
refresh()
mychem_doc = APIDoc.get(MYCHEM_ID)
assert mychem_doc._status.uptime_status == 'unknown'
def setup_fixture():
"""
Index 2 documents.
"""
reset()
# save initial docs with paths already transformed
mygene = SmartAPI(MYGENE_URL)
mygene.raw = MYGENE_RAW
mygene.username = '******'
mygene.slug = 'mygene'
mygene.save()
mychem = SmartAPI(MYCHEM_URL)
mychem.raw = MYCHEM_RAW
mychem.username = '******'
mychem.slug = 'mychem'
mychem.save()
# refresh index
refresh()
def test_refresh_update():
mychem = SmartAPI.get(MYCHEM_ID)
assert mychem.webdoc.status is None
# NOTE
# the following update and the updates thereafter will be applied
# https://github.com/NCATS-Tangerine/translator-api-registry/commit/b01baa5
mychem.refresh()
assert mychem.webdoc.status == 299 # new version
assert mychem.webdoc.timestamp > datetime(2020, 1, 1, tzinfo=timezone.utc)
_ts0 = mychem.webdoc.timestamp
mychem.refresh()
assert mychem.webdoc.status == 200 # already latest
assert mychem.webdoc.timestamp >= _ts0 # could be cached internally
mychem.save()
refresh()
mychem_doc = APIDoc.get(MYCHEM_ID)
assert mychem_doc._status.refresh_status == 200
def test_post(self):
_ID = '1ad2cba40cb25cd70d00aa8fba9cfaf3'
VALID_V3_URL = \
'https://raw.githubusercontent.com/schurerlab/'\
'smartAPIs/master/LINCS_Data_Portal_smartAPIs.yml'
try:
smartapi = SmartAPI.get(_ID)
smartapi.delete()
refresh()
except NotFoundError:
pass
self.request("/api/metadata/",
method='POST',
data={'url': VALID_V3_URL},
expect=401)
self.request("/api/metadata/",
method='POST',
data={'url': MYGENE_URL},
headers=self.auth_user,
expect=409)
self.request("/api/metadata/",
method='POST',
headers=self.auth_user,
expect=400)
self.request("/api/metadata/",
method='POST',
data={'url': "http://invalidhost/file"},
headers=self.auth_user,
expect=400)
self.request("/api/metadata/",
method='POST',
data={
'url': VALID_V3_URL,
'dryrun': True
},
headers=self.auth_user)
refresh()
assert not SmartAPI.exists(_ID)
self.request("/api/metadata/",
method='POST',
data={'url': VALID_V3_URL},
headers=self.auth_user)
refresh()
assert SmartAPI.exists(_ID)
try:
smartapi = SmartAPI.get(_ID)
smartapi.delete()
except NotFoundError:
pass
def test_delete(self):
# setup
assert SmartAPI.exists(MYGENE_ID)
self.request("/api/metadata/" + MYGENE_ID, method='DELETE', expect=401)
self.request("/api/metadata/" + MYGENE_ID,
method='DELETE',
headers=self.evil_user,
expect=403)
self.request("/api/metadata/" + MYGENE_ID,
method='DELETE',
headers=self.auth_user)
refresh()
assert not SmartAPI.exists(MYGENE_ID)
# teardown
refresh()
if not SmartAPI.exists(MYGENE_ID): # recover the deleted file
mygene = APIDoc(meta={'id': MYGENE_ID}, **MYGENE_ES)
mygene._raw = decoder.compress(MYGENE_RAW)
mygene.save()
refresh()
def test_refresh_status():
with open(os.path.join(dirname, 'mygene_full.yml'), 'rb') as file:
MYGENE_FULL = file.read()
mygene = SmartAPI.get(MYGENE_ID) # minimum
assert mygene.webdoc.status is None
assert 'components' not in mygene
mygene.webdoc.update(File(200, MYGENE_FULL, None, None)) # new content
assert mygene.webdoc.status == 299 # updated
assert 'components' in mygene
assert mygene.webdoc.timestamp > datetime(2020, 1, 1)
_ts0 = mygene.webdoc.timestamp
mygene.save()
refresh()
mygene_doc = APIDoc.get(MYGENE_ID)
assert mygene_doc._status.refresh_status == 299
assert 'components' in mygene_doc
mygene.webdoc.update(File(200, MYGENE_FULL, None, None)) # no change
assert mygene.webdoc.status == 200 # latest
assert 'components' in mygene
assert mygene.webdoc.timestamp > _ts0
mygene.save()
refresh()
mygene_doc = APIDoc.get(MYGENE_ID)
assert mygene_doc._status.refresh_status == 200
assert 'components' in mygene_doc
mygene.webdoc.update(File(404, None, None, None)) # link broken
assert mygene.webdoc.status == 404
assert 'components' in mygene # do not affect main copy
mygene.save()
refresh()
mygene_doc = APIDoc.get(MYGENE_ID)
assert mygene_doc._status.refresh_status == 404
assert 'components' in mygene_doc
mygene.webdoc.update(File(200, MYGENE_FULL, None, None)) # link back working
assert mygene.webdoc.status == 200 # latest
assert 'components' in mygene
mygene.save()
refresh()
mygene_doc = APIDoc.get(MYGENE_ID)
assert mygene_doc._status.refresh_status == 200
assert 'components' in mygene_doc
mygene.webdoc.update(File(200, b'{"openapi":"3.0.0"}', None, None)) # invalid
assert mygene.webdoc.status == 499 # invalid
assert 'components' in mygene # do not affect main copy
mygene.save()
refresh()
mygene_doc = APIDoc.get(MYGENE_ID)
assert mygene_doc._status.refresh_status == 499
assert 'components' in mygene_doc
def test_save(openapi):
"""
SmartAPI.slug.validate(slug)
smartapi.slug
smartapi.save()
"""
_t0 = datetime.now(timezone.utc)
time.sleep(0.1)
URL = "http://example.com/valid.json"
with pytest.raises(ValueError):
SmartAPI.slug.validate("a")
with pytest.raises(ValueError):
SmartAPI.slug.validate("AAA")
with pytest.raises(ValueError):
SmartAPI.slug.validate("www")
with pytest.raises(ValueError):
SmartAPI.slug.validate("^_^")
with open(os.path.join(dirname, './validate/openapi-pass.json'), 'rb') as file:
raw = file.read()
smartapi = SmartAPI(URL)
with pytest.raises(ControllerError):
smartapi.raw = None
smartapi.raw = raw
smartapi.slug = "mygene"
smartapi.validate()
with pytest.raises(ControllerError):
smartapi.save()
smartapi.username = "******"
with pytest.raises(ConflictError):
smartapi.save()
smartapi.slug = "mychem"
with pytest.raises(ConflictError):
smartapi.save()
smartapi.slug = "openapi"
smartapi.save()
refresh()
assert SmartAPI.find("openapi") == smartapi._id
assert smartapi.date_created > _t0
assert smartapi.last_updated > _t0
assert smartapi.date_created == smartapi.last_updated
apidoc = APIDoc.get(smartapi._id)
assert apidoc._meta.date_created == smartapi.date_created
assert apidoc._meta.last_updated == smartapi.last_updated
_t1 = smartapi.date_created
smartapi.save() # no change
refresh()
assert SmartAPI.find("openapi") == smartapi._id
assert smartapi.date_created == _t1
assert smartapi.last_updated == _t1
assert smartapi.date_created == smartapi.last_updated
apidoc = APIDoc.get(smartapi._id)
assert apidoc._meta.date_created == smartapi.date_created
assert apidoc._meta.last_updated == smartapi.last_updated
smartapi.slug = None
smartapi.save()
refresh()
assert not SmartAPI.find("openapi")
found = SmartAPI.get(openapi)
assert dict(smartapi) == dict(found)
assert smartapi.username == found.username
assert smartapi.slug == found.slug
assert smartapi.url == found.url
assert smartapi.date_created == _t1
assert smartapi.last_updated == _t1
assert smartapi.date_created == smartapi.last_updated
apidoc = APIDoc.get(smartapi._id)
assert apidoc._meta.date_created == smartapi.date_created
assert apidoc._meta.last_updated == smartapi.last_updated
smartapi.raw = raw # should trigger ts update
smartapi.save()
refresh()
assert smartapi.date_created == _t1
assert smartapi.last_updated > _t1
apidoc = APIDoc.get(smartapi._id)
assert apidoc._meta.date_created == smartapi.date_created
assert apidoc._meta.last_updated == smartapi.last_updated
def setup_fixture():
client.delete(ES_INDEX_NAME, "doc0", ignore=404)
client.delete(ES_INDEX_NAME, "doc1", ignore=404)
client.create(ES_INDEX_NAME, "doc1", MYGENE)
refresh()
smartapi.username = doc['_source']['_meta']['github_username']
smartapi.slug = doc['_source']['_meta'].get('slug')
smartapi.save()
print()
def update():
for doc in scan(Elasticsearch(ES_DESTINATION),
query={"query": {
"match_all": {}
}},
index="smartapi_docs",
scroll="60m"):
print(doc["_id"])
smartapi = SmartAPI.get(doc["_id"])
print(smartapi.check())
print(smartapi.refresh())
if smartapi.webdoc.status == 299:
smartapi.webdoc._status = 200 # change status not reliable during migration
smartapi.save()
print()
if __name__ == "__main__":
input('Will reset smartapi_docs index. Ctrl-C to cancel.')
indices.reset()
migrate()
indices.refresh()
update()
def test_update_slug(self):
mygene = SmartAPI.get(MYGENE_ID)
assert mygene.slug == "mygene"
self.request("/api/metadata/" + MYGENE_ID,
method='PUT',
data={"slug": "mygeeni"},
expect=401)
self.request("/api/metadata/" + MYGENE_ID,
method='PUT',
data={"slug": "mygeeni"},
headers=self.evil_user,
expect=403)
self.request("/api/metadata/" + MYGENE_ID,
method='PUT',
data={"slug": "my"},
headers=self.auth_user,
expect=400)
self.request("/api/metadata/" + MYGENE_ID,
method='PUT',
data={"slug": "www"},
headers=self.auth_user,
expect=400)
self.request("/api/metadata/" + MYGENE_ID,
method='PUT',
data={"slug": "MYGENE"},
headers=self.auth_user,
expect=400)
self.request("/api/metadata/" + MYGENE_ID,
method='PUT',
data={"slug": "mygene!!"},
headers=self.auth_user,
expect=400)
self.request("/api/metadata/" + MYGENE_ID,
method='PUT',
data={"slug": "mygeeni"},
headers=self.auth_user)
refresh()
assert not SmartAPI.find("mygene")
assert SmartAPI.find("mygeeni")
self.request("/api/metadata/" + MYGENE_ID,
method='PUT',
data={"slug": ""},
headers=self.auth_user)
refresh()
assert not SmartAPI.find("mygeeni")
assert not SmartAPI.find("mygene")
self.request("/api/metadata/" + MYGENE_ID,
method='PUT',
data={"slug": "mygene"},
headers=self.auth_user)
refresh()
assert not SmartAPI.find("mygeeni")
assert SmartAPI.find("mygene")
# teardown
refresh()
if not SmartAPI.find("mygene"):
mygene = APIDoc(meta={'id': MYGENE_ID}, **MYGENE_ES)
mygene._raw = decoder.compress(MYGENE_RAW)
mygene.save()
