def test_delete_graph():
# Test delete graph from the last test
result = db.delete_graph(graph_name)
assert result is True
assert graph_name not in db.graphs()
# Test delete missing graph
with pytest.raises(GraphDeleteError):
db.delete_graph(graph_name)
# Test delete missing graph (ignore_missing)
result = db.delete_graph(graph_name, ignore_missing=True)
assert result is False
major, minor = arango_version(arango_client)
if major == 3 and minor >= 1:
# Create a graph with vertex and edge collections and delete them all
new_graph_name = generate_graph_name()
graph = db.create_graph(new_graph_name)
vcol_name_1 = generate_col_name()
graph.create_vertex_collection(vcol_name_1)
vcol_name_2 = generate_col_name()
graph.create_vertex_collection(vcol_name_2)
ecol_name = generate_col_name()
graph.create_edge_definition(name=ecol_name,
from_collections=[vcol_name_1],
to_collections=[vcol_name_2])
collections = set(col['name'] for col in db.collections())
assert vcol_name_1 in collections
assert vcol_name_2 in collections
assert ecol_name in collections
db.delete_graph(new_graph_name)
collections = set(col['name'] for col in db.collections())
assert vcol_name_1 in collections
assert vcol_name_2 in collections
assert ecol_name in collections
graph = db.create_graph(new_graph_name)
graph.create_edge_definition(name=ecol_name,
from_collections=[vcol_name_1],
to_collections=[vcol_name_2])
db.delete_graph(new_graph_name, drop_collections=True)
collections = set(col['name'] for col in db.collections())
assert vcol_name_1 not in collections
assert vcol_name_2 not in collections
assert ecol_name not in collections
def test_get_user_access_collection_level():
# Create a new test user
username = generate_user_name()
db.create_user(username=username, password='******')
arango_client.database(name=db_name,
username=username,
password='******')
col_name = generate_col_name()
col = db.create_collection(col_name)
# The new user should have no access to the collection
assert col.user_access(username) is None
# After granting access to the collection it should work
col.grant_user_access(username)
assert col.user_access(username) == 'rw'
# Revoke the access again to see that 401 is back
col.revoke_user_access(username)
assert col.user_access(username) is None
# Grant access from a bad database (missing user)
with pytest.raises(ArangoError) as err:
bad_db.collection(col_name).user_access(generate_user_name())
assert err.value.http_code in HTTP_AUTH_ERR
assert isinstance(err.value, UserAccessError) \
or isinstance(err.value, AsyncExecuteError) \
or isinstance(err.value, BatchExecuteError)
def test_revoke_user_access_collection_level():
# Create a new test user
username = generate_user_name()
db.create_user(username=username, password='******')
user_db = arango_client.database(name=db_name,
username=username,
password='******')
col_name = generate_col_name()
col = db.create_collection(col_name)
# The new user should have no access to the collection
with pytest.raises(ArangoError) as err:
user_db.collection(col_name).count()
assert err.value.http_code in HTTP_AUTH_ERR
# After granting access to the collection it should work
col.grant_user_access(username)
# TODO enable again once the bug is fixed on ArangoDB side
# assert user_db.collection(col_name).count() == 0
# Revoke the access again to see that 401 is back
col.revoke_user_access(username)
with pytest.raises(ArangoError) as err:
user_db.collection(col_name).count()
assert err.value.http_code in HTTP_AUTH_ERR
# Grant access from a bad database (missing user)
with pytest.raises(ArangoError) as err:
bad_db.collection(col_name).revoke_user_access(generate_user_name())
assert err.value.http_code in HTTP_AUTH_ERR
assert isinstance(err.value, UserRevokeAccessError) \
or isinstance(err.value, AsyncExecuteError) \
or isinstance(err.value, BatchExecuteError)
def test_grant_user_access_db_level():
# Create a test user and login as that user
username = generate_user_name()
db.create_user(username=username, password='******')
user_db = arango_client.database(name=db_name,
username=username,
password='******')
# Create a collection with the user (should have no access)
col_name = generate_col_name()
with pytest.raises(CollectionCreateError) as err:
user_db.create_collection(col_name)
assert err.value.http_code in HTTP_AUTH_ERR
assert col_name not in set(col['name'] for col in db.collections())
# Grant the user access and try again
db.grant_user_access(username)
db.create_collection(col_name)
assert col_name in set(col['name'] for col in db.collections())
# Grant access to a missing user
bad_username = generate_user_name()
with pytest.raises(UserGrantAccessError) as err:
db.grant_user_access(bad_username)
assert err.value.http_code == 404
def test_revoke_user_access_db_level():
# Create a test user with access and login as that user
username = generate_user_name()
db.create_user(username=username, password='******')
db.grant_user_access(username, db_name)
user_db = arango_client.database(name=db_name,
username=username,
password='******')
# Test user access by creating a collection
col_name = generate_col_name()
user_db.create_collection(col_name)
assert col_name in set(col['name'] for col in db.collections())
# Revoke access from the user
db.revoke_user_access(username)
with pytest.raises(CollectionDeleteError) as err:
user_db.delete_collection(col_name)
assert err.value.http_code in HTTP_AUTH_ERR
# Test revoke access to missing user
bad_username = generate_user_name()
with pytest.raises(UserRevokeAccessError) as err:
db.revoke_user_access(bad_username)
assert err.value.http_code == 404
def test_rename():
assert col.name == col_name
new_name = generate_col_name()
while new_name == bad_col_name:
new_name = generate_col_name()
# Test rename collection
result = col.rename(new_name)
assert result['name'] == new_name
assert col.name == new_name
assert repr(col) == '<ArangoDB collection "{}">'.format(new_name)
# Try again (the operation should be idempotent)
result = col.rename(new_name)
assert result['name'] == new_name
assert col.name == new_name
assert repr(col) == '<ArangoDB collection "{}">'.format(new_name)
with pytest.raises(CollectionRenameError):
bad_col.rename(new_name)
def test_execute_with_errors():
txn = db.transaction(write=col_name)
bad_col_name = generate_col_name()
with pytest.raises(TransactionError):
txn.execute(
command='''
function (params) {{
var db = require('internal').db;
db.{col}.save({{ '_key': '1', 'val': params.one }});
db.{col}.save({{ '_key': '2', 'val': params.two }});
return 'this transaction should fail!';
}}'''.format(col=bad_col_name),
params={'one': 3, 'two': 4}
)
def test_replace_match():
# Set up test edges
ecol.insert_many(test_edges)
# Test replace single matching document with invalid body
with pytest.raises(DocumentReplaceError):
ecol.replace_match({'_key': '3'}, {'_to': edge2['_to']})
# Test replace single matching document with valid body
assert ecol.replace_match(
{'_key': '3'},
{'_to': edge2['_to'], '_from': edge3['_from']}
) == 1
assert ecol['3']['_to'] == edge2['_to']
assert ecol['3']['_from'] == edge3['_from']
# Test replace multiple matching documents
assert ecol.replace_match(
{'_from': col_name + '/1'},
{'_to': edge1['_to'], '_from': edge1['_from'], 'foo': 'bar'}
) == 2
assert ecol['1']['foo'] == 'bar'
assert ecol['1']['_to'] == edge1['_to']
assert ecol['1']['_from'] == edge1['_from']
assert ecol['4']['foo'] == 'bar'
# Test replace multiple matching documents with arguments
assert ecol.replace_match(
{'_from': col_name + '/1'},
{'_to': edge3['_to'], '_from': edge3['_from'], 'foo': 'baz'},
limit=1,
sync=True,
) == 1
assert ecol['1']['foo'] == 'baz'
assert ecol['4']['foo'] == 'bar'
# Test unaffected document
assert ecol['2']['_to'] == edge2['_to']
assert 'foo' not in ecol['2']
# Test replace matching documents in missing collection
bad_ecol_name = generate_col_name()
with pytest.raises(DocumentReplaceError):
bad_ecol = db.collection(bad_ecol_name)
bad_ecol.replace_match({'_key': '1'}, {'foo': 100})
def test_update_match():
# Set up test edges
ecol.insert_many(test_edges)
# Test update single matching document
assert ecol.update_match(
{'_key': '1'},
{'_to': 'foo'}
) == 1
assert ecol['1']['_to'] == 'foo'
assert ecol['1']['_from'] == edge1['_from']
# Test update multiple matching documents
assert ecol.update_match(
{'_from': col_name + '/1'},
{'foo': 'bar'}
) == 2
assert ecol['1']['foo'] == 'bar'
assert ecol['4']['foo'] == 'bar'
# Test update multiple matching documents with arguments
assert ecol.update_match(
{'_from': col_name + '/1'},
{'foo': None, 'bar': 'baz'},
limit=1,
sync=True,
keep_none=False
) == 1
assert ecol['1']['foo'] == 'bar'
assert 'foo' not in ecol['4']
assert ecol['4']['bar'] == 'baz'
# Test unaffected document
assert ecol['2']['_to'] == edge2['_to']
assert 'foo' not in ecol['2']
# Test update matching documents in missing collection
bad_ecol_name = generate_col_name()
with pytest.raises(DocumentUpdateError):
bad_ecol = db.collection(bad_ecol_name)
bad_ecol.update_match({'_key': '1'}, {'foo': 100})
def test_create_collection():
global col_name_2
# Test create duplicate collection
with pytest.raises(CollectionCreateError):
db.create_collection(col_name_1)
# Test create collection with parameters
col_name_2 = generate_col_name()
col = db.create_collection(name=col_name_2,
sync=True,
compact=False,
journal_size=7774208,
system=False,
volatile=False,
key_generator='autoincrement',
user_keys=False,
key_increment=9,
key_offset=100,
edge=True,
shard_count=2,
shard_fields=['test_attr'],
index_bucket_count=10,
replication_factor=1)
properties = col.properties()
assert 'id' in properties
assert properties['name'] == col_name_2
assert properties['sync'] is True
assert properties['compact'] is False
assert properties['journal_size'] == 7774208
assert properties['system'] is False
assert properties['volatile'] is False
assert properties['edge'] is True
assert properties['keygen'] == 'autoincrement'
assert properties['user_keys'] is False
assert properties['key_increment'] == 9
assert properties['key_offset'] == 100
def test_delete():
# Set up test edges
ecol.import_bulk(test_edges)
# Test delete (edge) with default options
result = ecol.delete(edge1)
assert result['_id'] == '{}/{}'.format(ecol.name, edge1['_key'])
assert result['_key'] == edge1['_key']
assert isinstance(result['_rev'], string_types)
assert result['sync'] is False
assert 'old' not in result
assert edge1['_key'] not in ecol
assert len(ecol) == 4
# Test delete (edge key) with default options
result = ecol.delete(edge2['_key'])
assert result['_id'] == '{}/{}'.format(ecol.name, edge2['_key'])
assert result['_key'] == edge2['_key']
assert isinstance(result['_rev'], string_types)
assert result['sync'] is False
assert 'old' not in result
assert edge2['_key'] not in ecol
assert len(ecol) == 3
# Test delete (edge) with return_old
result = ecol.delete(edge3, return_old=True)
assert result['_id'] == '{}/{}'.format(ecol.name, edge3['_key'])
assert result['_key'] == edge3['_key']
assert isinstance(result['_rev'], string_types)
assert result['sync'] is False
assert result['old']['_key'] == edge3['_key']
assert result['old']['_to'] == edge3['_to']
assert result['old']['_from'] == edge3['_from']
assert edge3['_key'] not in ecol
assert len(ecol) == 2
# Test delete (edge key) with sync
result = ecol.delete(edge4, sync=True)
assert result['_id'] == '{}/{}'.format(ecol.name, edge4['_key'])
assert result['_key'] == edge4['_key']
assert isinstance(result['_rev'], string_types)
assert result['sync'] is True
assert edge4['_key'] not in ecol
assert len(ecol) == 1
# Test delete (edge) with check_rev
rev = ecol[edge5['_key']]['_rev'] + '000'
bad_edge = edge5.copy()
bad_edge.update({'_rev': rev})
with pytest.raises(ArangoError):
ecol.delete(bad_edge, check_rev=True)
assert bad_edge['_key'] in ecol
assert len(ecol) == 1
# Test delete (edge) with check_rev
assert ecol.delete(edge4, ignore_missing=True) is False
with pytest.raises(DocumentDeleteError):
ecol.delete(edge4, ignore_missing=False)
assert len(ecol) == 1
# Test delete with missing edge collection
bad_col = generate_col_name()
with pytest.raises(DocumentDeleteError):
db.collection(bad_col).delete(edge5)
bad_col = generate_col_name()
with pytest.raises(DocumentDeleteError):
db.collection(bad_col).delete(edge5['_key'])
DocumentDeleteError,
DocumentInsertError,
DocumentReplaceError,
DocumentRevisionError,
DocumentUpdateError,
)
from tests.utils import (
generate_db_name,
generate_col_name,
)
arango_client = ArangoClient()
db_name = generate_db_name()
db = arango_client.create_database(db_name)
ecol_name = generate_col_name()
ecol = db.create_collection(ecol_name, edge=True)
ecol.add_geo_index(['coordinates'])
# Set up test collection and edges
col_name = generate_col_name()
db.create_collection(col_name).import_bulk([
{'_key': '1'}, {'_key': '2'}, {'_key': '3'}, {'_key': '4'}, {'_key': '5'}
])
edge1 = {'_key': '1', '_from': col_name + '/1', '_to': col_name + '/2'}
edge2 = {'_key': '2', '_from': col_name + '/2', '_to': col_name + '/3'}
edge3 = {'_key': '3', '_from': col_name + '/3', '_to': col_name + '/4'}
edge4 = {'_key': '4', '_from': col_name + '/1', '_to': col_name + '/1'}
edge5 = {'_key': '5', '_from': col_name + '/5', '_to': col_name + '/3'}
test_edges = [edge1, edge2, edge3, edge4, edge5]
test_edge_keys = [e['_key'] for e in test_edges]
ServerRoleError,
ServerSleepError,
ServerStatisticsError,
ServerTimeError,
ServerVersionError,
)
from tests.utils import (generate_db_name, generate_col_name,
generate_graph_name, arango_version)
arango_client = ArangoClient()
db_name = generate_db_name()
db = arango_client.create_database(db_name)
bad_db_name = generate_db_name()
bad_db = arango_client.db(bad_db_name)
col_name_1 = generate_col_name()
col_name_2 = ''
db.create_collection(col_name_1)
graph_name = generate_graph_name()
db.create_graph(graph_name)
def teardown_module(*_):
arango_client.delete_database(db_name, ignore_missing=True)
@pytest.mark.order1
def test_properties():
assert db.name == db_name
assert repr(db) == '<ArangoDB database "{}">'.format(db_name)
from arango import ArangoClient
from arango.aql import AQL
from arango.collections.standard import Collection
from arango.exceptions import ArangoError
from arango.graph import Graph
from tests.utils import (
generate_db_name,
generate_col_name,
generate_graph_name
)
arango_client = ArangoClient()
db_name = generate_db_name()
db = arango_client.create_database(db_name)
col_name = generate_col_name()
col = db.create_collection(col_name)
graph_name = generate_graph_name()
graph = db.create_graph(graph_name)
vcol_name = generate_col_name()
graph.create_vertex_collection(vcol_name)
def teardown_module(*_):
arango_client.delete_database(db_name, ignore_missing=True)
@pytest.mark.order1
def test_async_object():
cluster = db.cluster(
shard_id=1,
def test_delete_many():
# Set up test edges
current_revs = {}
edges = [edge.copy() for edge in test_edges]
# Test delete_many (edges) with default options
ecol.import_bulk(edges)
results = ecol.delete_many(edges)
for result, key in zip(results, test_edge_keys):
assert result['_id'] == '{}/{}'.format(ecol.name, key)
assert result['_key'] == key
assert isinstance(result['_rev'], string_types)
assert result['sync'] is False
assert 'old' not in result
assert key not in ecol
current_revs[key] = result['_rev']
assert len(ecol) == 0
# Test delete_many (edge keys) with default options
ecol.import_bulk(edges)
results = ecol.delete_many(edges)
for result, key in zip(results, test_edge_keys):
assert result['_id'] == '{}/{}'.format(ecol.name, key)
assert result['_key'] == key
assert isinstance(result['_rev'], string_types)
assert result['sync'] is False
assert 'old' not in result
assert key not in ecol
current_revs[key] = result['_rev']
assert len(ecol) == 0
# Test delete_many (edges) with return_old
ecol.import_bulk(edges)
results = ecol.delete_many(edges, return_old=True)
for result, edge in zip(results, edges):
key = edge['_key']
assert result['_id'] == '{}/{}'.format(ecol.name, key)
assert result['_key'] == key
assert isinstance(result['_rev'], string_types)
assert result['sync'] is False
assert result['old']['_key'] == key
assert result['old']['_to'] == edge['_to']
assert result['old']['_from'] == edge['_from']
assert key not in ecol
current_revs[key] = result['_rev']
assert len(ecol) == 0
# Test delete_many (edge keys) with sync
ecol.import_bulk(edges)
results = ecol.delete_many(edges, sync=True)
for result, edge in zip(results, edges):
key = edge['_key']
assert result['_id'] == '{}/{}'.format(ecol.name, key)
assert result['_key'] == key
assert isinstance(result['_rev'], string_types)
assert result['sync'] is True
assert 'old' not in result
assert key not in ecol
current_revs[key] = result['_rev']
assert len(ecol) == 0
# Test delete_many (edges) with check_rev
ecol.import_bulk(edges)
for edge in edges:
edge['_rev'] = current_revs[edge['_key']] + '000'
results = ecol.delete_many(edges, check_rev=True)
for result, edge in zip(results, edges):
assert isinstance(result, DocumentRevisionError)
assert len(ecol) == 5
# Test delete_many (edges) with missing edges
ecol.truncate()
results = ecol.delete_many([{'_key': '6'}, {'_key': '7'}])
for result, edge in zip(results, edges):
assert isinstance(result, DocumentDeleteError)
assert len(ecol) == 0
# Test delete_many with missing edge collection
bad_ecol = generate_col_name()
with pytest.raises(DocumentDeleteError):
db.collection(bad_ecol).delete_many(edges)
bad_ecol = generate_col_name()
with pytest.raises(DocumentDeleteError):
db.collection(bad_ecol).delete_many(test_edge_keys)
from __future__ import absolute_import, unicode_literals
import pytest
from arango import ArangoClient
from arango.exceptions import (IndexListError, IndexCreateError,
IndexDeleteError)
from tests.utils import (generate_db_name, generate_col_name)
arango_client = ArangoClient()
db_name = generate_db_name()
db = arango_client.create_database(db_name)
col_name = generate_col_name()
col = db.create_collection(col_name)
bad_col_name = generate_col_name()
bad_col = db.collection(bad_col_name)
col.add_geo_index(['coordinates'])
def teardown_module(*_):
arango_client.delete_database(db_name, ignore_missing=True)
def setup_function(*_):
col.truncate()
def test_list_indexes():
expected_index = {
'id': '0',
from arango import ArangoClient
from arango.exceptions import (PregelJobCreateError, PregelJobGetError,
PregelJobDeleteError)
from tests.utils import (
generate_db_name,
generate_col_name,
generate_graph_name,
)
arango_client = ArangoClient()
db_name = generate_db_name()
db = arango_client.create_database(db_name)
graph_name = generate_graph_name()
graph = db.create_graph(graph_name)
from_col_name = generate_col_name()
to_col_name = generate_col_name()
edge_col_name = generate_col_name()
graph.create_vertex_collection(from_col_name)
graph.create_vertex_collection(to_col_name)
graph.create_edge_definition(edge_col_name, [from_col_name], [to_col_name])
def teardown_module(*_):
arango_client.delete_database(db_name, ignore_missing=True)
@pytest.mark.order1
def test_start_pregel_job():
# Test start_pregel_job with page rank algorithm (happy path)
job_id = db.create_pregel_job('pagerank', graph_name)
