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)