def test_user_columns(app):
"""
Tests user columns' restrictions. Name must be unique and mandatory.
"""
# Uniqueness of uri
user_1 = _get_user(username="******", id=1)
user_2 = _get_user(username="******", id=1)
user_2.name = "janne"
with app.app_context():
db.session.add(user_1)
db.session.add(user_2)
with pytest.raises(IntegrityError):
db.session.commit()
db.session.rollback()
# Uniqueness of name
user_1 = _get_user(username="******", id=1)
user_2 = _get_user(username="******", id=2)
with app.app_context():
db.session.add(user_1)
db.session.add(user_2)
with pytest.raises(IntegrityError):
db.session.commit()
db.session.rollback()
# Not null name
user = _get_user()
with app.app_context():
user.name = None
db.session.add(user)
with pytest.raises(IntegrityError):
db.session.commit()
def test_errors(client):
"""
Test that the correct errors are raised in situations where they should be raised.
"""
#two bankaccounts with the same iban should raise IntegrityError
bankAccount1 = utils._get_bankAccount(iban="FI01", bankName="The bank")
bankAccount2 = utils._get_bankAccount(iban="FI01", bankName="The bank")
db.session.add(bankAccount1)
db.session.add(bankAccount2)
with pytest.raises(IntegrityError):
db.session.commit()
db.session.rollback()
#two users with the same username should raise IntegrityError
user1 = utils._get_user(username="******", password="******")
user2 = utils._get_user(username="******", password="******")
db.session.add(user1)
db.session.add(user2)
with pytest.raises(IntegrityError):
db.session.commit()
db.session.rollback()
#two categories with the same name should raise IntegrityError
category1 = utils._get_category(name="cat1")
category2 = utils._get_category(name="cat1")
db.session.add(category1)
db.session.add(category2)
with pytest.raises(IntegrityError):
db.session.commit()
db.session.rollback()
#creating two new users for transaction
user3 = utils._get_user(username="******", password="******")
user4 = utils._get_user(username="******", password="******")
db.session.add(user3)
db.session.add(user4)
db.session.commit()
#transaction with price other than float should raise StatementError
transaction = utils._get_transaction(price="en kerro",
dateTime=datetime.now(),
sender=user3,
receiver=user4,
category=[category1])
db.session.add(transaction)
with pytest.raises(StatementError):
db.session.commit()
db.session.rollback()
#transaction with dateTime other than datetime should raise StatementError
transaction = utils._get_transaction(price=9.99,
dateTime="en kerro",
sender=user3,
receiver=user4,
category=[category1])
db.session.add(transaction)
with pytest.raises(StatementError):
db.session.commit()
db.session.rollback()
def test_create_instances(client):
"""
Tests that we can create one instance of each model and save them to the
database using valid values for all columns. After creation, test that
everything can be found from database, and that all relationships have been
saved correctly.
"""
# Create everything
bankAccount1 = utils._get_bankAccount(iban="FI01", bankName="The bank")
bankAccount2 = utils._get_bankAccount(iban="FI02", bankName="The bank")
user1 = utils._get_user(username="******", password="******")
user2 = utils._get_user(username="******", password="******")
user1.bankAccount.append(bankAccount1)
user2.bankAccount.append(bankAccount2)
category1 = utils._get_category(name="cat1")
category2 = utils._get_category(name="cat2")
transaction = utils._get_transaction(price=3.50,
dateTime=datetime.now(),
sender=user1,
receiver=user2,
category=[category1])
db.session.add(bankAccount1)
db.session.add(bankAccount2)
db.session.add(user1)
db.session.add(user2)
db.session.add(category1)
db.session.add(category2)
db.session.add(transaction)
db.session.commit()
# Check that everything exists
assert BankAccount.query.count() == 2
assert User.query.count() == 2
assert Category.query.count() == 2
assert Transaction.query.count() == 1
db_bankAccounts = BankAccount.query.all()
db_users = User.query.all()
db_categories = Category.query.all()
db_transaction = Transaction.query.first()
# Check all relationships (both sides)
assert db_transaction.sender in db_users
assert db_transaction.receiver in db_users
for category in db_transaction.category:
assert category in db_categories
for bankAccount in db_transaction.sender.bankAccount:
assert bankAccount in db_bankAccounts
def test_component_mod(app):
"""
Tests the modification of component instance data
"""
# Modify
user = _get_user()
equip = _get_equipment()
component = _get_component()
with app.app_context():
db.session.add(user)
db.session.add(equip)
db.session.add(component)
db.session.commit()
component.name = "Ekakeula"
component.brand = "Rock Shox"
component.model = "Pike RTC3"
component.date_added = datetime(2019, 11, 21, 11, 20, 30)
component.date_retired = datetime(2020, 1, 1, 11, 20, 30)
db.session.commit()
component = Component.query.filter_by(category="Fork").first()
assert component.name == "Ekakeula"
assert component.brand == "Rock Shox"
assert component.model == "Pike RTC3"
assert str(component.date_added) == "2019-11-21 11:20:30"
assert str(component.date_retired) == "2020-01-01 11:20:30"
def test_delete_instances(client):
"""
Tests that instances behave correctly when deleted.
"""
#create instances:
#2 bankAccounts
#2 Users
#2 Categories
#1 Transaction
bankAccount1 = utils._get_bankAccount(iban="FI05", bankName="The bank")
bankAccount2 = utils._get_bankAccount(iban="FI06", bankName="The bank")
user1 = utils._get_user(username="******", password="******")
user2 = utils._get_user(username="******", password="******")
user1.bankAccount.append(bankAccount1)
user2.bankAccount.append(bankAccount2)
category1 = utils._get_category(name="cat3")
category2 = utils._get_category(name="cat4")
transaction = utils._get_transaction(price=9.99,
dateTime=datetime.now(),
sender=user1,
receiver=user2,
category=[category1])
db.session.add(bankAccount1)
db.session.add(bankAccount2)
db.session.add(user1)
db.session.add(user2)
db.session.add(category1)
db.session.add(category2)
db.session.add(transaction)
db.session.commit()
#delete instances:
#1 bankAccount
#1 User
#1 Category
#1 Transaction
db.session.delete(user1)
db.session.delete(bankAccount2)
db.session.delete(category2)
db.session.delete(transaction)
db.session.commit()
#after deleting should be only one instance of
#user, bankaccount, and category and no instances of transaction
assert BankAccount.query.count() == 1
assert User.query.count() == 1
assert Category.query.count() == 1
assert Transaction.query.count() == 0
def test_update_instances(client):
"""
First instances are created and then updated. Lastly the instances are checked to have the updated attributes.
"""
#create instances
bankAccount1 = utils._get_bankAccount(iban="FI03", bankName="The bank")
bankAccount2 = utils._get_bankAccount(iban="FI04", bankName="The bank")
user1 = utils._get_user(username="******", password="******")
user2 = utils._get_user(username="******", password="******")
user1.bankAccount.append(bankAccount1)
user2.bankAccount.append(bankAccount2)
category1 = utils._get_category(name="cat3")
category2 = utils._get_category(name="cat4")
transaction = utils._get_transaction(price=9.99,
dateTime=datetime.now(),
sender=user1,
receiver=user2,
category=[category1])
db.session.add(bankAccount1)
db.session.add(bankAccount2)
db.session.add(user1)
db.session.add(user2)
db.session.add(category1)
db.session.add(category2)
db.session.add(transaction)
db.session.commit()
#update instances
user1.bankAccount.append(bankAccount2)
user2.bankAccount.append(bankAccount1)
transaction.sender = User.query.filter_by(username="******").first()
category1.categoryName = "dog"
bankAccount1.bankName = "The other bank"
db.session.commit()
#check that instances are updated correctly
db_user1 = User.query.filter_by(username="******").first()
db_user2 = User.query.filter_by(username="******").first()
db_transaction = Transaction.query.filter_by(id=1).first()
assert db_user1.bankAccount == [bankAccount1, bankAccount2]
assert db_user2.bankAccount == [bankAccount2, bankAccount1]
assert db_transaction.sender == User.query.filter_by(
username="******").first()
assert Category.query.filter_by(
categoryName="dog").first().categoryName == "dog"
assert BankAccount.query.filter_by(
bankName="The other bank").first().bankName == "The other bank"
def test_user_query(app):
"""
Tests the querying of a user instance
"""
# Query
user = _get_user()
with app.app_context():
db.session.add(user)
db.session.commit()
user1 = User.query.filter_by(name="user-janne").first()
assert user1.name == "user-janne"
def test_equipment_query(app):
"""
Tests the querying of a equipment instance
"""
# Query
user = _get_user()
equip = _get_equipment()
with app.app_context():
db.session.add(user)
db.session.add(equip)
db.session.commit()
equip1 = Equipment.query.filter_by(uri="Bike-11").first()
assert equip1.name == "Bike-1"
def test_user_del(app):
"""
Tests the deletion of a user instance
"""
# Delete
user = _get_user()
with app.app_context():
db.session.add(user)
db.session.commit()
user = User.query.filter_by(name="user-janne").first()
db.session.delete(user)
db.session.commit()
assert User.query.count() == 0
def test_user_mod(app):
"""
Tests the modification of user instance data
"""
# Modify
user = _get_user()
with app.app_context():
db.session.add(user)
db.session.commit()
user = User.query.filter_by(name="user-janne").first()
user.name = "user-joonas"
db.session.commit()
user = User.query.filter_by(name="user-joonas").first()
assert user.name == "user-joonas"
def test_component_query(app):
"""
Tests the querying of a component instance
"""
# Query
user = _get_user()
equip = _get_equipment()
component = _get_component()
with app.app_context():
db.session.add(user)
db.session.add(equip)
db.session.add(component)
db.session.commit()
component1 = Component.query.filter_by(brand="Fox").first()
assert component1.brand == "Fox"
def test_ride_query(app):
"""
Tests the querying of a ride instance
"""
# Query
user = _get_user()
equip = _get_equipment()
ride = _get_ride()
with app.app_context():
db.session.add(user)
db.session.add(equip)
db.session.add(ride)
db.session.commit()
ride1 = Ride.query.filter_by(name="Ajo-1").first()
assert ride1.name == "Ajo-1"
def test_equipment_del(app):
"""
Tests the deletion of a equipment instance
"""
# Delete
user = _get_user()
equip = _get_equipment()
with app.app_context():
db.session.add(user)
db.session.add(equip)
db.session.commit()
equip = Equipment.query.get(1)
db.session.delete(equip)
db.session.commit()
assert Equipment.query.count() == 0
def populate_db():
bankAccount1 = utils._get_bankAccount(iban="FI01", bankName="The bank")
bankAccount2 = utils._get_bankAccount(iban="FI02", bankName="The bank")
user1 = utils._get_user(username="******", password="******")
user2 = utils._get_user(username="******", password="******")
user1.bankAccount.append(bankAccount1)
user2.bankAccount.append(bankAccount2)
category1 = utils._get_category(name="cat1")
category2 = utils._get_category(name="cat2")
transaction = utils._get_transaction(price=3.50,
dateTime=datetime.now(),
sender=user1,
receiver=user2,
category=[category1])
db.session.add(bankAccount1)
db.session.add(bankAccount2)
db.session.add(user1)
db.session.add(user2)
db.session.add(category1)
db.session.add(category2)
db.session.add(transaction)
db.session.commit()
def test_equipment_ondelete_user(app):
"""
Tests that equipments's owner foreign key is set to null
when the user is deleted.
"""
equipment = _get_equipment()
user = _get_user()
equipment.ownedBy = user
with app.app_context():
db.session.add(equipment)
db.session.commit()
db.session.delete(user)
db.session.commit()
assert equipment.owner is None
def test_ride_del(app):
"""
Tests the deletion of a ride instance
"""
# Delete
user = _get_user()
equip = _get_equipment()
ride = _get_ride()
with app.app_context():
db.session.add(user)
db.session.add(equip)
db.session.add(ride)
db.session.commit()
db.session.delete(ride)
db.session.commit()
assert Ride.query.count() == 0
def test_component_ondelete_equipment(app):
"""
Tests that components are deleted when parent equipment is deleted.
"""
user = _get_user()
equipment = _get_equipment()
component = _get_component()
component.owner = user
component.installedTo = equipment
with app.app_context():
db.session.add(user)
db.session.add(component)
db.session.commit()
db.session.delete(equipment)
db.session.commit()
assert Component.query.count() == 0
def test_create_instances(app):
"""
Tests that we can create one instance of each model and save them to the
database using valid values for all columns. After creation, test that
everything can be found from database, and that all relationships have been
saved correctly.
"""
# Create everything
user = _get_user()
equipment = _get_equipment()
component = _get_component()
ride = _get_ride()
# Connect relationships (just one side)
equipment.ownedBy = user
component.installedTo = equipment
ride.riddenWith = equipment
ride.riddenBy = user
# Put to database
with app.app_context():
db.session.add(user)
db.session.add(equipment)
db.session.add(component)
db.session.add(ride)
db.session.commit()
# Check that everything exists
assert User.query.count() == 1
assert Equipment.query.count() == 1
assert Component.query.count() == 1
assert Ride.query.count() == 1
db_user = User.query.first()
db_equipment = Equipment.query.first()
db_component = Component.query.first()
db_ride = Ride.query.first()
# Check all relationships (both sides)
# One to one
assert db_user == db_ride.riddenBy
assert db_equipment == db_ride.riddenWith
# Others
assert db_equipment in db_user.hasEquip
assert db_component in db_equipment.hasCompos
def test_ride_mod(app):
"""
Tests the modification of ride instance data
"""
# Modify
user = _get_user()
equip = _get_equipment()
ride = _get_ride()
with app.app_context():
db.session.add(user)
db.session.add(equip)
db.session.add(ride)
db.session.commit()
ride.name = "Ajo-2"
ride.duration = 1200
ride.datetime = datetime(2020, 1, 1, 11, 20, 30)
db.session.commit()
ride = Ride.query.get(1)
assert ride.name == "Ajo-2"
assert ride.duration == 1200
assert str(ride.datetime) == "2020-01-01 11:20:30"
def test_equipment_mod(app):
"""
Tests the modification of equipment instance data
"""
# Modify
user = _get_user()
equip = _get_equipment()
with app.app_context():
db.session.add(user)
db.session.add(equip)
db.session.commit()
equip = Equipment.query.get(1)
equip.name = "Bike-2"
equip.brand = "Canyon"
equip.model = "Spectral"
equip.date_added = datetime(2019, 11, 21, 11, 20, 30)
equip.date_retired = datetime(2020, 1, 1, 11, 20, 30)
db.session.commit()
equip = Equipment.query.get(1)
assert equip.name == "Bike-2"
assert equip.brand == "Canyon"
assert equip.model == "Spectral"
assert str(equip.date_added) == "2019-11-21 11:20:30"
assert str(equip.date_retired) == "2020-01-01 11:20:30"
def test_equipment_columns(app):
"""
Tests equipment columns' restrictions. Name must be unique.
Name, category, brand, model and date_added must be mandatory.
Date_added and date_retired must be type datetime and owner accepts
only numerical values.
Date_added must be less than date_retired.
"""
# Uniqueness of uri
user_1 = _get_user(username="******", id=1)
user_2 = _get_user(username="******", id=2)
equip_1 = _get_equipment(own=1)
equip_2 = _get_equipment(own=2)
with app.app_context():
db.session.add(user_1)
db.session.add(user_2)
db.session.add(equip_1)
db.session.add(equip_2)
with pytest.raises(IntegrityError):
db.session.commit()
db.session.rollback()
# Uniqueness of name + owner
user_1 = _get_user(username="******", id=1)
user_2 = _get_user(username="******", id=2)
equip_1 = _get_equipment(id=1)
equip_2 = _get_equipment(id=2)
with app.app_context():
db.session.add(user_1)
db.session.add(user_2)
db.session.add(equip_1)
db.session.add(equip_2)
with pytest.raises(IntegrityError):
db.session.commit()
db.session.rollback()
# Not null name
equipment = _get_equipment()
equipment.name = None
with app.app_context():
db.session.add(equipment)
with pytest.raises(IntegrityError):
db.session.commit()
db.session.rollback()
# Not null category
equipment = _get_equipment()
equipment.category = None
with app.app_context():
db.session.add(equipment)
with pytest.raises(IntegrityError):
db.session.commit()
db.session.rollback()
# Not null brand
equipment = _get_equipment()
equipment.brand = None
with app.app_context():
db.session.add(equipment)
with pytest.raises(IntegrityError):
db.session.commit()
db.session.rollback()
# Not null model
equipment = _get_equipment()
equipment.model = None
with app.app_context():
db.session.add(equipment)
with pytest.raises(IntegrityError):
db.session.commit()
db.session.rollback()
# Not null date_added
equipment = _get_equipment()
equipment.date_added = None
with app.app_context():
db.session.add(equipment)
with pytest.raises(IntegrityError):
db.session.commit()
db.session.rollback()
# Type int owner
equipment = _get_equipment()
equipment.owner = str(equipment.owner) + "kg"
with app.app_context():
db.session.add(equipment)
with pytest.raises(IntegrityError):
db.session.commit()
db.session.rollback()
# Type datetime date_added
equipment = _get_equipment()
equipment.date_added = time.time()
with app.app_context():
db.session.add(equipment)
with pytest.raises(StatementError):
db.session.commit()
db.session.rollback()
# Type datetime date_retired
equipment = _get_equipment()
equipment.date_retired = time.time()
with app.app_context():
db.session.add(equipment)
with pytest.raises(StatementError):
db.session.commit()
db.session.rollback()
# date_retired greater than date_added
equipment = _get_equipment()
equipment.date_added = datetime.now()
equipment.date_retired = datetime(2020, 1, 1, 0, 0, 0)
with app.app_context():
db.session.add(equipment)
with pytest.raises(StatementError):
db.session.commit()