def test_get_client_authorization_http_signature(self, mock_repository,
mock_get):
expected_client_id = 'my-client-id'
mock_repository.return_value = None
client_authorization_metadata = Collection("client_authorization",
"client_id")
document = {
"client_id": expected_client_id,
"type": "http_signature",
"public_key": "my-public-key",
"client_scopes": [{
"collection_name": "example",
"scope_type": "GET"
}]
}
expected_model = Model(client_authorization_metadata, document)
mock_get.return_value = expected_model
result = self.systemService.get_client_authorization(
expected_client_id)
self.assertTrue(mock_get.called_with(expected_client_id))
self.assertEqual(expected_client_id, result.client_id)
self.assertIsInstance(result, ClientAuthorizationHttpSignature)
self.assertEqual("my-public-key", result.client_public_key)
self.assertEqual(1, len(result.client_scopes))
self.assertEqual("example", result.client_scopes[0].collection_name)
self.assertEqual("GET", result.client_scopes[0].scope_type.name)
def test_create_authorization_http_signature(self, mock_repository,
mock_create):
expected_client_id = "test"
client_authorization = ClientAuthorizationHttpSignature(
expected_client_id, [Scope("example", ScopesType.CREATE)],
"my-public-key")
client_authorization_metadata = Collection("client_authorization",
"client_id")
mock_repository.return_value = None
document = {
"type":
"http_signature",
"client_id":
expected_client_id,
"client_scopes": [{
"collection_name": "example",
"scope_type": "CREATE"
}],
"public_key":
"my-public-key"
}
mock_create.return_value = Model(client_authorization_metadata,
document)
result = self.systemService.create_client_authorization(
client_authorization)
self.assertEqual(result.client_id, client_authorization.client_id)
self.assertTrue(isinstance(result, ClientAuthorizationHttpSignature))
self.assertEqual(call(document), mock_create.call_args_list[0])
def test_getSystemCollectionmetadata(self, mock_system_service, mock_get_system_collection):
mock_system_service.return_value = None
mock_get_system_collection.return_value = Collection("example", "id", "ordering")
collection_metadata = get("collection", "example")
self.assertDictEqual(collection_metadata,
dict(id_key="id", name="example", ordering_key="ordering", attribute_definition=None, auto_generate_id=False))
self.assertTrue(mock_get_system_collection.called_with("example"))
def test_queryCollectionByName(self, mock_index_dynamoplus_repository,
mock_find):
collection_metadata = Collection("example", "name")
expected_query = Query(Eq("name", "example"), collection_metadata)
mock_index_dynamoplus_repository.return_value = None
mock_find.return_value = QueryResult([
Model(Collection("example", "id"), {
"name": "example",
"id_key": "id"
})
])
collections = self.systemService.find_collections_by_example(
collection_metadata)
self.assertTrue(len(collections) == 1)
self.assertEqual(collections[0].name, "example")
self.assertEqual(call(expected_query), mock_find.call_args_list[0])
def test_model(self):
collection = Collection("example", "id", None)
document = {"id": "randomId"}
model = Model(collection, document)
self.assertEqual(model.pk(), "example#randomId")
self.assertEqual(model.sk(), "example")
self.assertEqual(model.data(), "randomId")
self.assertIsNone(model.order_value())
def from_dict_to_collection(d: dict):
attributes = list(map(from_dict_to_attribute_definition,
d["attributes"])) if "attributes" in d else None
auto_generate_id = d[
"auto_generate_id"] if "auto_generate_id" in d else False
return Collection(d["name"], d["id_key"],
d["ordering"] if "ordering" in d else None, attributes,
auto_generate_id)
def test_query_model_range(self):
collection = Collection("example", "id", "ordering")
query_model = QueryModel(collection, Range("field1", "value1",
"value2"))
self.assertIsNone(query_model.pk())
self.assertEqual("example#field1", query_model.sk())
self.assertEqual(2, len(query_model.data()))
self.assertEqual("value1", query_model.data()[0])
self.assertEqual("value2", query_model.data()[1])
def test_indexModelWithNoValue(self):
collection = Collection("example", "id", "ordering")
document = {}
index = None
model = IndexModel(collection, document, None)
self.assertEqual(model.pk(), None)
self.assertEqual(model.sk(), "example")
self.assertEqual(model.data(), None)
self.assertEqual(model.order_value(), None)
def test_modelWithOrdering(self):
# documentConfiguration = DocumentTypeConfiguration("example","id","ordering")
collection = Collection("example", "id", "ordering")
document = {"id": "randomId", "ordering": "123456"}
model = Model(collection, document)
self.assertEqual(model.pk(), "example#randomId")
self.assertEqual(model.sk(), "example")
self.assertEqual(model.data(), "123456")
self.assertEqual(model.order_value(), "123456")
def test_createCollection(self, mock_repository, mock_create):
expected_id = 'example'
target_collection = {
"name": "example",
"id_key": "id",
"ordering": None,
"auto_generate_id": False
}
document = {"name": expected_id, "id_key": "id"}
collection_metadata = Collection("collection", "name")
expected_model = Model(collection_metadata, document)
mock_repository.return_value = None
mock_create.return_value = expected_model
target_metadata = Collection("example", "id")
created_collection = self.systemService.create_collection(
target_metadata)
collection_id = created_collection.name
self.assertEqual(collection_id, expected_id)
self.assertEqual(call(target_collection),
mock_create.call_args_list[0])
def fake_query_result(self, uid, next=None):
return QueryResult([
Model(
Collection("index", "name"), {
"uid": uid,
"name": "collection.name",
"collection": {
"name": "example" + uid
},
"conditions": ["collection.name"]
})
], next)
def test_queryIndex_by_CollectionByName(self,
mock_index_dynamoplus_repository,
mock_find):
expected_query = Query(Eq("collection.name", "example"),
Collection("index", "uid"))
mock_index_dynamoplus_repository.return_value = None
mock_find.return_value = QueryResult([
Model(
Collection("index", "name"), {
"uid": "1",
"name": "collection.name",
"collection": {
"name": "example"
},
"conditions": ["collection.name"]
})
])
indexes, last_key = self.systemService.find_indexes_from_collection_name(
"example")
self.assertEqual(1, len(indexes))
self.assertEqual(indexes[0].uid, "1")
self.assertEqual(indexes[0].index_name, "collection.name")
self.assertEqual(call(expected_query), mock_find.call_args_list[0])
def test_getCollection(self, mock_repository, mock_get):
expected_id = 'example'
mock_repository.return_value = None
collection_metadata = Collection("collection", "name")
document = {
"name": expected_id,
"id_key": expected_id,
"fields": [{
"field1": "string"
}]
}
expected_model = Model(collection_metadata, document)
mock_get.return_value = expected_model
result = self.systemService.get_collection_by_name(expected_id)
# self.assertIn("fields",result)
self.assertTrue(mock_get.called_with(expected_id))
def test_indexModel(self):
collection = Collection("example", "id", None)
document = {
"id": "randomId",
"attr1": "value2",
"nested": {
"condition": {
"1": "value1"
}
}
}
index = Index("1", "example", ["nested.condition.1", "attr1"], None)
model = IndexModel(collection, document, index)
self.assertEqual(model.pk(), "example#randomId")
self.assertEqual(model.sk(), "example#nested.condition.1#attr1")
self.assertEqual(model.data(), "value1#value2")
self.assertIsNone(model.order_value())
def test_queryIndex_by_CollectionByName_generator(
self, mock_index_dynamoplus_repository, mock_find):
expected_query = Query(Eq("collection.name", "example"),
Collection("index", "uid"), 2)
mock_index_dynamoplus_repository.return_value = None
mock_find.side_effect = [
self.fake_query_result("1", "2"),
self.fake_query_result("2", "3"),
self.fake_query_result("3", "4"),
self.fake_query_result("4", "5"),
self.fake_query_result("5"),
]
indexes = self.systemService.get_indexes_from_collection_name_generator(
"example", 2)
uids = list(map(lambda i: i.uid, indexes))
self.assertEqual(5, len(uids))
self.assertEqual(["1", "2", "3", "4", "5"], uids)
self.assertEqual(call(expected_query), mock_find.call_args_list[0])
def test_get_documents_by_index(self, mock_system_service, mock_get_collection_by_name, mock_get_index,
mock_domain_service, mock_find_by_index):
mock_system_service.return_value = None
mock_get_collection_by_name.return_value = Collection("example", "id", "ordering")
mock_domain_service.return_value = None
expected_index = Index("1","example", ["attribute1"])
expected_predicate = Eq("attribute1","1")
mock_get_index.return_value=expected_index
expected_document_example = {"attribute1": "1"}
expected_documents = [
{"id": "1", "attribute1": "1"},
{"id": "2", "attribute1": "1"}
]
mock_find_by_index.return_value = expected_documents, None
documents = query("example", {"matches": {"eq":{"field_name":"attribute1", "value":"1"}}})
self.assertEqual(len(documents), len(expected_documents))
self.assertTrue(mock_get_collection_by_name.called_with("example"))
self.assertTrue(mock_get_index.called_with("attribute1"))
self.assertEqual(call(expected_predicate, None, None), mock_find_by_index.call_args_list[0])
def test_createIndexWithNoOrdering(self, mock_repository, mock_create):
expected_id = 'field1__field2.field21'
expected_conditions = ["field1", "field2.field21"]
target_index = {
"uid": "1",
"name": expected_id,
"collection": {
"name": "example"
},
"conditions": expected_conditions,
"ordering_key": None
}
index_metadata = Collection("index", "name")
expected_model = Model(index_metadata, target_index)
mock_repository.return_value = None
mock_create.return_value = expected_model
index = Index("1", "example", expected_conditions)
created_index = self.systemService.create_index(index)
index_name = created_index.index_name
self.assertEqual(index_name, expected_id)
self.assertEqual(call(target_index), mock_create.call_args_list[0])
def test_get_client_authorization_api_key(self, mock_repository, mock_get):
expected_client_id = 'my-client-id'
mock_repository.return_value = None
client_authorization_metadata = Collection("client_authorization",
"client_id")
document = {
"client_id": expected_client_id,
"type": "api_key",
"api_key": "my_api_key",
"whitelist_hosts": ["*"],
"client_scopes": [{
"collection_name": "example",
"scope_type": "GET"
}]
}
expected_model = Model(client_authorization_metadata, document)
mock_get.return_value = expected_model
result = self.systemService.get_client_authorization(
expected_client_id)
self.assertTrue(mock_get.called_with(expected_client_id))
self.assertEqual(expected_client_id, result.client_id)
self.assertIsInstance(result, ClientAuthorizationApiKey)
def setUp(self):
os.environ["TEST_FLAG"] = "true"
os.environ["DYNAMODB_DOMAIN_TABLE"] = "example-domain"
self.dynamodb = boto3.resource("dynamodb")
self.dynamodb.create_table(TableName="example-domain",
KeySchema=[{
'AttributeName': 'pk',
'KeyType': 'HASH'
}, {
'AttributeName': 'sk',
'KeyType': 'RANGE'
}],
AttributeDefinitions=[{
'AttributeName': 'pk',
'AttributeType': 'S'
}, {
'AttributeName': 'sk',
'AttributeType': 'S'
}, {
'AttributeName': 'data',
'AttributeType': 'S'
}],
GlobalSecondaryIndexes=[{
'IndexName':
'sk-data-index',
'KeySchema': [{
'AttributeName': 'sk',
'KeyType': 'HASH'
}, {
'AttributeName': 'data',
'KeyType': 'RANGE'
}],
"Projection": {
"ProjectionType": "ALL"
}
}])
self.collection = Collection("example", "id", "ordering")
self.table = self.dynamodb.Table('example-domain')
def test_delete_authorization_http_signature(self, mock_repository,
mock_delete):
expected_client_id = "test"
client_authorization_metadata = Collection("client_authorization",
"client_id")
mock_repository.return_value = None
document = {
"type":
"http_signature",
"client_id":
expected_client_id,
"client_scopes": [{
"collection_name": "example",
"scope_type": "CREATE"
}],
"public_key":
"my-public-key"
}
mock_delete.return_value = Model(client_authorization_metadata,
document)
self.systemService.delete_authorization(expected_client_id)
self.assertEqual(call(expected_client_id),
mock_delete.call_args_list[0])
def test_query_model_any_match(self):
collection = Collection("example", "id", "ordering")
query_model = QueryModel(collection, AnyMatch())
self.assertIsNone(query_model.pk())
self.assertEqual("example", query_model.sk())
self.assertIsNone(query_model.data())
def test_collecton_metadata(self):
collection = Collection("collection", "name")
model = Model(collection, {"name": "example"})
self.assertEqual(model.pk(), "collection#example")
self.assertEqual(model.sk(), "collection")
self.assertEqual(model.data(), "example")
import logging
from typing import *
from dynamoplus.models.query.conditions import Predicate, And, Range, Eq, AnyMatch
from dynamoplus.repository.models import Query as QueryRepository
from dynamoplus.repository.repositories import DynamoPlusRepository, IndexDynamoPlusRepository
from dynamoplus.models.system.collection.collection import Collection, AttributeDefinition, AttributeType, \
AttributeConstraint
from dynamoplus.models.system.index.index import Index
from dynamoplus.models.system.client_authorization.client_authorization import ClientAuthorization, \
ClientAuthorizationApiKey, ClientAuthorizationHttpSignature, Scope, ScopesType
collectionMetadata = Collection("collection", "name")
index_metadata = Collection("index", "uid")
client_authorization_metadata = Collection("client_authorization", "client_id")
logger = logging.getLogger()
logger.setLevel(logging.INFO)
def from_collection_to_dict(collection_metadata: Collection):
result = {
"name": collection_metadata.name,
"id_key": collection_metadata.id_key
}
if collection_metadata.ordering_key:
result["ordering_key"] = collection_metadata.ordering_key
return result
def from_index_to_dict(index_metadata: Index):
def setUp(self):
self.exampleCollectionMetadata = Collection("example", "id",
"ordering")
self.domainService = DomainService(self.exampleCollectionMetadata)
import os
from typing import *
from dynamoplus.models.system.collection.collection import Collection
from dynamoplus.models.query.query import Query, Index
collectionMetadata = Collection("collection", "name")
indexMetadata = Collection("index", "uid")
systemCollections = {"collection": collectionMetadata, "index": indexMetadata}
class DynamoPlusService(object):
def __init__(self):
pass
@staticmethod
def is_system(collection_name):
system_entities = os.environ['ENTITIES']
return collection_name in system_entities.split(",")
@staticmethod
def build_index(index_str: str):
index_str_array = index_str.split("#")
document_type = index_str_array[0]
index_name = index_str_array[1]
parts1 = index_name.split("__ORDER_BY__")
conditions = parts1[0].split("__")
return Index(document_type,
conditions,
ordering_key=parts1[1] if len(parts1) > 1 else None)