def test_call_function(self):
self._q(query.create_function({
"name": "concat_with_slash",
"body": query.query(lambda a, b: query.concat([a, b], "/"))
}))
self.assertEqual(self._q(query.call(query.function("concat_with_slash"), "a", "b")), "a/b")
def test_create_function(self):
self._q(
query.create_function({
"name": "a_function",
"body": query.query(lambda x: x)
}))
self.assertTrue(self._q(query.exists(query.function("a_function"))))
def test_create_accprov_with_roles(self):
providerName = "provider_with_roles"
issuerName = "issuer_%s" % (self._randStr())
fullUri = "https: //$%s.auth0.com" % (self._randStr(4))
roleOneName = "role_one_%s" % (self._randStr(4))
roleTwoName = "role_two_%s" % (self._randStr(4))
self.admin_client.query(
query.create_role({
"name":
roleOneName,
"privileges": [
{
"resource": query.databases(),
"actions": {
"read": True
},
},
],
}))
self.admin_client.query(
query.create_role({
"name":
roleTwoName,
"privileges": [
{
"resource": query.databases(),
"actions": {
"read": True
},
},
],
}))
provider = self.admin_client.query(
query.create_access_provider({
"name":
providerName,
"issuer":
issuerName,
"jwks_uri":
fullUri,
"roles": [
query.role(roleOneName),
{
"role": query.role(roleTwoName),
"predicate": query.query(query.lambda_("x", True)),
},
],
}))
self.assertEqual(provider["name"], providerName)
self.assertEqual(provider["issuer"], issuerName)
self.assertEqual(provider["jwks_uri"], fullUri)
self.assertTrue(isinstance(provider["roles"], list))
def test_query(self):
versioned212 = Query({"api_version": "2.12", "lambda": ["a", "b"], "expr": {
"concat": [{"var": "a"}, {"var": "b"}], "separator": "/"}})
body212 = self._q(versioned212)
body3 = self._q(query.query(lambda a, b: query.concat([a, b], "/")))
versioned3 = Query({"api_version": "4", "lambda": ["a", "b"], "expr": {
"concat": [{"var": "a"}, {"var": "b"}], "separator": "/"}})
self.assertEqual(body212, versioned212)
self.assertEqual(body3, versioned3)
def test_echo_query(self):
body = self._q(query.query(lambda a, b: query.concat([a, b], "/")))
bodyEchoed = self._q(body)
self.assertEqual(body, bodyEchoed)
def test_typecheckfns(self):
coll = query.collection("typecheck_coll")
db = query.database("typecheck_db")
fn = query.function("typecheck_fn")
index = query.index("typecheck_index")
self.admin_client.query(query.create_collection({"name": "typecheck_coll"}))
self.admin_client.query(query.create_index(
{"name": "typecheck_index", "source": coll, "active": True}))
doc = self.admin_client.query(query.create(
coll, {"data": {}, "credentials": {"password": "******"}}))
self.admin_client.query(query.create_database({"name": "typecheck_db"}))
function = self._q(query.create_function(
{"name": "typecheck_fn", "body": query.query(query.lambda_("x", query.now()))}))
key = self.admin_client.query(
query.create_key({"database": db, "role": "admin"}))
token = self._q(query.login(doc["ref"], {"password": "******"}))
credentials = self._q(query.select(['data', 0], query.paginate(query.credentials())))
role = self.admin_client.query(query.create_role(
{"name": "typecheck_role", "membership": [], "privileges": []}))
values = [
None,
bytearray([12,3,4,5]),
credentials,
90,
3.14,
True,
query.to_date(query.now()),
query.date("1970-01-01"),
query.now(),
query.epoch(1, "second"),
query.time("1970-01-01T00:00:00Z"),
{"x": 10},
query.get(doc["ref"]),
query.paginate(query.collections()),
[1, 2, 3],
"a string",
coll,
query.collections(),
query.match(index),
query.union(query.match(index)),
doc["ref"],
query.get(doc["ref"]),
index,
db,
coll,
token["ref"],
role["ref"],
key["ref"],
function["ref"],
query.get(function["ref"]),
query.query(query.lambda_("x", query.var("x"))),
]
pairs = [
["array", query.is_array],
["object", query.is_object],
["string", query.is_string],
["null", query.is_null],
["number", query.is_number],
["bytes", query.is_bytes],
["date", query.is_date],
["timestamp", query.is_timestamp],
["set", query.is_set],
["ref", query.is_ref],
["boolean", query.is_boolean],
["double", query.is_double],
["integer", query.is_integer],
["database", query.is_database],
["index", query.is_index],
["collection", query.is_collection],
["token", query.is_token],
["function", query.is_function],
["collection", query.is_collection],
["role", query.is_role],
["credentials", query.is_credentials],
["key", query.is_key],
]
expected = {
"array": 1,
"boolean": 1,
"bytes": 1,
"collection": 3,
"credentials": 1,
"database": 1,
"date": 2,
"double": 1,
"function": 2,
"integer": 1,
"index": 1,
"key": 1,
"null": 1,
"number": 2,
"object": 5,
"ref": 11,
"role": 1,
"set": 3,
"string": 1,
"timestamp": 3,
"token": 1,
}
q = []
for p in pairs:
d = dict()
d[p[0]] = query.count(query.filter_(query.lambda_("v", p[1](query.var("v"))), query.var("vals")))
q.append(d)
actual = self._q(query.let({"vals": values}, query.merge({}, q)))
self.assertEqual(actual, expected)
def create_indexes(client):
indexes = [{
"name": "user_by_email",
"source": q.collection("users"),
"terms": [{
"field": ["data", "email"]
}],
}, {
"name": "products_search_by_name",
"source": {
"collection": q.collection('products'),
"fields": {
"wordparts":
q.query(lambda product: wordPartsGenerator(
q.select(['data', 'name'], product)))
}
},
"terms": [{
"binding": 'wordparts'
}],
}, {
"name": "products_search_by_category",
"source": q.collection('products'),
"terms": [{
"field": ["data", "categories"]
}],
}, {
"name": "products_sort_by_name_asc",
"source": q.collection('products'),
"terms": [{
"field": ["ref"]
}],
"values": [
{
"field": ["data", "name"]
},
{
"field": ["ref"]
},
]
}, {
"name": "products_sort_by_price_asc",
"source": q.collection('products'),
"terms": [{
"field": ["ref"]
}],
"values": [
{
"field": ["data", "price"]
},
{
"field": ["ref"]
},
]
}, {
"name":
"products_sort_by_price_desc",
"source":
q.collection('products'),
"terms": [{
"field": ["ref"]
}],
"values": [
{
"field": ["data", "price"],
"reverse": True
},
{
"field": ["ref"]
},
]
}, {
"name":
"products_sort_by_created_asc",
"source":
q.collection('products'),
"values": [
{
"field": ["data", "createdAt"]
},
{
"field": ["ref"]
},
]
}]
client.query(
q.map_(
lambda index: q.if_(q.exists(q.index(q.select(["name"], index))),
True, q.create_index(index)), indexes))
def create_roles(client):
roles = [{
"name":
"admin",
"membership": [{
"resource":
q.collection("users"),
"predicate":
q.query(lambda ref: q.equals(
q.select(["data", "type"], q.get(ref)), "admin"))
}],
"privileges": [{
"resource": q.collection("categories"),
"actions": {
"read": True,
"create": True,
"write": True
}
}, {
"resource": q.collection("products"),
"actions": {
"read": True,
"write": True,
"create": True
}
}, {
"resource": q.collection("users"),
"actions": {
"read": True,
"create": True,
"write": True
}
}, {
"resource": q.collection("orders"),
"actions": {
"read": True,
"write": True,
"create": True
}
}, {
"resource":
objects.Ref("check_if_categories_exists",
objects.Ref("functions")),
"actions": {
"call": True
}
}]
}, {
"name":
"customer",
"membership": [{
"resource":
q.collection("users"),
"predicate":
q.query(lambda ref: q.equals(
q.select(["data", "type"], q.get(ref)), "customer"))
}],
"privileges": [{
"resource":
objects.Ref("purchase", objects.Ref("functions")),
"actions": {
"call": True
}
}, {
"resource":
objects.Ref("get_order_status_history", objects.Ref("functions")),
"actions": {
"call":
q.query(lambda ref: q.equals(
q.current_identity(),
q.select(["data", "customer"], q.get(ref)))),
}
}, {
"resource": q.collection("users"),
"actions": {
"read":
q.query(lambda ref: q.equals(q.current_identity(), ref)),
"write":
q.query(lambda ref: q.equals(q.current_identity(), ref)),
}
}, {
"resource": q.collection("orders"),
"actions": {
"read":
q.query(lambda ref: q.equals(
q.current_identity(),
q.select(["data", "customer"], q.get(ref)))),
}
}]
}]
client.query(q.map_(lambda role: q.create_role(role), roles))
