def add(self, user: User):
self._users.append(user)
id = self.uuid_generator.make()
writerow(
self.csv_path,
[
id,
user.name,
user.status,
],
)
user.set_id(id)
def _from_csv(self) -> List[User]:
loaded_users = []
with self.csv_path.open("r") as f:
reader = csv.DictReader(f)
for row in reader:
loaded_users.append(User(**row))
return loaded_users
def test_create_new_user():
uuid_gen = CustomUuid()
user_repository = InMemoryUserRepository(uuid_generator=uuid_gen)
create_new_user = CreateNewUser(user_repository)
uuid_gen.set_next_uuid("pat_uuid")
create_new_user.execute(name="patrice", status="active")
assert len(user_repository.users) == 1
expected_user = User(uuid="pat_uuid", name="patrice", status="active")
assert user_repository.users == [expected_user]
def test_create_new_topic():
uuid_topic, uuid_user = '******', 'topic_user'
topic_name = "My first topic"
uuid = CustomUuid()
uuid.set_next_uuid(uuid_topic)
topic_repo = InMemoryTopicRepository(uuid_generator=uuid)
user = User(name='patrice', status='active', uuid=uuid_user)
create_new_topic = CreateNewTopic(topic_repository=topic_repo)
create_new_topic.execute(topic_name=topic_name, user=user)
created_topic = topic_repo.get_all()[0]
assert isinstance(created_topic, Topic), 'wrong type'
assert created_topic.topic_name == topic_name, 'wrong name'
assert created_topic.uuid == uuid_topic, "wrong uuid"
assert created_topic.author_uuid == user.uuid, "wrong user"
def test_can_get_all_topics_and_authors():
client = ndb.Client()
with client.context():
repo_topic = NDBTopicRepository()
repo_user = NDBUserRepository()
my_user = User(name='nathan malnoury', status='active')
repo_user.add(my_user)
my_topic = Topic(topic_name='ant', author_uuid=my_user.id)
repo_topic.add(my_topic)
async_operation = repo_topic.async_get_all_topics_and_authors(
user_repo=repo_user)
res = async_operation.result()
print(res)
def add(self, user: User):
ndb_user = UserNDB(name=user.name, status=user.status)
ndb_user.put()
user.set_id(ndb_user.id)
from google.cloud import ndb
from adapters.datastore.ndb_user_repository import NDBUserRepository
from domain.ports import User
user = User(name="patrice bertrand", status="active")
def test_can_add_user():
client = ndb.Client()
with client.context():
ndb_user_repository = NDBUserRepository()
number_users_before_add = len(ndb_user_repository.get_all())
ndb_user_repository.add(user)
assert len(ndb_user_repository.get_all()) == number_users_before_add + 1
def test_can_get_user():
client = ndb.Client()
with client.context():
ndb_user_repository = NDBUserRepository()
user_from_ndb = ndb_user_repository.get(user.id)
assert user_from_ndb == user
def test_can_get_all_users():
client = ndb.Client()
with client.context():
all_users = NDBUserRepository().get_all()
assert type(all_users) == list
assert len(all_users) > 0
import csv
from pathlib import Path
from adapters.csv_user_repository import CsvUserRepository
from domain.ports import User
from domain.ports.uuid import CustomUuid
from helpers.csv import reset_file_from_path
csv_path = Path("tests/integration/data") / "user_repo.csv"
user_example = User(name="patrice", status="contact")
def test_can_add_user():
reset_file_from_path(csv_path)
uuid = CustomUuid()
uuid.set_next_uuid("pat_uuid")
csv_user_repository = CsvUserRepository(csv_path=csv_path, uuid_generator=uuid)
csv_user_repository.add(user_example)
with csv_path.open("r") as f:
reader = csv.DictReader(f)
assert list(reader)[0] == {
"uuid": "pat_uuid",
"name": "patrice",
"status": "contact",
}
def test_can_get_user_if_exists():
reset_file_from_path(csv_path)
uuid = CustomUuid()
def to_user(self):
return User(name=self.name, status=self.status, uuid=self.id)
def get_all(self) -> List[User]:
s = self.table.select()
rows = self.connection.execute(s)
return [User(*row) for row in rows]
def get(self, uuid: str) -> User:
s = self.table.select().where(self.table.c.uuid == uuid)
rows = self.connection.execute(s)
return User(*list(rows)[0])
reset_db,
)
from adapters.postgres.pg_user_repository import PgUserRepository
from domain.ports import User
def prepare_db():
# test_pg_url = "postgresql://*****:*****@postgres:5432/xq-db"
engine = create_engine(
test_pg_url,
isolation_level="REPEATABLE READ",
)
reset_db(engine)
initialize_db(engine)
return engine
patrice_user = User(name="patrice", status="active", uuid="pat_uuid")
anne_user = User(name="anne", status="deleted", uuid="anne_uuid")
def test_get_from_pg_repo():
engine = prepare_db()
repo = PgUserRepository(
engine=engine,
table=user_table,
)
repo.add(patrice_user)
repo.add(anne_user)