def create_server_client():
"""
create server client, collections and indexes
:return: server client
"""
client = FaunaClient(secret=os.environ.get('FAUNA_SERVER_SECRET'))
client.query(q.create_collection({"name": "users"}))
client.query(q.create_index(
{
"name": "users_by_username",
"source": q.collection("users"),
"permissions": {"read": "public"},
"terms": [{"field": ["data", "username"]}],
"unique": True
}
))
client.query(q.create_collection({"name": "contacts"}))
client.query(q.create_index(
{
"name": "contacts_by_username",
"source": q.collection("contacts"),
"terms": [{"field": ["data", "username"]}]
}
))
return client
def test_count_mean_sum(self):
data = [1, 2, 3, 4, 5, 6, 7, 8, 9]
self._q(query.create_collection({"name": "countmeansum_test"}))
self._q(
query.create_index({
"name": "countmeansum_idx",
"source": query.collection("countmeansum_test"),
"active": True,
"values": [{
"field": ["data", "value"]
}]
}))
self._q(
query.foreach(
query.lambda_(
"x",
query.create(
query.collection("countmeansum_test"),
{"data": {
"value": query.add(query.var("x"), 2)
}})), data))
m = query.match(query.index("countmeansum_idx"))
expected = [9, 5.0, 45, 9, 7.0, 63]
self.assertEqual(
self._q([
query.count(data),
query.mean(data),
query.sum(data),
query.count(m),
query.mean(m),
query.sum(m)
]), expected)
def create_collection(client):
collections = ["products", "users", "orders", "categories", "users"]
client.query(
q.map_(
lambda collection_name: q.if_(
q.exists(q.collection(collection_name)), True,
q.create_collection({"name": collection_name})), collections))
def test_documents(self):
aCollection = "col_test_documents"
anIndex = "idx_test_documents"
self._q(query.create_collection({"name": aCollection}))
self._q(
query.create_index({
"name": anIndex,
"source": query.collection(aCollection),
"active": True
}))
count = 56
data = [{} for x in range(count)]
self._q(
query.foreach(
query.lambda_(
"x",
query.create(query.collection(aCollection),
{"data": query.var("x")})), data))
self.assertEqual(
self._q(
query.select([0],
query.count(
query.paginate(
query.documents(
query.collection(aCollection)))))),
count)
self.assertEqual(
self._q(query.count(query.documents(
query.collection(aCollection)))), count)
def test_reverse(self):
#arrays
list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
self.assertEqual(self._q(query.reverse(list)), [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0])
self.assertEqual(self._q(query.reverse(query.reverse(list))), list)
self.assertEqual(self._q(query.reverse([])), [])
self._q(query.create_collection({"name": "reverse_collection"}))
self._q(query.create_index({
"name": "rev_coll_idx",
"source": query.collection("reverse_collection"),
"values": [{"field": ["data", "val"]}]
}))
index = query.index("rev_coll_idx")
for i in range(100):
self._q(query.create(query.collection(
"reverse_collection"), {"data": {"val": i}}))
assertPaginate = lambda q, expected, size = None : self.assertEqual(self._q(query.select("data", query.paginate(q, size))), expected)
assertPaginate(query.reverse(query.match(index)), [99, 98, 97, 96, 95], 5)
assertPaginate(query.reverse(query.reverse(query.match(index))), list, 11)
q1 = query.select(["data", 0], query.reverse(query.paginate(query.match(index), size=50)))
self.assertEqual(self._q(q1), 49)
self._assert_bad_query(query.reverse("a string"))
self._assert_bad_query(query.reverse(index))
self._assert_bad_query(query.reverse({"a": 1, "b": 2}))
def test_instance_not_found(self):
# Must be a reference to a real collection or else we get InvalidExpression
self.client.query(create_collection({"name": "foofaws"}))
self._assert_query_error(
get(ref(collection("foofaws"), "123")),
NotFound,
"instance not found")
def test_range(self):
data = list(range(1, 20))
self._q(query.create_collection({"name": "range_test"}))
self._q(
query.create_index({
"name": "range_idx",
"source": query.collection("range_test"),
"active": True,
"values": [{
"field": ["data", "value"]
}]
}))
self._q(
query.foreach(
query.lambda_query(lambda x: query.create(
query.collection("range_test"), {"data": {
"value": x
}})), data))
m = query.match(query.index("range_idx"))
q1 = query.select("data", query.paginate(query.range(m, 3, 8)))
q2 = query.select("data", query.paginate(query.range(m, 17, 18)))
q3 = query.select("data", query.paginate(query.range(m, 19, 0)))
self.assertEqual(self._q(q1), [3, 4, 5, 6, 7, 8])
self.assertEqual(self._q(q2), [17, 18])
self.assertEqual(self._q(q3), [])
def setUpClass(cls):
super(QueryTest, cls).setUpClass()
cls.collection_ref = cls.client.query(
query.create_collection({"name": "widgets"}))["ref"]
cls.n_index_ref = cls.client.query(
query.create_index({
"name": "widgets_by_n",
"active": True,
"source": cls.collection_ref,
"terms": [{
"field": ["data", "n"]
}]
}))["ref"]
cls.m_index_ref = cls.client.query(
query.create_index({
"name": "widgets_by_m",
"active": True,
"source": cls.collection_ref,
"terms": [{
"field": ["data", "m"]
}]
}))["ref"]
cls.z_index_ref = cls._q(
query.create_index({
"name": "widgets_by_z",
"active": True,
"source": cls.collection_ref,
"values": [{
"field": ["data", "z"]
}]
}))["ref"]
def fauna_create_collection(self, **kwargs: str) -> bool:
"""Create collection."""
client = self.get_fauna_connection()
collection_name: str = kwargs["collection_name"]
try:
client.query(q.create_collection({"name": collection_name}))
return True, collection_name
except (Exception) as _error: # pragma: no cover
raise ValueError("Fauna error.") from _error
def test_invalid_type(self):
exception = self.assert_raises(BadRequest,
lambda: self.client.query(create_collection({"name": 123})))
self._assert_error(exception, "validation failed", ['create_collection'])
failures = exception.errors[0].failures
self.assertEqual(len(failures), 1)
failure = failures[0]
self.assertEqual(failure.code, "invalid type")
self.assertEqual(failure.field, ["name"])
def __initialize_collection(cls):
logger.info("Checking if collection {c} exists...".format(
c=cls._collection_name))
try:
session().query(q.get(q.collection(cls._collection_name)))
logger.info("{c} exists, skipping creation.".format(
c=cls._collection_name))
except BadRequest:
logger.info("{c} does not exist, creating...".format(
c=cls._collection_name))
session().query(q.create_collection({"name":
cls._collection_name}))
def test_create_key(self):
self.admin_client.query(query.create_database({"name": "database_for_key_test"}))
resource = self.admin_client.query(query.create_key({
"database": query.database("database_for_key_test"),
"role": "server"}))
new_client = self.admin_client.new_session_client(secret=resource["secret"])
new_client.query(query.create_collection({"name": "collection_for_test"}))
self.assertTrue(new_client.query(query.exists(query.collection("collection_for_test"))))
def test_stream_reject_non_readonly_query(self):
q = query.create_collection({"name": "c"})
stream = None
def on_error(error):
self.assertEqual(error.type, 'error')
self.assertTrue(isinstance(error.error, BadRequest))
self.assertEqual(error.error._get_description(),
'Write effect in read-only query expression.')
stream.close()
stream = self.stream_sync(q, on_error=on_error)
stream.start()
def create_server_client():
client = FaunaClient(secret=os.environ.get('FAUNA_SECRET'))
client.query(q.create_collection({"name": "users"}))
client.query(
q.create_index({
"name": "users_by_username",
"source": q.collection("users"),
"permissions": {
"read": "public"
},
"terms": [{
"field": ["data", "username"]
}],
"unique": True
}))
client.create_collection()
def test_nested_references(self):
client1 = self.create_new_database(self.admin_client,
"parent-database")
client2 = self.create_new_database(client1, "child-database")
client2.query(query.create_collection({"name": "a_collection"}))
client2.query(
query.create_role({
"name": "a_role",
"privileges": {
"resource": query.collections(),
"actions": {
"read": True
}
}
}))
nested_database_ref = query.database("child-database",
query.database("parent-database"))
nested_collection_ref = query.collection("a_collection",
nested_database_ref)
nested_role_ref = query.role("a_role", nested_database_ref)
self.assertEqual(
self.admin_client.query(query.exists(nested_collection_ref)), True)
self.assertEqual(
self.admin_client.query(query.exists(nested_role_ref)), True)
parent_db_ref = Ref("parent-database", Native.DATABASES)
child_db_ref = Ref("child-database", Native.DATABASES, parent_db_ref)
self.assertEqual(
self.admin_client.query(
query.paginate(
query.collections(nested_database_ref)))["data"],
[Ref("a_collection", Native.COLLECTIONS, child_db_ref)])
self.assertEqual(
self.admin_client.query(
query.paginate(query.roles(nested_database_ref)))["data"],
[Ref("a_role", Native.ROLES, child_db_ref)])
def _make_sure_information_schema_exists() -> typing.List[QueryExpression]:
index_queries = [
_create_table_indices(collection_name, field_metadata)
for collection_name, field_metadata in
INFORMATION_SCHEMA_COLLECTIONS.items()
]
return [
q.if_(
q.exists(q.collection("information_schema_tables_")),
None,
q.do(*[
q.create_collection({"name": collection_name})
for collection_name in INFORMATION_SCHEMA_COLLECTIONS
]),
),
q.if_(
q.exists(q.index(fql.index_name("information_schema_tables_"))),
None,
q.do(*index_queries),
),
]
def __init__(self, database="Balthus", collection="domains"):
self.database = database
self.collection = collection
FAUNA_SECRET = os.getenv("FAUNA_SECRET")
self.client = FaunaClient(secret=FAUNA_SECRET)
try:
self.client.query(q.create_database({"name": database}))
except:
print("Database: {} already exist".format(database))
ref = self.client.query(
q.create_key({
"database": q.database(database),
"role": "server"
}))
self.client = FaunaClient(secret=ref['secret'])
try:
self.client.query(q.create_collection({"name": collection}))
except:
print("Collection: {} already exist".format(collection))
def _translate_create_table(
statement: token_groups.Statement,
table_token_idx: int) -> typing.List[QueryExpression]:
idx, table_identifier = statement.token_next_by(i=token_groups.Identifier,
idx=table_token_idx)
table_name = table_identifier.value
idx, column_identifiers = statement.token_next_by(
i=token_groups.Parenthesis, idx=idx)
field_metadata = _extract_column_definitions(column_identifiers)
index_queries = _create_table_indices(table_name, field_metadata)
collection_metadata: CollectionMetadata = {
"fields": field_metadata,
"indexes": _create_index_metadata(table_name, field_metadata),
}
information_metadata_query = _update_information_metadata(
table_name, collection_metadata)
# Fauna creates resources asynchronously, so we cannot create and use a collection
# in the same transaction, so we have to run the expressions that create
# the collection and the indices that depend on it separately
return [
*_make_sure_information_schema_exists(),
q.create_collection({"name": table_name}),
q.do(
*index_queries,
information_metadata_query,
q.let(
{"collection": q.collection(table_name)},
{"data": [{
"id": q.var("collection")
}]},
),
),
]
def test_set_iterator(self):
collection_ref = self.client.query(
query.create_collection({"name": "gadgets"}))["ref"]
index_ref = self.client.query(
query.create_index({
"name": "gadgets_by_n",
"active": True,
"source": collection_ref,
"terms": [{
"field": ["data", "n"]
}]
}))["ref"]
def create(n):
q = query.create(collection_ref, {"data": {"n": n}})
return self.client.query(q)["ref"]
a = create(0)
create(1)
b = create(0)
gadgets_set = query.match(index_ref, 0)
self.assertEqual(
list(Page.set_iterator(self.client, gadgets_set, page_size=1)),
[a, b])
query_mapper = lambda a: query.select(['data', 'n'], query.get(a))
query_mapped_iter = Page.set_iterator(self.client,
gadgets_set,
map_lambda=query_mapper)
self.assertEqual(list(query_mapped_iter), [0, 0])
mapped_iter = Page.set_iterator(self.client,
gadgets_set,
mapper=lambda x: [x])
self.assertEqual(list(mapped_iter), [[a], [b]])
def __init__(self, collection_name: str, model):
"""
Each CRUD requires that:
- Fauna client is connected to db
- collection_name is created / exists
- Collection is created / exists
"""
self.collection_name = collection_name
self.model = model
self.client = FaunaClient(secret=settings.FAUNADB_SECRET)
if not self.client.query(
query.exists(query.database(
db_name=settings.FAUNADB_DBNAME, ))):
self.database = self.client.query(
query.create_database(db_params={
'name': settings.FAUNADB_DBNAME,
}), )
if not self.client.query(
query.exists(
query.collection(collection_name=collection_name, ))):
self.collection = self.client.query(
query.create_collection(collection_params={
'name': collection_name,
}), )
def test_create_collection(self):
self.assertJson(query.create_collection({"name": "widget"}),
'{"create_collection":{"object":{"name":"widget"}}}')
# create db
client.query(q.create_database({"name": "my_app"}))
# Accessing the database
# Create an initial server key by using an admin key. The server key has unrestricted access to a single database;
# in this case, the server key will only access the blog post database we just created.
client.query(q.create_key({
"database": q.database("my_app"),
"role": "server"
}))
# Set up a collection
# Create a collection using the CreateCollection function with a param_object containing the name of the collection.
# We shall name our collection "posts":
client.query(q.create_collection({"name": "posts"}))
# Create an index
# The customary way to access documents within a collection is by specifying a criteria for one of the fields.
# To enable criteria-based searches, we need to first create an index using the path of the field within the document.
client.query(
q.create_index({
"name": "posts_by_title",
"source": q.collection("posts"),
"terms": [{
"field": ["data", "title"]
}]
}))
client.query(
def setUpClass(cls):
super(ThirdPartyAuthTest, cls).setUpClass()
cls.collection_ref = cls._q(
query.create_collection({"name": "3rdpartyauth_test_coll"}))["ref"]
def setUpClass(cls):
super(ClientLoggerTest, cls).setUpClass()
cls.collection_ref = cls.client.query(
create_collection({"name": "logging_tests"}))["ref"]
def test_create_collection(self):
self._q(query.create_collection({"name": "collection_for_test"}))
self.assertTrue(
self._q(query.exists(query.collection("collection_for_test"))))
def test_instance_already_exists(self):
self.client.query(create_collection({"name": "duplicates"}))
r = self.client.query(create(collection("duplicates"), {}))["ref"]
self._assert_query_error(create(r, {}), BadRequest,
"instance already exists", ["create"])
client.query(q.paginate(q.keys()))
### Get a key
#client.query(q.get(q.ref(q.keys(), "243725029947212288")))
client.query(q.get(q.ref(q.keys(), ref["ref"].id())))
### Delete a key
#client.query(q.delete(q.ref(q.keys(), "243725029947212288")))
client.query(q.delete(q.ref(q.keys(), ref["ref"].id())))
client.query(q.delete(q.database("caledonia")))
## Collections
### Create a collection
client.query(q.create_collection({"name": "spells"}))
### Paginate all collections
client.query(q.paginate(q.collections()))
### Get a collection
client.query(q.get(q.collection("spells")))
### Rename a collection
client.query(q.update(q.collection("spells"), {"name": "dilapidated_huts"}))
### Delete a collection
client.query(q.delete(q.collection("dilapidated_huts")))
### Create a document in a collection
client.query(q.create_collection({"name": "spells"}))
def setUpClass(cls):
super(StreamTest, cls).setUpClass()
cls.collection_ref = cls._q(
query.create_collection({"name": "stream_test_coll"}))["ref"]
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)
