Convert Users, Roles, WorkspaceUsers, TaskOrders to use classmethods

tests/domain/test_roles.py

@@ -3,21 +3,16 @@ from atst.domain.roles import Roles
 from atst.domain.exceptions import NotFoundError
 
 
-@pytest.fixture()
-def roles_repo(session):
-    return Roles(session)
-
-
-def test_get_all_roles(roles_repo):
-    roles = roles_repo.get_all()
+def test_get_all_roles():
+    roles = Roles.get_all()
     assert roles
 
 
-def test_get_existing_role(roles_repo):
-    role = roles_repo.get("developer")
+def test_get_existing_role():
+    role = Roles.get("developer")
     assert role.name == "developer"
 
 
-def test_get_nonexistent_role(roles_repo):
+def test_get_nonexistent_role():
     with pytest.raises(NotFoundError):
-        roles_repo.get("nonexistent")
+        Roles.get("nonexistent")

tests/domain/test_task_orders.py

@@ -6,10 +6,6 @@ from atst.domain.task_orders import TaskOrders
 from tests.factories import TaskOrderFactory
 
 
-@pytest.fixture()
-def task_orders(session):
-    return TaskOrders(session)
-
 @pytest.fixture(scope="function")
 def new_task_order(session):
     def make_task_order(**kwargs):
@@ -22,13 +18,13 @@ def new_task_order(session):
     return make_task_order
 
 
-def test_can_get_task_order(task_orders, new_task_order):
+def test_can_get_task_order(new_task_order):
     new_to = new_task_order(number="0101969F")
-    to = task_orders.get(new_to.number)
+    to = TaskOrders.get(new_to.number)
 
     assert to.id == to.id
 
 
-def test_nonexistent_task_order_raises(task_orders):
+def test_nonexistent_task_order_raises():
     with pytest.raises(NotFoundError):
-        task_orders.get("some fake number")
+        TaskOrders.get("some fake number")

tests/domain/test_users.py

@@ -5,69 +5,64 @@ from atst.domain.users import Users
 from atst.domain.exceptions import NotFoundError, AlreadyExistsError
 
 
-@pytest.fixture()
-def users_repo(session):
-    return Users(session)
-
-
 @pytest.fixture(scope="function")
 def user_id():
     return uuid4()
 
 
-def test_create_user(users_repo, user_id):
-    user = users_repo.create(user_id, "developer")
+def test_create_user(user_id):
+    user = Users.create(user_id, "developer")
     assert user.id == user_id
 
 
-def test_create_user_with_nonexistent_role(users_repo, user_id):
+def test_create_user_with_nonexistent_role(user_id):
     with pytest.raises(NotFoundError):
-        users_repo.create(user_id, "nonexistent")
+        Users.create(user_id, "nonexistent")
 
 
-def test_create_already_existing_user(users_repo, user_id):
-    users_repo.create(user_id, "developer")
+def test_create_already_existing_user(user_id):
+    Users.create(user_id, "developer")
     with pytest.raises(AlreadyExistsError):
-        users_repo.create(user_id, "developer")
+        Users.create(user_id, "developer")
 
 
-def test_get_or_create_nonexistent_user(users_repo, user_id):
-    user = users_repo.get_or_create(user_id, atat_role_name="developer")
+def test_get_or_create_nonexistent_user(user_id):
+    user = Users.get_or_create(user_id, atat_role_name="developer")
     assert user.id == user_id
 
 
-def test_get_or_create_existing_user(users_repo, user_id):
-    users_repo.get_or_create(user_id, atat_role_name="developer")
-    user = users_repo.get_or_create(user_id, atat_role_name="developer")
+def test_get_or_create_existing_user(user_id):
+    Users.get_or_create(user_id, atat_role_name="developer")
+    user = Users.get_or_create(user_id, atat_role_name="developer")
     assert user
 
 
-def test_get_user(users_repo, user_id):
-    users_repo.create(user_id, "developer")
-    user = users_repo.get(user_id)
+def test_get_user(user_id):
+    Users.create(user_id, "developer")
+    user = Users.get(user_id)
     assert user.id == user_id
 
 
-def test_get_nonexistent_user(users_repo, user_id):
-    users_repo.create(user_id, "developer")
+def test_get_nonexistent_user(user_id):
+    Users.create(user_id, "developer")
     with pytest.raises(NotFoundError):
-        users_repo.get(uuid4())
+        Users.get(uuid4())
 
 
-def test_update_user(users_repo, user_id):
-    users_repo.create(user_id, "developer")
-    updated_user = users_repo.update(user_id, "ccpo")
+def test_update_user(user_id):
+    Users.create(user_id, "developer")
+    updated_user = Users.update(user_id, "ccpo")
 
     assert updated_user.atat_role.name == "ccpo"
 
 
-def test_update_nonexistent_user(users_repo, user_id):
-    users_repo.create(user_id, "developer")
+def test_update_nonexistent_user(user_id):
+    Users.create(user_id, "developer")
     with pytest.raises(NotFoundError):
-        users_repo.update(uuid4(), "ccpo")
+        Users.update(uuid4(), "ccpo")
 
 
-def test_update_existing_user_with_nonexistent_role(users_repo, user_id):
-    users_repo.create(user_id, "developer")
+def test_update_existing_user_with_nonexistent_role(user_id):
+    Users.create(user_id, "developer")
     with pytest.raises(NotFoundError):
-        users_repo.update(user_id, "nonexistent")
+        Users.update(user_id, "nonexistent")

tests/domain/test_workspace_users.py

@@ -5,37 +5,27 @@ from atst.domain.workspace_users import WorkspaceUsers
 from atst.domain.users import Users
 
 
-@pytest.fixture()
-def users_repo(session):
-    return Users(session)
-
-
-@pytest.fixture()
-def workspace_users_repo(session):
-    return WorkspaceUsers(session)
-
-
-def test_can_create_new_workspace_user(users_repo, workspace_users_repo):
+def test_can_create_new_workspace_user():
     workspace_id = uuid4()
-    user = users_repo.create(uuid4(), "developer")
+    user = Users.create(uuid4(), "developer")
 
     workspace_user_dicts = [{"id": user.id, "workspace_role": "owner"}]
 
-    workspace_users = workspace_users_repo.add_many(workspace_id, workspace_user_dicts)
+    workspace_users = WorkspaceUsers.add_many(workspace_id, workspace_user_dicts)
 
     assert workspace_users[0].user.id == user.id
     assert workspace_users[0].user.atat_role.name == "developer"
     assert workspace_users[0].workspace_role.role.name == "owner"
 
 
-def test_can_update_existing_workspace_user(users_repo, workspace_users_repo):
+def test_can_update_existing_workspace_user():
     workspace_id = uuid4()
-    user = users_repo.create(uuid4(), "developer")
+    user = Users.create(uuid4(), "developer")
 
-    workspace_users_repo.add_many(
+    WorkspaceUsers.add_many(
         workspace_id, [{"id": user.id, "workspace_role": "owner"}]
     )
-    workspace_users = workspace_users_repo.add_many(
+    workspace_users = WorkspaceUsers.add_many(
         workspace_id, [{"id": user.id, "workspace_role": "developer"}]
     )