Resolve "Add db-tests"

server/app/__init__.py

@@ -2,8 +2,8 @@ from flask import Flask
 from flask_bcrypt import Bcrypt
 from flask_jwt_extended.jwt_manager import JWTManager
 from flask_sqlalchemy import SQLAlchemy
-from app.database import Base
 
+from app.database import Base
 
 bcrypt = Bcrypt()
 jwt = JWTManager()

server/app/api/users.py

@@ -2,6 +2,7 @@ import datetime
 
 from app import db
 from app.api import api_blueprint
+from app.database.controller import add_user
 from app.database.models import Blacklist, User
 from app.utils.validator import edit_user_schema, login_schema, register_schema, validateObject
 from flask import request
@@ -90,11 +91,12 @@ def create():
     if existing_user != None:
         return {"message": "User already exists"}, 400
 
-    user = User(json_dict["email"], json_dict["password"])
-    db.session.add(user)
+    add_user(json_dict["email"], json_dict["password"], json_dict["role"], json_dict["city"])
     db.session.commit()
 
-    return user.get_dict(), 200
+    item_user = User.query.filter_by(email=json_dict["email"]).first()
+
+    return item_user.get_dict(), 200
 
 
 @api_blueprint.route("/users/", methods=["PUT"])

server/app/database/controller.py

+from app import db
+from app.database.models import City, Role, User
+
+
+def add_user(email, plaintext_password, role, city):
+    item_role = Role.query.filter_by(name=role).first()
+    item_city = City.query.filter_by(name=city).first()
+    user = User(email, plaintext_password, item_role.id, item_city.id)
+    db.session.add(user)

server/app/database/models.py

+from enum import unique
+
 from app import bcrypt, db
 from sqlalchemy.ext.declarative import declared_attr
 from sqlalchemy.ext.hybrid import hybrid_method, hybrid_property
@@ -7,7 +9,8 @@ STRING_SIZE = 254
 
 class Blacklist(db.Model):
     id = db.Column(db.Integer, primary_key=True)
-    jti = db.Column(db.String, unique=True, nullable=False)
+    jti = db.Column(db.String, unique=True)
+    expire_date = db.Column(db.Integer, nullable=True)
 
     def __init__(self, jti):
         self.jti = jti
@@ -23,6 +26,7 @@ class Role(db.Model):
         self.name = name
 
 
+# TODO Region?
 class City(db.Model):
     id = db.Column(db.Integer, primary_key=True)
     name = db.Column(db.String(STRING_SIZE), unique=True)
@@ -36,26 +40,26 @@ class City(db.Model):
 
 class User(db.Model):
     id = db.Column(db.Integer, primary_key=True)
-    email = db.Column(db.String(254), unique=True, nullable=False)
-    name = db.Column(db.String(50), nullable=True)
+    email = db.Column(db.String(STRING_SIZE), unique=True)
+    name = db.Column(db.String(STRING_SIZE), nullable=True)
 
     _password = db.Column(db.LargeBinary(60), nullable=False)
-    authenticated = db.Column(db.Boolean, default=False)
 
-    twoAuthConfirmed = db.Column(db.Boolean, default=True)  # Change to false for Two factor authen
-    twoAuthCode = db.Column(db.String(100), nullable=True)
+    # Change to false for Two factor authen
+    authenticated = db.Column(db.Boolean, default=False)
+    twoAuthConfirmed = db.Column(db.Boolean, default=True)
+    twoAuthCode = db.Column(db.String(STRING_SIZE), nullable=True)
 
-    role_id = db.Column(db.Integer, db.ForeignKey("role.id"), nullable=True)  # Change to false
-    city_id = db.Column(db.Integer, db.ForeignKey("city.id"), nullable=True)  # Change to false
+    role_id = db.Column(db.Integer, db.ForeignKey("role.id"), nullable=False)
+    city_id = db.Column(db.Integer, db.ForeignKey("city.id"), nullable=False)
 
     media = db.relationship("Media", backref="upload_by")
 
-    def __init__(self, email, plaintext_password, role_id=None, city_id=None, name=None):
+    def __init__(self, email, plaintext_password, role_id, city_id):
         self._password = bcrypt.generate_password_hash(plaintext_password)
         self.email = email
         self.role_id = role_id
         self.city_id = city_id
-        self.name = name
         self.authenticated = False
 
     def get_dict(self):
@@ -77,26 +81,26 @@ class User(db.Model):
 class Media(db.Model):
     id = db.Column(db.Integer, primary_key=True)
     filename = db.Column(db.String(STRING_SIZE), unique=True)
-    type = db.Column(db.Integer, nullable=False)
+    type_id = db.Column(db.Integer, db.ForeignKey("media_type.id"), nullable=False)
     upload_by_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
 
     styles = db.relationship("Style", backref="bg_image")
 
-    def __init__(self, filename, type, upload_by_id):
+    def __init__(self, filename, type_id, upload_by_id):
         self.filename = filename
-        self.type = type
+        self.type_id = type_id
         self.upload_by_id = upload_by_id
 
 
 class Style(db.Model):
     id = db.Column(db.Integer, primary_key=True)
     name = db.Column(db.String(STRING_SIZE), unique=True)
-    css = db.Column(db.Text, nullable=True)
+    css = db.Column(db.Text, nullable=False)
     bg_image_id = db.Column(db.Integer, db.ForeignKey("media.id"), nullable=True)
 
     competition = db.relationship("Competition", backref="style")
 
-    def __init__(self, name, css=None, bg_image_id=None):
+    def __init__(self, name, css, bg_image_id=None):
         self.name = name
         self.css = css
         self.bg_image_id = bg_image_id
@@ -118,11 +122,12 @@ class Competition(db.Model):
 
 
 class Team(db.Model):
+    __table_args__ = (db.UniqueConstraint("competition_id", "name"),)
     id = db.Column(db.Integer, primary_key=True)
-    name = db.Column(db.String(STRING_SIZE), unique=True)
+    name = db.Column(db.String(STRING_SIZE), nullable=False)
     competition_id = db.Column(db.Integer, db.ForeignKey("competition.id"), nullable=False)
 
-    answered_questions = db.relationship("AnsweredQuestion", backref="team")
+    question_answers = db.relationship("QuestionAnswer", backref="team")
 
     def __init__(self, name, competition_id):
         self.name = name
@@ -130,58 +135,107 @@ class Team(db.Model):
 
 
 class Slide(db.Model):
+    __table_args__ = (db.UniqueConstraint("order", "competition_id"),)
     id = db.Column(db.Integer, primary_key=True)
-    name = db.Column(db.String(STRING_SIZE), unique=True)
     order = db.Column(db.Integer, nullable=False)
-    tweak_settings = db.Column(db.Text, nullable=True)
+    title = db.Column(db.String(STRING_SIZE), nullable=False, default="")
+    body = db.Column(db.Text, nullable=False, default="")
+    timer = db.Column(db.Integer, nullable=False, default=0)
+    tweak_settings = db.Column(db.Text, nullable=False, default="")
     competition_id = db.Column(db.Integer, db.ForeignKey("competition.id"), nullable=False)
 
     questions = db.relationship("Question", backref="slide")
 
-    def __init__(self, name, order, competition_id, tweak_settings=None):
-        self.name = name
+    def __init__(self, order, competition_id):
         self.order = order
         self.competition_id = competition_id
-        self.tweak_settings = tweak_settings
 
 
 class Question(db.Model):
+    __table_args__ = (db.UniqueConstraint("slide_id", "name"), db.UniqueConstraint("slide_id", "order"))
     id = db.Column(db.Integer, primary_key=True)
-    name = db.Column(db.String(STRING_SIZE), unique=True)
-    title = db.Column(db.String(STRING_SIZE), nullable=False)
-    timer = db.Column(db.Integer, nullable=False)
+    name = db.Column(db.String(STRING_SIZE), nullable=False)
+    order = db.Column(db.Integer, nullable=False)
+    type_id = db.Column(db.Integer, db.ForeignKey("question_type.id"), nullable=False)
     slide_id = db.Column(db.Integer, db.ForeignKey("slide.id"), nullable=False)
+    question_answers = db.relationship("QuestionAnswer", backref="question")
+    alternatives = db.relationship("QuestionAlternative", backref="question")
 
-    answered_questions = db.relationship("AnsweredQuestion", backref="question")
-
-    def __init__(self, name, title, timer, slide_id):
+    def __init__(self, name, order, type_id, slide_id):
         self.name = name
-        self.title = title
-        self.timer = timer
+        self.order = order
+        self.type_id = type_id
         self.slide_id = slide_id
 
 
-class TrueFalseQuestion(db.Model):
+class QuestionAlternative(db.Model):
+    __table_args__ = (db.UniqueConstraint("question_id", "order"),)
     id = db.Column(db.Integer, primary_key=True)
-    true_false = db.Column(db.Boolean, nullable=False, default=False)
+    text = db.Column(db.String(STRING_SIZE), nullable=False)
+    value = db.Column(db.Boolean, nullable=False)
+    order = db.Column(db.Integer, nullable=False)
     question_id = db.Column(db.Integer, db.ForeignKey("question.id"), nullable=False)
 
-    question = db.relationship("Question", foreign_keys=[question_id], uselist=False)
-
-    def __init__(self, true_false, question_id):
-        self.true_false = true_false
+    def __init__(self, text, value, order, question_id):
+        self.text = text
+        self.value = value
+        self.order = order
         self.question_id = question_id
 
 
-class TextQuestion(db.Model):
+# TODO QuestionAnswer
+class QuestionAnswer(db.Model):
+    __table_args__ = (db.UniqueConstraint("question_id", "team_id"),)
     id = db.Column(db.Integer, primary_key=True)
+    data = db.Column(db.Text, nullable=False)
+    score = db.Column(db.Integer, nullable=False, default=0)  # 0: False, 1: True
     question_id = db.Column(db.Integer, db.ForeignKey("question.id"), nullable=False)
+    team_id = db.Column(db.Integer, db.ForeignKey("team.id"), nullable=False)
 
-    question = db.relationship("Question", foreign_keys=[question_id], uselist=False)
-    alternatives = db.relationship("TextQuestionAlternative", backref="text_question")
-
-    def __init__(self, question_id):
+    def __init__(self, data, score, question_id, team_id):
+        self.data = data
+        self.score = score
         self.question_id = question_id
+        self.team_id = team_id
+
+
+class MediaType(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    name = db.Column(db.String(STRING_SIZE), unique=True)
+    media = db.relationship("Media", backref="type")
+
+    def __init__(self, name):
+        self.name = name
+
+
+class QuestionType(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    name = db.Column(db.String(STRING_SIZE), unique=True)
+    questions = db.relationship("Question", backref="type")
+
+    def __init__(self, name):
+        self.name = name
+
+
+"""
+QuestionHandler = db.Table(
+    "question_handler",
+    db.Column("question_id", db.Integer, db.ForeignKey("question.id"), primary_key=True),
+    db.Column("sub_question_id", db.Integer, unique=True),
+    db.Column("question_type", db.Integer, nullable=False),
+)
+
+class TrueFalseQuestion(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    true_false = db.Column(db.Boolean, nullable=False, default=False)
+
+    def __init__(self, true_false):
+        self.true_false = true_false
+
+
+class TextQuestion(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    alternatives = db.relationship("TextQuestionAlternative", backref="text_question")
 
 
 class TextQuestionAlternative(db.Model):
@@ -198,15 +252,11 @@ class MCQuestion(db.Model):
     id = db.Column(db.Integer, primary_key=True)
     title = db.Column(db.String(STRING_SIZE), nullable=False)
     timer = db.Column(db.Integer, nullable=False)
-    question_id = db.Column(db.Integer, db.ForeignKey("question.id"), nullable=False)
-
-    question = db.relationship("Question", foreign_keys=[question_id], uselist=False)
     alternatives = db.relationship("MCQuestionAlternative", backref="mc_question")
 
-    def __init__(self, title, timer, slide_id):
+    def __init__(self, title, timer):
         self.title = title
         self.timer = timer
-        self.slide_id = slide_id
 
 
 class MCQuestionAlternative(db.Model):
@@ -221,15 +271,5 @@ class MCQuestionAlternative(db.Model):
         self.mc_id = mc_id
 
 
-class AnsweredQuestion(db.Model):
-    id = db.Column(db.Integer, primary_key=True)
-    data = db.Column(db.Text, nullable=False)
-    score = db.Column(db.Integer, nullable=False)
-    question_id = db.Column(db.Integer, db.ForeignKey("question.id"), nullable=False)
-    team_id = db.Column(db.Integer, db.ForeignKey("team.id"), nullable=False)
 
-    def __init__(self, data, score, question_id, team_id):
-        self.data = data
-        self.score = score
-        self.question_id = question_id
-        self.team_id = team_id
+"""

server/app/database/populate.py

+from app import db
+from app.database.controller import add_user
+from app.database.models import City, MediaType, QuestionType, Role
+
+media_types = ["Image", "Video"]
+question_types = ["Boolean", "Multiple", "Text"]
+roles = ["Admin", "Editor"]
+cities = ["Linköping"]
+
+
+def add_default_values():
+
+    # Add media types
+    for type in media_types:
+        db.session.add(MediaType(type))
+
+    # Add question types
+    for type in question_types:
+        db.session.add(QuestionType(type))
+
+    # Add roles
+    for role in roles:
+        db.session.add(Role(role))
+
+    # Add cities
+    for city in cities:
+        db.session.add(City(city))
+
+    # Commit changes to db
+    db.session.commit()
+
+    # Add user with role and city
+    add_user("test@test.se", "password", "Admin", "Linköping")
+    db.session.commit()

server/app/utils/populate.py

-from requests import *
-import json
-
-HOST = "http://localhost:5000/"
-
-
-def _post(url: str, jdict: dict):
-    post(HOST + url, json.dumps(jdict))
-
-
-def asdasd(i: int):
-    return i
-
-
-print("Populate default database data")
-
-_post("user/", {"email": "admin@test.com", "password": "password", "name": "Admin Adminsson"})

server/app/utils/test_helpers.py

+from app import db
+
+
+# Try insert invalid row. If it fails then the test is passed
+def assert_insert_fail(type, *args):
+    try:
+        db.session.add(type(*args))
+        db.session.commit()
+        assert False
+    except:
+        db.session.rollback()
+
+
+def assert_exists(type, length, **kwargs):
+    items = type.query.filter_by(**kwargs).all()
+    assert len(items) == length
+    return items[0]
+
+
+def assert_object_values(object, dict):
+    for k, v in dict.items():
+        assert getattr(object, k) == v

server/app/utils/validator.py

@@ -17,6 +17,8 @@ login_schema = {
 register_schema = {
     "email": {"type": "string", "required": True, "regex": _email_regex},
     "password": {"type": "string", "required": True, "minlength": 6, "maxlength": 128},
+    "role": {"type": "string", "required": True},
+    "city": {"type": "string", "required": True},
 }
 
 edit_user_schema = {

server/tests/__init__.py

@@ -6,9 +6,15 @@ from app import create_app, db
 def app():
     app = create_app("configmodule.TestingConfig")
 
+    """
     with app.app_context():
         db.drop_all()
         db.create_all()
+        yield app
+    """
+    app.app_context().push()
+    db.drop_all()
+    db.create_all()
     return app
 
 

server/tests/test_app.py

-from tests import app, client
 import json
 
+from app.database.populate import add_default_values
+
+from tests import app, client
+
 
 def test_app(client):
+    add_default_values()
 
+    register_data = {"email": "test1@test.se", "password": "abc123", "role": "Admin", "city": "Linköping"}
     # Create user
     rv = client.post(
         "/api/users/",
-        data=json.dumps({"email": "test@test.se", "password": "abc123"}),
+        data=json.dumps(register_data),
     )
     rv_dict = json.loads(rv.data.decode())
 
     assert rv.status_code == 200
-    assert rv_dict["id"] == 1
+    assert rv_dict["id"] == 2
     assert "password" not in rv_dict
-    assert rv_dict["email"] == "test@test.se"
+    assert rv_dict["email"] == "test1@test.se"
 
     # Try loggin with wrong PASSWORD
-    rv = client.post("/api/users/login", data=json.dumps({"email": "test@test.se", "password": "abc1234"}))
+    rv = client.post("/api/users/login", data=json.dumps({"email": "test1@test.se", "password": "abc1234"}))
     assert rv.status_code == 401
 
     # Try loggin with wrong Email
-    rv = client.post("/api/users/login", data=json.dumps({"email": "test1@test.se", "password": "abc1234"}))
+    rv = client.post("/api/users/login", data=json.dumps({"email": "testx@test.se", "password": "abc1234"}))
     assert rv.status_code == 401
 
     # Try loggin with right PASSWORD
-    rv = client.post("/api/users/login", data=json.dumps({"email": "test@test.se", "password": "abc123"}))
+    rv = client.post("/api/users/login", data=json.dumps({"email": "test1@test.se", "password": "abc123"}))
     rv_dict = json.loads(rv.data.decode())
     assert rv.status_code == 200
     headers = {"Authorization": "Bearer " + rv_dict["access_token"]}
@@ -34,7 +39,7 @@ def test_app(client):
     rv = client.get("/api/users/", headers=headers)
     rv_dict = json.loads(rv.data.decode())
     assert rv.status_code == 200
-    assert rv_dict["email"] == "test@test.se"
+    assert rv_dict["email"] == "test1@test.se"
 
     rv = client.put("/api/users/", data=json.dumps({"name": "carl carlsson"}), headers=headers)
     rv_dict = json.loads(rv.data.decode())

server/tests/test_db.py

+import pytest
+from app.database.controller import add_user
+from app.database.models import (
+    City,
+    Competition,
+    Media,
+    MediaType,
+    Question,
+    QuestionAnswer,
+    QuestionType,
+    Role,
+    Slide,
+    Style,
+    Team,
+    User,
+)
+from app.database.populate import add_default_values
+from app.utils.test_helpers import *
+
+from tests import app, client, db
+
+# server/env/Scripts/pytest.exe --cov app server/tests/
+
+
+def test_user(client):
+    add_default_values()
+    item_user = User.query.filter_by(email="test@test.se").first()
+
+    # Assert user
+    assert item_user != None
+    assert item_user.city.name == "Linköping"
+    assert item_user.role.name == "Admin"
+
+    item_role = Role.query.filter_by(name="Admin").first()
+    item_city = City.query.filter_by(name="Linköping").first()
+
+    # Assert user with role and city
+    assert len(item_role.users) == 1 and item_role.users[0].id == item_user.id
+    assert len(item_city.users) == 1 and item_city.users[0].id == item_user.id
+
+
+def test_media_style(client):
+    add_default_values()
+    item_user = User.query.filter_by(email="test@test.se").first()
+
+    # Get image type
+    image_type = MediaType.query.filter_by(name="Image").first()
+
+    # Add image
+    db.session.add(Media("bild.png", image_type.id, item_user.id))
+    db.session.commit()
+
+    # Assert image
+    item_media = Media.query.filter_by(filename="bild.png").first()
+    assert item_media != None
+    assert len(item_user.media) == 1
+    assert item_media.upload_by.email == "test@test.se"
+
+    # Add style
+    db.session.add(Style("template", "hej", item_media.id))
+    db.session.commit()
+
+    # Assert style
+    item_style = Style.query.filter_by(name="template").first()
+    assert item_style != None
+    assert len(item_media.styles) == 1
+    assert item_style.bg_image.filename == "bild.png"
+
+    # Assert lazy loading
+    assert item_user.media[0].styles[0].name == "template"
+
+
+def test_question(client):
+    add_default_values()
+    item_user = User.query.filter_by(email="test@test.se").first()
+
+    # Get image type
+    image_type = MediaType.query.filter_by(name="Image").first()
+
+    # Add image
+    db.session.add(Media("bild.png", image_type.id, item_user.id))
+    db.session.commit()
+    item_media = Media.query.filter_by(filename="bild.png").first()
+
+    # Add style
+    db.session.add(Style("template", "hej", item_media.id))
+    db.session.commit()
+    item_style = Style.query.filter_by(name="template").first()
+
+    # Add competition
+    item_city = City.query.filter_by(name="Linköping").first()
+    db.session.add(Competition("teknik8", item_style.id, item_city.id))
+    db.session.add(Competition("teknik9", item_style.id, item_city.id))
+    db.session.commit()
+    item_competition = Competition.query.filter_by(name="teknik8").first()
+    item_competition_2 = Competition.query.filter_by(name="teknik9").first()
+
+    assert item_competition != None
+    assert item_competition.id == 1
+    assert item_competition.style.name == "template"
+    assert item_competition.city.name == "Linköping"
+
+    # Add teams
+    db.session.add(Team("Lag1", item_competition.id))
+    db.session.add(Team("Lag2", item_competition.id))
+    db.session.commit()
+
+    assert_insert_fail(Team, "Lag1", item_competition.id)
+
+    db.session.add(Team("Lag1", item_competition_2.id))
+    db.session.commit()
+
+    assert Team.query.filter((Team.competition_id == item_competition.id) & (Team.name == "Lag1")).count() == 1
+    assert Team.query.filter((Team.competition_id == item_competition.id) & (Team.name == "Lag2")).count() == 1
+    assert Team.query.filter((Team.competition_id == item_competition_2.id) & (Team.name == "Lag1")).count() == 1
+    assert Team.query.filter(Team.name == "Lag1").count() == 2
+    assert Team.query.filter(Team.competition_id == item_competition.id).count() == 2
+    assert Team.query.count() == 3
+
+    # Add slides
+    db.session.add(Slide(1, item_competition.id))
+    db.session.add(Slide(2, item_competition.id))
+    db.session.add(Slide(3, item_competition.id))
+    db.session.commit()
+
+    # Try add slide with same order
+    assert_insert_fail(Slide, 1, item_competition.id)
+    assert_exists(Slide, 1, order=1)
+
+    item_slide1 = Slide.query.filter_by(order=1).first()
+    item_slide2 = Slide.query.filter_by(order=2).first()
+    item_slide3 = Slide.query.filter_by(order=3).first()
+
+    assert item_slide1 != None
+    assert item_slide2 != None
+    assert item_slide3 != None
+
+    # Add questions
+    question_type_bool = QuestionType.query.filter_by(name="Boolean").first()
+    question_type_multiple = QuestionType.query.filter_by(name="Multiple").first()
+
+    db.session.add(Question("Fråga1", 0, question_type_bool.id, item_slide2.id))
+    db.session.add(Question("Fråga2", 1, question_type_multiple.id, item_slide3.id))
+    db.session.commit()
+
+    assert question_type_bool != None
+    assert question_type_multiple != None
+
+    item_q1 = Question.query.filter_by(name="Fråga1").first()
+    item_q2 = Question.query.filter_by(name="Fråga2").first()
+    assert item_q1.type.name == "Boolean"
+    assert item_q2.type.name == "Multiple"