def test_find_all_by_user_returns_all_expected_wallets(self, database):
user = User.create(first_name=self.first_name,
last_name=self.last_name,
email=self.email)
user2 = User.create(first_name=self.first_name,
last_name=self.last_name,
email='*****@*****.**')
wallet = Wallet.create(user, self.currency)
assert Wallet.query.count() == 1
assert Wallet.find_all_by_user(user2) == []
assert Wallet.find_all_by_user(user) == [wallet]
def test_finds_by_id_returns_the_expected_user(self, database):
user = User.create(first_name=self.first_name,
last_name=self.last_name,
email=self.email)
user2 = User.create(first_name=self.first_name,
last_name=self.last_name,
email='*****@*****.**')
wallet = Wallet.create(user, self.currency)
assert Wallet.query.count() == 1
assert Wallet.find_by_user_and_currency(user2, self.currency) is None
assert Wallet.find_by_user_and_currency(user, self.currency) == wallet
def test_creates_transaction_with_all_expected_attributes(self, database, transaction_type):
user = User.create(
first_name = self.first_name,
last_name = self.last_name,
email = self.email
)
wallet = Wallet.create(
user,
self.currency
)
transaction = Transaction.create(
wallet,
self.amount_cents,
transaction_type
)
assert Transaction.query.filter_by(
wallet_id = wallet.id
).count() == 1
assert Transaction.query.filter_by(
wallet_id = wallet.id
).first().id == transaction.id
assert transaction.id is not None
assert Transaction.query.filter_by(
wallet_id = wallet.id
).first().created_at == transaction.created_at
assert transaction.created_at is not None
assert transaction.type == transaction_type.name
assert transaction.amount_cents == self.amount_cents
def test_creates_user_authentication_details_with_all_expected_attributes(
self, database):
user = User.create(first_name=self.first_name,
last_name=self.last_name,
email=self.email)
user_authentication_detail = UserAuthenticationDetail.create(
user=user, email=self.email, password=self.password)
assert UserAuthenticationDetail.query.filter_by(
email=self.email).first().id == user_authentication_detail.id
assert user_authentication_detail.id is not None
assert UserAuthenticationDetail.query.filter_by(
email=self.email).first(
).created_at == user_authentication_detail.created_at
assert user_authentication_detail.created_at is not None
assert UserAuthenticationDetail.query.filter_by(
email=self.email).first(
).updated_at == user_authentication_detail.updated_at
assert user_authentication_detail.updated_at is not None
assert user_authentication_detail.email == self.email
assert user_authentication_detail.password != self.password
assert user_authentication_detail.password == hashing.hash(
self.password)
assert user_authentication_detail.user_id == user.id
def create_user(self):
user = User.find_by_email(self.email)
if user is None:
user = User.create(self.first_name, self.last_name, self.email)
return user
def test_finds_by_email_returns_the_expected_user(self, database):
user = User.create(first_name=self.first_name,
last_name=self.last_name,
email=self.email)
assert User.query.count() == 1
assert User.find_by_email('*****@*****.**') is None
assert User.find_by_email(self.email) == user
def test_finds_by_id_returns_the_expected_user(self, database):
user = User.create(first_name=self.first_name,
last_name=self.last_name,
email=self.email)
assert User.query.count() == 1
assert User.find_by_id(uuid.uuid4()) is None
assert User.find_by_id(user.id) == user
def test_does_not_create_wallet_with_duplicated_currency(self, database):
user = User.create(first_name=self.first_name,
last_name=self.last_name,
email=self.email)
wallet = Wallet.create(user, self.currency)
prev_count = Wallet.query.filter_by(user_id=user.id).count()
with pytest.raises(InvalidCurrency):
wallet = Wallet.create(user, self.currency)
assert Wallet.query.filter_by(user_id=user.id).count() == prev_count
def test_add_operation_modifies_wallet_balance_accordingly(
self, database, operation):
user = User.create(first_name=self.first_name,
last_name=self.last_name,
email=self.email)
wallet = Wallet.create(user, self.currency)
assert wallet.balance_cents == 0
wallet.add_operation(operation[0], operation[1])
assert wallet.balance_cents == operation[2]
def test_finds_by_id_returns_the_expected_user_authentication_detail(
self, database):
user = User.create(first_name=self.first_name,
last_name=self.last_name,
email=self.email)
user_authentication_detail = UserAuthenticationDetail.create(
user=user, email=self.email, password=self.password)
assert UserAuthenticationDetail.query.count() == 1
assert UserAuthenticationDetail.find_by_id(uuid.uuid4()) is None
assert UserAuthenticationDetail.find_by_id(
user_authentication_detail.id) == user_authentication_detail
def test_does_not_create_user_authentication_details_with_invalid_email(
self, database):
user = User.create(first_name=self.first_name,
last_name=self.last_name,
email=self.email)
prev_count = UserAuthenticationDetail.query.count()
with pytest.raises(InvalidUserAuthenticationDetails):
user_authentication_detail = UserAuthenticationDetail.create(
user=user, email=None, password=self.password)
assert UserAuthenticationDetail.query.count() == prev_count
def test_converts_user_to_dict(self, database):
user = User.create(first_name=self.first_name,
last_name=self.last_name,
email=self.email)
expected_dict = {
'first_name': user.first_name,
'last_name': user.last_name,
'email': user.email,
'updated_at': int(user.created_at.timestamp()),
'created_at': int(user.created_at.timestamp())
}
assert user.as_dict() == expected_dict
def test_finds_by_token_returns_the_expected_user_authentication_detail(
self, database):
user = User.create(first_name=self.first_name,
last_name=self.last_name,
email=self.email)
user_authentication_detail = UserAuthenticationDetail.create(
user=user, email=self.email, password=self.password)
user2 = User.create(first_name=self.first_name,
last_name=self.last_name,
email='*****@*****.**')
UserAuthenticationDetail.create(user=user2,
email='*****@*****.**',
password=self.password)
user_authentication_detail.generate_token()
assert UserAuthenticationDetail.query.count() == 2
assert UserAuthenticationDetail.find_by_token('') is None
assert UserAuthenticationDetail.find_by_token(None) is None
assert UserAuthenticationDetail.find_by_token(
user_authentication_detail.token) == user_authentication_detail
def test_as_dict_converts_wallet_into_expected_dict(self, database):
user = User.create(first_name=self.first_name,
last_name=self.last_name,
email=self.email)
wallet = Wallet.create(user, self.currency)
expected_dict = {
'id': wallet.id,
'currency': wallet.currency,
'balance_cents': wallet.balance_cents,
'updated_at': int(wallet.updated_at.timestamp()),
'created_at': int(wallet.created_at.timestamp())
}
assert wallet.as_dict() == expected_dict
def test_does_not_create_user_with_empty_mandatory_details(
self, database, invalid_detail):
prev_count = User.query.count()
with pytest.raises(InvalidUser):
user = User.create(
**{
**{
'first_name': self.first_name,
'last_name': self.last_name,
'email': self.email
},
**invalid_detail
})
assert User.query.count() == prev_count
def test_finds_by_email_and_password_returns_the_expected_user_authentication_detail(
self, database):
user = User.create(first_name=self.first_name,
last_name=self.last_name,
email=self.email)
user_authentication_detail = UserAuthenticationDetail.create(
user=user, email=self.email, password=self.password)
assert UserAuthenticationDetail.query.count() == 1
assert UserAuthenticationDetail.find_by_email_and_password(
self.email, 'nonexistingpswd') is None
assert UserAuthenticationDetail.find_by_email_and_password(
'*****@*****.**', self.password) is None
assert UserAuthenticationDetail.find_by_email_and_password(
self.email, self.password) == user_authentication_detail
def test_generate_token_for_existing_user(self, database):
with freeze_time("2000-10-19"):
user = User.create(first_name=self.first_name,
last_name=self.last_name,
email=self.email)
user_authentication_detail = UserAuthenticationDetail.create(
user=user, email=self.email, password=self.password)
assert user_authentication_detail.token is None
current_updated_at = user_authentication_detail.updated_at
user_authentication_detail.generate_token()
assert user_authentication_detail.token is not None
assert user_authentication_detail.updated_at is not None
assert user_authentication_detail.updated_at > current_updated_at
def test_converts_user_authentication_details_as_dict(self, database):
user = User.create(first_name=self.first_name,
last_name=self.last_name,
email=self.email)
user_authentication_detail = UserAuthenticationDetail.create(
user=user, email=self.email, password=self.password)
expected_dict = {
'id': user_authentication_detail.id,
'email': user_authentication_detail.email,
'updated_at':
int(user_authentication_detail.updated_at.timestamp()),
'created_at':
int(user_authentication_detail.created_at.timestamp())
}
assert user_authentication_detail.as_dict() == expected_dict
def test_creates_user_with_all_expected_attributes(self, database):
user = User.create(first_name=self.first_name,
last_name=self.last_name,
email=self.email)
assert User.query.filter_by(email=self.email).first().id == user.id
assert user.id is not None
assert User.query.filter_by(
email=self.email).first().created_at == user.created_at
assert user.created_at is not None
assert User.query.filter_by(
email=self.email).first().updated_at == user.updated_at
assert user.updated_at is not None
assert user.first_name == self.first_name
assert user.last_name == self.last_name
assert user.email == self.email
def test_find_all_transactions_with_valid_wallet(self, database):
user = User.create(
first_name = self.first_name,
last_name = self.last_name,
email = self.email
)
wallet = Wallet.create(
user,
self.currency
)
assert Transaction.find_all_by_wallet(wallet) == []
transaction = Transaction.create(
wallet,
self.amount_cents,
self.type
)
assert Transaction.find_all_by_wallet(wallet) == [transaction]
def test_creates_wallet_with_all_expected_attributes(self, database):
user = User.create(first_name=self.first_name,
last_name=self.last_name,
email=self.email)
wallet = Wallet.create(user, self.currency)
assert Wallet.query.filter_by(user_id=user.id).count() == 1
assert Wallet.query.filter_by(user_id=user.id).first().id == wallet.id
assert wallet.id is not None
assert Wallet.query.filter_by(
user_id=user.id).first().created_at == wallet.created_at
assert wallet.created_at is not None
assert Wallet.query.filter_by(
user_id=user.id).first().updated_at == wallet.updated_at
assert wallet.updated_at is not None
assert wallet.currency == self.currency.name
assert wallet.balance_cents == 0
def test_does_not_create_transaction_when_wallet_not_valid(self, database):
user = User.create(
first_name = self.first_name,
last_name = self.last_name,
email = self.email
)
wallet = Wallet(
id = uuid.uuid4(),
user_id = user.id,
currency = self.currency
)
prev_count = Transaction.query.count()
with pytest.raises(InvalidWallet):
transaction = Transaction.create(
wallet,
self.amount_cents,
self.type
)
assert Transaction.query.count() == prev_count
