def main(cfg):
global api_path
api_path = cfg.api_base + "/executes"
logger.log("Testing Executes API, api path: %s", api_path)
conn = db.connect(cfg)
test_asset_name = "script-test-sp-echo"
_delete(conn, test_asset_name)
try:
asset_id = create_asset(cfg, test_asset_name)
add_role(cfg, asset_id, "script", json.dumps(script_role_value))
add_role(cfg, asset_id, "script-executor-amc", {"os": "linux"})
rsp_msg = execute(cfg, asset_id)
rsp_msg_json = json.loads(rsp_msg)
if rsp_msg_json["code"] != 200:
return logger.failed("unexpected error: " + rsp_msg)
actual_output = str(rsp_msg_json["message"]).rstrip()
if actual_output != expected_output:
return logger.failed("expected: '" + expected_output +
"', actual: '" + actual_output + "'")
except Exception, x:
#traceback.print_exc()
return logger.failed(x.message)
def _testUpdate(conn, num, role):
_update_data = {
"modified_ts": str(role.modified_ts),
"role_schema": _asset_schema2(num)
}
req = requests.post(api_path + "/" + role.name, json=_update_data)
if not req.ok:
return logger.failed("Update expected {200, OK}, got code:",
req.status_code, "response:", req.text)
rsp_msg = json.loads(req.text)
rsp_name = rsp_msg["pk"]["role_name"]
rsp_modified_ts = datetime.strptime(rsp_msg["optLock"]["modified_ts"],
ts_fmt)
assert role.name == rsp_name
assert role.modified_ts < rsp_modified_ts
db_rec = Role(_read(conn, role.name)[0])
assert db_rec.name == role.name
assert db_rec.clazz == role.clazz
assert _eq_json_str(db_rec.role_schema, role.role_schema)
assert db_rec.description == role.description
assert db_rec.created_by == role.created_by
assert db_rec.modified_by == role.modified_by
assert db_rec.created_ts == role.created_ts
assert db_rec.modified_ts > role.modified_ts
assert db_rec.modified_ts == rsp_modified_ts
role.modified_ts = rsp_modified_ts
return True
def _testUpdate(conn, store):
new_store_type = "GitHub"
_update_data = {
"script_store_id": str(store.script_store_id),
"modified_ts": str(store.modified_ts),
"store_type": new_store_type
}
req = requests.post(api_path, data = _update_data)
if not req.ok:
return logger.failed("Update expected {200, OK}, got code:", req.status_code, "response:", req.text)
rsp_msg = json.loads(req.text)["message"]
rsp_script_store_id = str(rsp_msg["pk"]["script_store_id"])
rsp_modified_ts = datetime.strptime(rsp_msg["optLock"]["modified_ts"], ts_fmt)
assert rsp_script_store_id == str(store.script_store_id)
assert store.modified_ts < rsp_modified_ts
scriptStore = ScriptStore(_read(conn, store.script_store_id)[0])
assert store.script_store_id == scriptStore.script_store_id
assert store.store_name == scriptStore.store_name
assert new_store_type == scriptStore.store_type
assert store.description == scriptStore.description
assert store.created_by == scriptStore.created_by
assert store.modified_by == scriptStore.modified_by
assert store.created_ts == scriptStore.created_ts
assert store.modified_ts < scriptStore.modified_ts
assert rsp_modified_ts == scriptStore.modified_ts
store.modified_ts = rsp_modified_ts
return True
def _testDeleteNonExisted(conn, role):
logger.log("running DeleteNonExisted")
_delete_data = {"modified_ts": str(role.modified_ts)}
rsp = requests.delete(api_path + "/" + role.name, params=_delete_data)
if not rsp.status_code == 410:
return logger.failed("DeleteNonExisted expected {410, ...}, got code:",
rsp.status_code, "response:", rsp.text)
return True
def main(cfg):
api_path = cfg.api_base + "/admin/data"
logger.log("Testing Data Admin MetaData, API path: %s", api_path)
rsp = requests.get(api_path)
if not rsp.ok:
return logger.failed("expected {200, OK}, got code: %s, message %s" %
(rsp.status_code, rsp.text))
entry_point_names = json.loads(rsp.text)
if len(entry_point_names) < 1:
return logger.failed("no entry points were returned")
if not "script_stores" in entry_point_names:
return logger.failed(
"expected entry point 'script_stores' is not in the list")
return True
def _testCreateDupName(conn):
logger.log("running CreateDupName")
_insert_data = { "store_name": "store 1", "store_type": "GitHub", "description": "test data -1"}
req = requests.post(api_path, data = _insert_data)
rsp_msg = json.loads(req.text)["message"]
if not rsp_msg.startswith("Duplicate entry"):
return logger.failed("CreateDupName expected dup failure, got code:", req.status_code, "message:", req.text)
db.sql(conn, "rollback")
return True
def _testDeleteNonExisted(conn, store):
logger.log("running DeleteNonExisted")
_delete_data = {
"script_store_id": str(uuid.uuid4()), # new UUID
"modified_ts": str(store.modified_ts)
}
rsp = requests.delete(api_path, params = _delete_data)
if not rsp.status_code == 410:
return logger.failed("DeleteNonExisted expected {410, ...}, got code:", rsp.status_code, "response:", rsp.text)
return True
def _testDelete(conn, role):
_delete_data = {"modified_ts": str(role.modified_ts)}
rsp = requests.delete(api_path + "/" + role.name, params=_delete_data)
if not rsp.ok:
return logger.failed("Delete expected {200, OK}, got code:",
rsp.status_code, "response:", rsp.text)
asset_record = _read(conn, role.name)
assert asset_record is None
return True
def _testUpdateNonExisted(conn, role):
logger.log("running UpdateNonExisted")
_update_data = {
"modified_ts": str(role.modified_ts),
"role_schema": _asset_schema2(0)
}
rsp = requests.post(api_path + "/" + _asset_name(0), json=_update_data)
if not rsp.status_code == 410:
return logger.failed("UpdateNonExisted expected {410, ...}, got code:",
rsp.status_code, "response:", rsp.text)
return True
def _testUpdateNonExisted(conn, store):
logger.log("running UpdateNonExisted")
_update_data = {
"script_store_id": str(uuid.uuid4()), # new UUID
"modified_ts": str(store.modified_ts),
"store_type": "GitHub"
}
rsp = requests.post(api_path, data = _update_data)
if not rsp.status_code == 410:
return logger.failed("UpdateNonExisted expected {410, ...}, got code:", rsp.status_code, "response:", rsp.text)
return True
def _testCreateDupAsset(conn):
logger.log("running CreateDupName")
_insert_data = {
"role_name": _asset_name(1),
"class": "test",
"role_schema": _asset_schema(1)
}
req = requests.post(api_path, json=_insert_data)
if req.status_code != 409:
return logger.failed("CreateDupName expected dup failure, got code:",
req.status_code, "message:", req.text)
db.sql(conn, "rollback")
return True
def _testDelete(conn, store):
_delete_data = {
"script_store_id": str(store.script_store_id),
"modified_ts": str(store.modified_ts)
}
rsp = requests.delete(api_path, params = _delete_data)
if not rsp.ok:
return logger.failed("Delete expected {200, OK}, got code:", rsp.status_code, "response:", rsp.text)
recs = _read(conn, store.script_store_id)
assert len(recs) == 0
return True
def test(prms):
req = requests.get(api_path, params = prms)
if not req.ok:
return logger.failed(
"for %s: Read expected {200, OK}, got code: %s, message %s" % (prms, req.status_code, req.text))
apiObjs = json.loads(req.text)
assert apiObjs and len(apiObjs) == 1
apiObj = apiObjs[0]
assert apiObj["script_store_id"] == str(scriptStore.script_store_id)
assert apiObj["store_name" ] == scriptStore.store_name
assert apiObj["store_type" ] == scriptStore.store_type
assert apiObj["description"] == scriptStore.description
assert apiObj["created_by"] == scriptStore.created_by
assert apiObj["modified_by"] == scriptStore.modified_by
assert datetime.strptime(apiObj["created_ts"], ts_fmt) == scriptStore.created_ts
assert datetime.strptime(apiObj["modified_ts"], ts_fmt) == scriptStore.modified_ts
def test(role_name):
req = requests.get(api_path + "/" + role_name)
if not req.ok:
return logger.failed(
"for role %s: Read expected {200, OK}, got code: %s, message %s"
% (role_name, req.status_code, req.text))
apiObj = json.loads(req.text)
assert apiObj
assert apiObj["role_name"] == role.name
assert apiObj["class"] == role.clazz
assert _eq_json(apiObj["role_schema"], json.loads(role.role_schema))
assert apiObj["description"] == role.description
assert apiObj.get("created_by") == role.created_by
assert apiObj.get("modified_by") == role.modified_by
assert datetime.strptime(apiObj["created_ts"],
ts_fmt) == role.created_ts
assert datetime.strptime(apiObj["modified_ts"],
ts_fmt) == role.modified_ts
def _testCreateNew(conn, how_many):
logger.log("running CreateNew for %d entities", how_many)
identities = []
for k in xrange(how_many):
ks = str(k+1)
_insert_data = { "store_name": "store "+ks, "store_type": "LocalFile", "description": "test data "+ks}
req = requests.post(api_path, data = _insert_data)
if not req.ok:
return logger.failed("CreateNew expected {200, OK}, got code:", req.status_code, "response:", req.text)
rsp_msg = json.loads(req.text)["message"]
id_obj = {
"script_store_id": str(rsp_msg["pk"]["script_store_id"]),
"modified_ts": str(rsp_msg["optLock"]["modified_ts"]),
"uuid_pk": uuid.UUID(str(rsp_msg["pk"]["script_store_id"]))
}
identities.append(id_obj)
db.sql(conn, "commit")
return identities
def _testCreateAsset(conn, how_many):
logger.log("running CreateAsset for %d entities", how_many)
identities = []
for k in xrange(how_many):
role_name = _asset_name(k + 1)
_insert_data = {
"role_name": role_name,
"class": "test",
"role_schema": _asset_schema(k + 1),
"description": "test role " + str(k + 1)
}
req = requests.post(api_path, json=_insert_data)
if not req.ok:
return logger.failed("CreateNew expected {200, OK}, got code:",
req.status_code, "response:", req.text)
rsp_msg = json.loads(req.text)
id_obj = {
"name": str(rsp_msg["pk"]["role_name"]),
"modified_ts": str(rsp_msg["optLock"]["modified_ts"])
}
identities.append(id_obj)
db.sql(conn, "commit")
return identities
