def setup(self):
self.graph = create_app(testing=True)
self.user_store = self.graph.user_store
self.follower_relationship_store = self.graph.follower_relationship_store
self.username1 = "glen.runciter"
self.user1 = User(
username=self.username1,
email="*****@*****.**",
first_name="Glen",
last_name="Runciter",
title="Big Boss",
bio="Ubik-- get it today!",
)
self.username2 = "joe.chip"
self.user2 = User(
username=self.username2,
email="*****@*****.**",
first_name="Joe",
last_name="Chip",
title="Technician",
bio="Ubik-- get it today!",
)
self.context = SessionContext(self.graph)
self.context.recreate_all()
self.context.open()
with transaction():
self.user1.create()
self.user2.create()
def setup(self):
self.graph = create_object_graph(
"microcosm_eventsource",
root_path=join(dirname(__file__), pardir),
testing=True,
)
self.graph.use(
"sub_task_store",
"sub_task_event_store",
)
self.store = SubTaskRollUpStore(self.graph)
self.context = SessionContext(self.graph)
self.context.recreate_all()
self.context.open()
with transaction():
self.sub_task = SubTask().create()
self.sub_task_created_event = SubTaskEvent(
event_type=SubTaskEventType.CREATED,
sub_task_id=self.sub_task.id,
).create()
self.sub_task_assigned_event = SubTaskEvent(
assignee="Alice",
event_type=SubTaskEventType.ASSIGNED,
parent_id=self.sub_task_created_event.id,
sub_task_id=self.sub_task.id,
).create()
def test_transition_to_revised(self):
with SessionContext(self.graph), transaction():
reassigned_event = list(islice(self.iter_events(), 4))[-1]
assert_that(reassigned_event.event_type,
is_(equal_to(TaskEventType.STARTED)))
response = self.client.post(
"/api/v1/task_event",
data=dumps(
dict(
taskId=str(self.task.id),
eventType=TaskEventType.REVISED.name,
)),
)
assert_that(response.status_code, is_(equal_to(201)))
data = loads(response.data.decode("utf-8"))
assert_that(data, has_entry("taskId", str(self.task.id)))
assert_that(data, has_entry("clock", 5))
assert_that(data, has_entry("parentId", str(reassigned_event.id)))
assert_that(data, has_entry("version", 2))
self.graph.sns_producer.produce.assert_called_with(
media_type=
"application/vnd.globality.pubsub._.created.task_event.revised",
uri="http://localhost/api/v1/task_event/{}".format(data["id"]),
)
with SessionContext(self.graph), transaction():
task_event = self.graph.task_event_store.retrieve(data["id"])
assert_that(task_event.state, is_(contains(TaskEventType.CREATED)))
def setup(self):
self.graph = create_app(testing=True)
self.tweet_store = self.graph.tweet_store
self.user_store = self.graph.user_store
self.username = "******"
self.user = User(
username=self.username,
email="*****@*****.**",
first_name="Joe",
last_name="Chip",
title="Technician",
bio="Ubik-- get it today!",
)
self.context = SessionContext(self.graph)
self.context.recreate_all()
self.context.open()
with transaction():
self.user_store.create(self.user)
self.tweet_content = """
Friends, this is clean-up time and we’re discounting all our silent,
electric Ubiks by this much money. Yes, we’re throwing away the blue-book.
And remember: every Ubik on our lot has been used only as directed.
"""
self.tweet = Tweet(
user_id=self.user.id,
tweet_content=self.tweet_content,
)
def setup(self):
self.graph = create_app(testing=True)
self.client = self.graph.flask.test_client()
recreate_all(self.graph)
self.username1 = "glen.runciter"
self.user1 = User(
username=self.username1,
email="*****@*****.**",
first_name="Glen",
last_name="Runciter",
title="Big Boss",
bio="Ubik-- get it today!",
)
self.username2 = "joe.chip"
self.user2 = User(
username=self.username2,
email="*****@*****.**",
first_name="Joe",
last_name="Chip",
title="Technician",
bio="Ubik-- get it today!",
)
with SessionContext(self.graph), transaction():
self.user1.create()
self.user2.create()
self.user1_follow_user2 = FollowerRelationship(
id=new_object_id(),
user_id=self.user2.id,
follower_id=self.user1.id,
)
self.user2_tweet_content1 = """
Friends, this is clean-up time and we’re discounting all our silent,
electric Ubiks by this much money. Yes, we’re throwing away the blue-book.
And remember: every Ubik on our lot has been used only as directed.
"""
self.user2_tweet_content2 = """
The best way to ask for beer is to sing out Ubik.
Made from select hops, choice water, slow-aged for perfect flavor,
Ubik is the nation’s number-one choice in beer. Made only in Cleveland.
"""
with SessionContext(self.graph), transaction():
self.user1_follow_user2.create()
self.user2_tweet1 = Tweet(
id=new_object_id(),
user_id=self.user2.id,
tweet_content=self.user2_tweet_content1,
).create()
self.user2_tweet2 = Tweet(
id=new_object_id(),
user_id=self.user2.id,
tweet_content=self.user2_tweet_content2,
).create()
def setup(self):
self.graph = create_object_graph(name="example", testing=True, import_name="microcosm_postgres")
self.company_store = self.graph.company_store
self.employee_store = self.graph.employee_store
self.context = SessionContext(self.graph)
self.context.recreate_all()
self.context.open()
def setup(self):
self.graph = create_object_graph(name="example",
testing=True,
import_name="microcosm_postgres")
self.context = SessionContext(self.graph)
self.context.recreate_all()
self.context.open()
self.store = Store(self.graph, Sequential)
def setup(self):
self.graph = create_object_graph(name="example",
testing=True,
import_name="microcosm_postgres")
self.graph.use("company_store")
context = SessionContext(self.graph)
context.recreate_all()
def setup(self):
self.graph = create_app(testing=True)
self.pizza_store = self.graph.pizza_store
self.name = "NAME"
self.context = SessionContext(self.graph)
self.context.recreate_all()
self.context.open()
def test_delete(self):
with SessionContext(self.graph), transaction():
self.order1.create()
response = self.client.delete(self.detail_uri)
assert_that(response.status_code, is_(equal_to(204)))
with SessionContext(self.graph) as session:
assert session.session.query(Order).get(self.order_id) is None
def setup(self):
self.graph = create_app(testing=True)
self.order_event_store = self.graph.order_event_store
self.order_id = new_object_id()
self.context = SessionContext(self.graph)
self.context.recreate_all()
self.context.open()
def setup(self):
self.graph = create_app(testing=True)
self.customer_event_store = self.graph.customer_event_store
self.pizza_store = self.graph.pizza_store
self.order_store = self.graph.order_store
self.topping_store = self.graph.topping_store
self.context = SessionContext(self.graph)
self.context.recreate_all()
self.context.open()
def setup(self):
self.graph = create_app(testing=True)
self.pizza_store = self.graph.pizza_store
self.order_store = self.graph.order_store
self.pizza_type = PizzaType.HANDTOSSED.name
self.pizza_size = PizzaSize.SMALL.name
self.context = SessionContext(self.graph)
self.context.recreate_all()
self.context.open()
def setup(self):
self.graph = create_app(testing=True)
self.user_store = self.graph.user_store
self.username = "******"
self.email = "*****@*****.**"
self.first_name = "Joe"
self.last_name = "Chip"
self.title = "Technician"
self.bio = "Ubik-- get it today!"
self.context = SessionContext(self.graph)
self.context.recreate_all()
self.context.open()
def test_update_with_key(self):
with SessionContext(self.graph):
with transaction():
encryptable = self.encryptable_store.create(
Encryptable(
key="private",
value="value",
),
)
with SessionContext(self.graph):
with transaction():
res = self.encryptable_store.update(
encryptable.id,
Encryptable(
id=encryptable.id,
# Pass the key
key="private",
value="new-value",
),
)
assert_that(
res,
has_properties(
key=is_(equal_to("private")),
value=is_(equal_to("new-value")),
encrypted_id=is_not(none()),
),
)
with SessionContext(self.graph):
encryptable = self.encryptable_store.retrieve(encryptable.id)
assert_that(
encryptable,
has_properties(
key=is_(equal_to("private")),
value=is_(equal_to("new-value")),
encrypted_id=is_not(none()),
),
)
assert_that(
self.encryptable_store.count(), is_(equal_to(1)),
)
assert_that(
self.encrypted_store.count(), is_(equal_to(1)),
)
def setup(self):
loader = load_from_dict(
secret=dict(postgres=dict(host=environ.get(
"MICROCOSM_EVENTSOURCE__POSTGRES__HOST", "localhost"), ), ),
postgres=dict(host=environ.get(
"MICROCOSM_EVENTSOURCE__POSTGRES__HOST", "localhost"), ),
sns_producer=dict(mock_sns=False, ),
)
self.graph = create_object_graph(
"microcosm_eventsource",
loader=loader,
root_path=dirname(__file__),
testing=True,
)
self.graph.use(
"session_factory",
"task_store",
"task_event_store",
"task_event_controller",
"task_crud_routes",
)
self.client = self.graph.flask.test_client()
recreate_all(self.graph)
with SessionContext(self.graph), transaction():
self.task = Task().create()
self.graph.sns_producer.sns_client.reset_mock()
def test_not_encrypted(self):
with SessionContext(self.graph):
with transaction():
encryptable = self.encryptable_store.create(
Encryptable(
key="key",
value="value",
), )
assert_that(
encryptable,
has_properties(
key=is_(equal_to("key")),
value=is_(equal_to("value")),
encrypted_id=is_(none()),
),
)
assert_that(
self.encryptable_store.count(),
is_(equal_to(1)),
)
assert_that(
self.encrypted_store.count(),
is_(equal_to(0)),
)
with transaction():
self.encryptable_store.delete(encryptable.id)
assert_that(
self.encryptable_store.count(),
is_(equal_to(0)),
)
def test_created_event(self):
created_event_id = new_object_id()
with patch.object(self.graph.task_event_store,
"new_object_id") as mocked:
mocked.return_value = created_event_id
response = self.client.post(
"/api/v1/task_event",
data=dumps(
dict(
taskId=str(self.task.id),
eventType=TaskEventType.CREATED.name,
parentId=str(self.task.id),
)),
)
assert_that(response.status_code, is_(equal_to(201)))
data = loads(response.data.decode("utf-8"))
assert_that(data, has_entry("id", str(created_event_id)))
assert_that(data, has_entry("taskId", str(self.task.id)))
assert_that(data, has_entry("clock", 1))
assert_that(data, has_entry("parentId", none()))
self.graph.sns_producer.produce.assert_called_with(
media_type=
"application/vnd.globality.pubsub._.created.task_event.created",
uri="http://localhost/api/v1/task_event/{}".format(data["id"]),
)
with SessionContext(self.graph), transaction():
task_event = self.graph.task_event_store.retrieve(data["id"])
assert_that(task_event.state, is_(contains(TaskEventType.CREATED)))
def test_search_task_events_by_clock(self):
with SessionContext(self.graph), transaction():
created_event = list(islice(self.iter_events(), 4))[-1]
assert_that(created_event.event_type,
is_(equal_to(TaskEventType.STARTED)))
descending_response = self.client.get(
"/api/v1/task_event?sort_by_clock=true", )
assert_that(descending_response.status_code, is_(equal_to(200)))
data = loads(descending_response.data.decode("utf-8"))
descending_order_clock_list = [
event['clock'] for event in data["items"]
]
assert_that(descending_order_clock_list, is_(equal_to([4, 3, 2, 1])))
ascending_response = self.client.get(
"/api/v1/task_event?sort_by_clock=true&sort_clock_in_ascending_order=true",
)
assert_that(ascending_response.status_code, is_(equal_to(200)))
data = loads(ascending_response.data.decode("utf-8"))
ascending_order_clock_list = [
event['clock'] for event in data["items"]
]
assert_that(ascending_order_clock_list, is_(equal_to([1, 2, 3, 4])))
invalid_response = self.client.get(
"/api/v1/task_event?sort_clock_in_ascending_order=true", )
assert_that(invalid_response.status_code, is_(equal_to(422)))
def test_create(self):
uri = "/api/v1/pizza"
with SessionContext(self.graph), transaction():
self.order.create()
customer_id = str(new_object_id())
with patch.object(self.graph.pizza_store, "new_object_id") as mocked:
mocked.return_value = self.pizza1.id
response = self.client.post(
uri,
json=dict(customerId=customer_id,
crustType="thin",
size=12,
orderId=self.order_id),
)
assert_that(response.status_code, is_(equal_to(201)))
assert_that(
response.json,
has_entries(
id=str(self.pizza1.id),
customerId=customer_id,
crustType="thin",
size=12,
),
)
def setup(self):
loaders = load_each(
load_from_dict(
multi_tenant_key_registry=dict(
context_keys=[
"private",
],
key_ids=[
"key_id",
],
),
),
load_from_environ,
)
self.graph = create_object_graph(
name="example",
testing=True,
import_name="microcosm_postgres",
loader=loaders,
)
self.encryptable_store = self.graph.encryptable_store
self.encrypted_store = self.graph.encrypted_store
self.json_encryptable_store = self.graph.json_encryptable_store
self.json_encrypted_store = self.graph.json_encrypted_store
self.nullable_encryptable_store = self.graph.nullable_encryptable_store
self.nullable_encrypted_store = self.graph.nullable_encrypted_store
self.encryptor = self.graph.multi_tenant_encryptor
with SessionContext(self.graph) as context:
context.recreate_all()
def test_clone(self):
with SessionContext(self.graph):
substitutions = dict(name="newname")
dag = DAG.from_nodes(self.company,
self.employee).clone(substitutions)
assert_that(dag.nodes, has_length(2))
assert_that(dag.edges, has_length(1))
def setup(self):
self.graph = create_object_graph(
name="example",
testing=True,
import_name="microcosm_postgres",
)
self.company_store = self.graph.company_store
self.companies = [
Company(
name="name1",
type=CompanyType.private,
),
Company(
name="name2",
type=CompanyType.private,
),
Company(
name="name3",
type=CompanyType.private,
),
]
with SessionContext(self.graph) as context:
context.recreate_all()
def _make_company(self):
with SessionContext(self.graph):
with transaction():
return Company(
name="name",
type=CompanyType.private,
).create()
def test_select_from_none(self):
with SessionContext(self.graph):
with transient(Company) as transient_company:
assert_that(
transient_company.select_from(Company),
contains(),
)
def setup(self):
self.graph = create_app(testing=True)
self.client = self.graph.flask.test_client()
recreate_all(self.graph)
with SessionContext(self.graph), transaction():
self.new_order = Order().create()
self.new_pizza = Pizza(
id=new_object_id(),
order_id=self.new_order.id,
pizza_size=PizzaSize.SMALL.name,
pizza_type=PizzaType.HANDTOSSED.name,
).create()
self.first_topping = Topping(
id=new_object_id(),
pizza_id=self.new_pizza.id,
topping_type=ToppingType.ONIONS,
)
self.second_topping = Topping(
id=new_object_id(),
pizza_id=self.new_pizza.id,
topping_type=ToppingType.CHICKEN,
)
def setup(self):
self.graph = create_object_graph(
"microcosm_eventsource",
root_path=join(dirname(__file__), pardir),
testing=True,
)
self.graph.use(
"simple_test_object_store",
"simple_test_object_event_store",
)
self.store = SimpleObjectTestRollupStore(self.graph)
self.event_store = self.graph.simple_test_object_event_store
self.context = SessionContext(self.graph)
self.context.recreate_all()
self.context.open()
def setup(self):
self.graph = create_object_graph(name="example", testing=True, import_name="microcosm_postgres")
self.company_store = self.graph.company_store
self.context = SessionContext(self.graph)
self.context.recreate_all()
self.context.open()
def setup(self):
self.graph = create_object_graph(
"microcosm_eventsource",
root_path=join(dirname(__file__), pardir),
testing=True,
)
self.graph.use(
"task_store",
"task_event_store",
"activity_store",
"activity_event_store",
)
self.store = self.graph.task_event_store
self.activity_store = self.graph.activity_event_store
self.context = SessionContext(self.graph)
self.context.recreate_all()
self.context.open()
with transaction():
self.task = Task().create()
self.created_event = TaskEvent(
event_type=TaskEventType.CREATED,
task_id=self.task.id,
).create()
self.scheduled_event = TaskEvent(
deadline=datetime.utcnow(),
event_type=TaskEventType.SCHEDULED,
parent_id=self.created_event.id,
state=[TaskEventType.CREATED, TaskEventType.SCHEDULED],
task_id=self.task.id,
).create()
self.assigned_event = TaskEvent(
deadline=datetime.utcnow(),
event_type=TaskEventType.ASSIGNED,
parent_id=self.scheduled_event.id,
state=[TaskEventType.ASSIGNED, TaskEventType.CREATED, TaskEventType.SCHEDULED],
assignee="assignee",
task_id=self.task.id,
).create()
self.started_event = TaskEvent(
event_type=TaskEventType.STARTED,
parent_id=self.assigned_event.id,
task_id=self.task.id,
).create()
# flush sqlalchemy cache before sql operation
self.store.session.expire_all()
def test_delete(self):
with SessionContext(self.graph), transaction():
self.example1.create()
uri = f"/api/v1/example/{self.example1.id}"
response = self.client.delete(uri)
assert_that(response.status_code, is_(equal_to(204)))
def setup(self):
self.graph = create_app(testing=True)
self.account_store = self.graph.account_store
self.name = "NAME"
with SessionContext(self.graph) as context:
context.recreate_all()
def setup(self):
self.graph = create_app(testing=True)
self.example_store = self.graph.example_store
self.name = "NAME"
self.context = SessionContext(self.graph)
self.context.recreate_all()
self.context.open()
def setup(self):
self.graph = create_object_graph(name="example", testing=True, import_name="microcosm_postgres")
self.company_store = self.graph.company_store
self.employee_store = self.graph.employee_store
self.context = SessionContext(self.graph)
self.context.recreate_all()
self.context.open()
with transaction():
self.company = Company(
name="name"
).create()
class TestCloning:
def setup(self):
self.graph = create_object_graph(name="example", testing=True, import_name="microcosm_postgres")
self.company_store = self.graph.company_store
self.context = SessionContext(self.graph)
self.context.recreate_all()
self.context.open()
def teardown(self):
self.context.close()
self.graph.postgres.dispose()
def test_clone(self):
with transaction():
company = Company(
name="name",
type=CompanyType.private,
).create()
copy = clone(company, dict(name="newname"))
assert_that(copy.id, is_not(equal_to(company.id)))
assert_that(self.company_store.retrieve(copy.id), is_(not_none()))
class TestEmployeeStore:
def setup(self):
self.graph = create_object_graph(name="example", testing=True, import_name="microcosm_postgres")
self.company_store = self.graph.company_store
self.employee_store = self.graph.employee_store
self.context = SessionContext(self.graph)
self.context.recreate_all()
self.context.open()
with transaction():
self.company = Company(
name="name"
).create()
def teardown(self):
self.context.close()
self.graph.postgres.dispose()
def test_create(self):
"""
Should be able to retrieve an employee after creating it.
"""
with transaction():
employee = Employee(
first="first",
last="last",
company_id=self.company.id,
).create()
retrieved_employee = Employee.retrieve(employee.id)
assert_that(retrieved_employee.first, is_(equal_to("first")))
assert_that(retrieved_employee.last, is_(equal_to("last")))
def test_create_requires_foreign_key(self):
"""
Should not be able to create an employee without a company.
"""
employee = Employee(
first="first",
last="last",
)
assert_that(calling(employee.create), raises(ModelIntegrityError))
def test_update(self):
"""
Should be able to update an employee after creating it.
"""
with transaction():
employee = Employee(
first="first",
last="last",
company_id=self.company.id,
).create()
with transaction():
updated_employee = Employee(
id=employee.id,
first="Jane",
last="Doe",
).update()
assert_that(updated_employee.first, is_(equal_to("Jane")))
assert_that(updated_employee.last, is_(equal_to("Doe")))
assert_that(updated_employee.company_id, is_(equal_to(self.company.id)))
with transaction():
retrieved_employee = Employee.retrieve(employee.id)
assert_that(retrieved_employee.first, is_(equal_to("Jane")))
assert_that(retrieved_employee.last, is_(equal_to("Doe")))
assert_that(Employee.count(), is_(equal_to(1)))
def test_update_with_diff(self):
"""
Should be able to update an employee after creating it and get a diff.
"""
with transaction():
employee = Employee(
first="first",
last="last",
company_id=self.company.id,
).create()
with transaction():
_, diff = Employee(
id=employee.id,
last="Doe",
).update_with_diff()
assert_that(list(diff.keys()), contains_inanyorder("last", "updated_at"))
assert_that(diff["last"].before, is_(equal_to("last")))
assert_that(diff["last"].after, is_(equal_to("Doe")))
with transaction():
retrieved_employee = Employee.retrieve(employee.id)
assert_that(retrieved_employee.first, is_(equal_to("first")))
assert_that(retrieved_employee.last, is_(equal_to("Doe")))
assert_that(Employee.count(), is_(equal_to(1)))
def test_update_not_found(self):
"""
Should not be able to update an employee that does not exist.
"""
with transaction():
employee = Employee(
first="first",
last="last",
company_id=self.company.id,
)
assert_that(calling(employee.update), raises(ModelNotFoundError))
def test_replace(self):
"""
Should be able to replace an employee after creating it.
"""
with transaction():
employee = Employee(
first="first",
last="last",
company_id=self.company.id,
).create()
with transaction():
updated_employee = Employee(
id=employee.id,
first="Jane",
last="Doe",
).replace()
assert_that(updated_employee.first, is_(equal_to("Jane")))
assert_that(updated_employee.last, is_(equal_to("Doe")))
with transaction():
retrieved_employee = Employee.retrieve(employee.id)
assert_that(retrieved_employee.first, is_(equal_to("Jane")))
assert_that(retrieved_employee.last, is_(equal_to("Doe")))
assert_that(Employee.count(), is_(equal_to(1)))
def test_replace_not_found(self):
"""
Should be able to replace an employee that does not exist.
"""
with transaction():
employee = Employee(
first="first",
last="last",
company_id=self.company.id,
).replace()
with transaction():
retrieved_employee = Employee.retrieve(employee.id)
assert_that(retrieved_employee.first, is_(equal_to("first")))
assert_that(retrieved_employee.last, is_(equal_to("last")))
assert_that(Employee.count(), is_(equal_to(1)))
def test_search_by_company(self):
"""
Should be able to retrieve an employee after creating it.
"""
with transaction():
employee1 = Employee(
first="first",
last="last",
company_id=self.company.id,
).create()
employee2 = Employee(
first="Jane",
last="Doe",
company_id=self.company.id,
).create()
company2 = Company(
name="other",
).create()
employee3 = Employee(
first="John",
last="Doe",
company_id=company2.id,
).create()
assert_that(Employee.count(), is_(equal_to(3)))
assert_that(
[employee.last for employee in self.employee_store.search_by_company(self.company.id)],
contains("Doe", "last"),
)
assert_that(
[employee.id for employee in self.employee_store.search_by_company(self.company.id)],
contains_inanyorder(employee1.id, employee2.id)
)
assert_that(
[employee.id for employee in self.employee_store.search_by_company(company2.id)],
contains_inanyorder(employee3.id)
)
def test_search_by_company_kwargs(self):
"""
Should be able to filter searches using kwargs.
"""
with transaction():
employee1 = Employee(
first="first",
last="last",
company_id=self.company.id,
).create()
employee2 = Employee(
first="Jane",
last="Doe",
company_id=self.company.id,
).create()
company2 = Company(
name="other",
).create()
employee3 = Employee(
first="John",
last="Doe",
company_id=company2.id,
).create()
assert_that(Employee.count(), is_(equal_to(3)))
assert_that(
[employee.id for employee in self.employee_store.search(company_id=self.company.id, offset=0, limit=10)],
contains_inanyorder(employee1.id, employee2.id)
)
assert_that(self.employee_store.count(company_id=self.company.id, offset=0, limit=10), is_(equal_to(2)))
assert_that(
[employee.id for employee in self.employee_store.search(company_id=company2.id, offset=0, limit=10)],
contains_inanyorder(employee3.id)
)
assert_that(self.employee_store.count(company_id=company2.id, offset=0, limit=10), is_(equal_to(1)))
def test_search_first(self):
"""
Should be able to search for the first item with matching criteria after creation.
"""
with transaction():
Employee(
first="first",
last="last",
company_id=self.company.id,
).create()
Employee(
first="Jane",
last="Doe",
company_id=self.company.id,
).create()
retrieved_real_employee = self.employee_store.search_first(first="Jane")
assert_that(retrieved_real_employee.last, is_(equal_to("Doe")))
retrieved_fake_employee = self.employee_store.search_first(first="Tarzan")
assert_that(retrieved_fake_employee, is_(equal_to(None)))
class TestCompany:
def setup(self):
self.graph = create_object_graph(name="example", testing=True, import_name="microcosm_postgres")
self.company_store = self.graph.company_store
self.employee_store = self.graph.employee_store
self.context = SessionContext(self.graph)
self.context.recreate_all()
self.context.open()
def teardown(self):
self.context.close()
self.graph.postgres.dispose()
def test_create_retrieve_company(self):
"""
Should be able to retrieve a company after creating it.
"""
with transaction():
company = Company(
name="name",
type=CompanyType.private,
).create()
retrieved_company = Company.retrieve(company.id)
assert_that(retrieved_company.name, is_(equal_to("name")))
assert_that(retrieved_company.type, is_(equal_to(CompanyType.private)))
def test_search_company(self):
"""
Should be able to search for companies.
"""
with transaction():
company = Company(
name="name",
type=CompanyType.private,
).create()
assert_that(Company.search(), contains(company))
assert_that(Company.search(name="whatever"), is_(empty()))
assert_that(Company.search(name=company.name), contains(company))
# NB: filtering is skipped if None
assert_that(Company.search(name=None), contains(company))
def test_create_duplicate_company(self):
"""
Should not be able to retrieve a company with a duplicate name.
"""
with transaction():
Company(name="name").create()
company = Company(name="name")
assert_that(calling(company.create), raises(DuplicateModelError))
def test_create_delete_company(self):
"""
Should not be able to retrieve a company after deleting it.
"""
with transaction():
company = Company(name="name").create()
with transaction():
company.delete()
assert_that(
calling(Company.retrieve).with_args(company.id),
raises(ModelNotFoundError, pattern="Company not found"),
)
def test_create_search_count_company(self):
"""
Should be able to search and count companies after creation.
"""
with transaction():
company1 = Company(name="name1").create()
company2 = Company(name="name2").create()
assert_that(Company.count(), is_(equal_to(2)))
# Pagination fields do not affect count calculations
assert_that(self.company_store.count(offset=1, limit=1), is_(equal_to(2)))
assert_that([company.id for company in Company.search()], contains_inanyorder(company1.id, company2.id))
def test_create_update_company(self):
"""
Should be able to update a company after creating it.
"""
with transaction():
company = Company(
name="name",
).create()
with transaction():
updated_company = Company(
id=company.id,
name="new_name",
).update()
assert_that(updated_company.name, is_(equal_to("new_name")))
with transaction():
retrieved_company = Company.retrieve(company.id)
assert_that(retrieved_company.name, is_(equal_to("new_name")))
def test_create_update_with_diff_company(self):
"""
Should be able to update a company after creating it and get a diff.
"""
with transaction():
company = Company(name="name").create()
with transaction():
_, diff = Company(
id=company.id,
name="new_name",
).update_with_diff()
assert_that(list(diff.keys()), contains_inanyorder("name", "updated_at"))
assert_that(diff["name"].before, is_(equal_to("name")))
assert_that(diff["name"].after, is_(equal_to("new_name")))
with transaction():
retrieved_company = Company.retrieve(company.id)
assert_that(retrieved_company.name, is_(equal_to("new_name")))
def test_create_update_duplicate_company(self):
"""
Should be not able to update a company to a duplicate name.
"""
with transaction():
Company(name="name1").create()
company = Company(name="name2").create()
company.name = "name1"
assert_that(calling(company.update), raises(DuplicateModelError))
def test_delete_company_with_employees(self):
"""
Should be not able to delete a company with employees.
"""
with transaction():
Company(
name="name1",
).create()
company = Company(
name="name2",
).create()
with transaction():
Employee(
first="first",
last="last",
company_id=company.id,
).create()
assert_that(calling(company.delete), raises(ReferencedModelError))
class TestExamples:
def setup(self):
self.graph = create_app(testing=True)
self.example_store = self.graph.example_store
self.name = "NAME"
self.context = SessionContext(self.graph)
self.context.recreate_all()
self.context.open()
def teardown(self):
self.context.close()
self.graph.postgres.dispose()
def test_create(self):
"""
Examples can be persisted.
"""
new_example = Example(
name=self.name,
)
with transaction():
self.example_store.create(new_example)
retrieved_example = self.example_store.retrieve(new_example.id)
assert_that(retrieved_example, is_(equal_to(new_example)))
def test_create_duplicate(self):
"""
Examples enforce uniqueness on type/external id.
"""
example1 = Example(
name=self.name,
)
example2 = Example(
name=self.name,
)
with transaction():
self.example_store.create(example1)
assert_that(
calling(self.example_store.create).with_args(example2),
raises(DuplicateModelError),
)
def test_retrieve_by_name(self):
"""
Examples can be retrieved by name.
"""
new_example = Example(
name=self.name,
)
with transaction():
self.example_store.create(new_example)
retrieved_example = self.example_store.retrieve_by_name(
self.name
)
assert_that(retrieved_example, is_(equal_to(new_example)))
