def setUp(self):
self.user_repository = UserRepository(test_database_connection())
self.user_service = UserService(self.user_repository)
self.user_repository.delete_all()
self.test_user_one = User('testuser', 'testuser1', 1)
self.test_user_two = User('secondo', 'testuser2', 2)
def setUp(self):
self.i_o = test_io()
self.repository = UserRepository(self.i_o)
self.test_user1 = User("Paavo", "Pesusieni666_", 1)
self.test_user2 = User("MacGyver", "_käpyKranaatti13", 2)
self.repository.empty_users_table()
def setUp(self):
database = Database()
database.init_database()
self._fake_settings_repository = FakeSettingsRepository()
self._user_repository = UserRepository(database,
self._fake_settings_repository)
self._user_repository.create_user(
TestUserRepository.TEST_USER_NAME,
TestUserRepository.TEST_USER_PASSWORD)
def setUp(self):
self.user_repository = UserRepository(test_database_connection())
self.user_repository.delete_all()
self.test_user_one = User('test_user_one', 'testpw')
self.test_user_two = User('test_user_two', 'test')
self.user_repository.create_user(self.test_user_one)
self.user_repository.create_user(self.test_user_two)
def setUp(self):
self.password_repository = PasswordRepository(test_database_connection())
self.password_service = PasswordService(self.password_repository)
self.password_repository.delete_all_passwords()
self.user_repository = UserRepository(test_database_connection())
self.user_service = UserService(self.user_repository)
self.test_user_one = User("test_user_one", "test_pw1")
self.test_user_two = User("test_user_two", "test_pw2")
self.user_service.create_user(self.test_user_one)
self.user_service.create_user(self.test_user_two)
def reserve(request):
device_pk = request.GET.get('device_pk', '')
user_pk = request.GET.get('user_pk', '')
dr = DeviceRepository()
ur = UserRepository()
device = dr.get_by_pk(device_pk)
user = ur.get_by_pk(user_pk)
device.reserve(user)
return redirect('devices:index')
class TestPasswordService(unittest.TestCase):
def setUp(self):
self.password_repository = PasswordRepository(test_database_connection())
self.password_service = PasswordService(self.password_repository)
self.password_repository.delete_all_passwords()
self.user_repository = UserRepository(test_database_connection())
self.user_service = UserService(self.user_repository)
self.test_user_one = User("test_user_one", "test_pw1")
self.test_user_two = User("test_user_two", "test_pw2")
self.user_service.create_user(self.test_user_one)
self.user_service.create_user(self.test_user_two)
def test_num_of_users_correct(self):
users = self.user_repository.get_all_users()
self.assertEqual(len(users), 2)
def test_add_new_password(self):
user_for_password = self.user_repository.get_single_user(self.test_user_one)
password_to_add = Password(
"test_username",
"test_pw",
"test_site",
user_for_password.user_id
)
added_password = self.password_service.add_new_password(password_to_add)
self.assertEqual(added_password.user_id, user_for_password.user_id)
self.assertEqual(added_password, password_to_add)
def test_get_passwords_by_user(self):
user_for_password = self.user_repository.get_single_user(self.test_user_one)
for i in range(5):
password_to_add = Password(
f"test_username{i}",
f"test_pw{i}",
f"test_site{i}",
user_for_password.user_id
)
self.password_service.add_new_password(password_to_add)
passwords_by_user = self.password_service.get_passwords_by_user(user_for_password)
self.assertEqual(len(passwords_by_user), 5)
self.assertEqual(passwords_by_user[0].username, "test_username0")
class AppLibrary:
def __init__(self):
self._io = StubIO()
self._user_repository = UserRepository()
self._user_service = UserService(self._user_repository)
self._app = App(self._user_service, self._io)
def input(self, value):
self._io.add_input(value)
def output_should_contain(self, value):
outputs = self._io.outputs
if value not in outputs:
raise AssertionError(f'Output "{value}" is not in {str(outputs)}')
def run_application(self):
self._app.run()
def create_user(self, username, password):
try:
self._user_service.create_user(username, password)
except Exception as err:
self._io.outputs.append(str(err))
def user_should_exist(self, username):
if not self._user_repository.find_by_username(username):
raise AssertionError(f"User {username} does not exist")
def setUp(self):
# Reset tables users, passwords
self.password_repository = PasswordRepository(test_database_connection())
self.user_repository = UserRepository(test_database_connection())
self.password_repository.delete_all_passwords()
self.user_repository.delete_all()
self.test_user_one = User('testiuser', 'testiuser666', 1)
self.test_user_two = User('secondtestuesr', 'testingggggg', 2)
self.test_user_one = self.user_repository.create_user(self.test_user_one)
self.test_user_two = self.user_repository.create_user(self.test_user_two)
self.test_password_one = Password('matti', 'teppo', 'www.vauva.fi')
self.test_password_two = Password('testpassword', 'testpassword2', 'www.coinbase.com')
self.test_password_one.set_user_id(self.test_user_one.user_id)
self.test_password_two.set_user_id(self.test_user_one.user_id)
def main():
user_repository = UserRepository()
user_service = UserService(user_repository)
console_io = ConsoleIO()
app = App(user_service, console_io)
app.run()
def users(request):
last_name = request.GET.get('last_name', '')
ur = UserRepository()
users = ur.get_by_last_name(last_name)
json_users = json.loads(serializers.serialize('json', users))
response = {'suggestions': []}
for user in json_users:
response['suggestions'].append({
'value': ' '.join([user['fields']['first_name'], user['fields']['last_name']]),
'data': user['pk']
})
return JsonResponse(response, safe=False)
class UserHelper():
repository = UserRepository()
def add_user(self, user_id):
user = User(user_id=user_id, username="******", password="******")
self.repository.save(user.to_dict())
return user
def get_user(self, user_id):
return self.repository.get_by_id(user_id)
def main():
"""Call this to start the program.
"""
window = Tk()
window.title("Arithmetician")
database = Database()
if not database.is_db_connection_ok():
print(
f"Failed to connect to database: {Config.DB_FILENAME}. Exiting..")
return
gui = UI(window, MainService(UserRepository(database)))
gui.start()
window.geometry("350x500")
window.mainloop()
def test_logging_in_as_user_loads_previous_settings_from_file(self):
database = Database()
database.init_database()
main_service = MainService(UserRepository(database))
main_service.create(TestMainService.TEST_USER_NAME,
TestMainService.TEST_USER_PASSWORD)
user = main_service.show_current_user()
self.assertNotEqual(
user.settings.get_setting(user.settings.ADD_TIMELIMIT), 5555)
user.settings.set_setting(user.settings.ADD_TIMELIMIT, 5555)
main_service.save_settings()
main_service.logout()
main_service.login(TestMainService.TEST_USER_NAME,
TestMainService.TEST_USER_PASSWORD)
user = main_service.show_current_user()
self.assertEqual(
user.settings.get_setting(user.settings.ADD_TIMELIMIT), 5555)
def __init__(self,
meal_repository = MealRepository(),
menu_repository = None,
user_repository = UserRepository(),
library_repository = LibraryRepository()):
"""Konstruktori, alustaa controllerin tarvitsemat repository-luokat, sekä pitää kirjaa
siitä, minkä käyttäjän tietoja kulloinkin käsitellään.
"""
self.meal_repository = meal_repository
self.menu_repository = menu_repository
self.user_repository = user_repository
self.lib_repository = library_repository
if not self.menu_repository:
self.menu_repository = MenuRepository(self.meal_repository)
self.user = None
class UserResource(object):
def __init__(self, conn, image):
self.conn = conn
self.http = Http()
self.user = UserRepository(conn)
self.image = image
def on_get(self, req, resp):
result = self.user.list()
self.http.responder(resp, result["code"], result["status"],
result["message"], result["data"])
@use_args({"name": fields.Str(required=True)})
def on_post(self, req, resp, args):
result = self.user.create(args)
self.http.responder(resp, result["code"], result["status"],
result["message"], result["data"])
def on_get_single(self, req, resp, id):
result = self.user.detail(id)
self.http.responder(resp, result["code"], result["status"],
result["message"], result["data"])
def on_delete_single(self, req, resp, id):
result = self.user.delete(id)
self.http.responder(resp, result["code"], result["status"],
result["message"], result["data"])
@use_args({"name": fields.Str(required=True)})
def on_put_single(self, req, resp, args, id):
result = self.user.update(args, id)
self.http.responder(resp, result["code"], result["status"],
result["message"], result["data"])
# @use_args({
# "picture": fields.Str(required=True)
# })
def on_patch_single(self, req, resp, id):
filename = self.image.save(req.stream, req.content_type)
result = self.user.update_picture(filename, id)
self.http.responder(resp, result["code"], result["status"],
result["message"], {"path": "/images/" + filename})
class TestUserRepository(unittest.TestCase):
def setUp(self):
self.repository = UserRepository()
self.repository.register("maija", "Ahlie8oh")
def test_register_user(self):
user = self.repository.register("matti", "salasana123")
assert user is not None
def test_contains_username_existing(self):
result = self.repository.contains_username("maija")
assert result
def test_check_login_correct(self):
result = self.repository.check_login("maija", "Ahlie8oh")
self.assertEqual(result.username, "maija")
def test_check_login_incorrect_password(self):
result = self.repository.check_login("maija", "Ahlie8ohe")
assert result is None
def test_check_login_incorrect_username(self):
result = self.repository.check_login("maije", "Ahlie8oh")
assert result is None
from recommender import recommender_list
from repositories.user_repository import UserRepository
from firebase_initializer import initialize_firebase
import pandas as pd
initialize_firebase()
user_repo = UserRepository()
user_profile = user_repo.get("-LPIy7P5NJTaRPQcGiLw")
user_profile_df = pd.DataFrame(user_profile, index=[user_profile["id"]])
print(list(user_profile_df.columns))
model = recommender_list.load_model()
new_list = model.predict(user_data=user_profile_df, id_category=1)
print(new_list)
def __init__(self):
self._io = StubIO()
self._user_repository = UserRepository()
self._user_service = UserService(self._user_repository)
self._app = App(self._user_service, self._io)
class TestUserRepository(unittest.TestCase):
TEST_USER_NAME = "testuser"
TEST_USER_PASSWORD = "******"
def setUp(self):
database = Database()
database.init_database()
self._fake_settings_repository = FakeSettingsRepository()
self._user_repository = UserRepository(database,
self._fake_settings_repository)
self._user_repository.create_user(
TestUserRepository.TEST_USER_NAME,
TestUserRepository.TEST_USER_PASSWORD)
def test_cannot_create_existing_user(self):
user = self._user_repository.create_user(
TestUserRepository.TEST_USER_NAME,
TestUserRepository.TEST_USER_PASSWORD)
self.assertIsNone(user)
def test_can_create_new_user(self):
user = self._user_repository.create_user("newuser", "newpassword")
self.assertIsNotNone(user)
self.assertEqual("newuser", user.username)
self.assertTrue(user.verify_password("newpassword"))
def test_can_find_existing_user(self):
user = self._user_repository.get_user(
TestUserRepository.TEST_USER_NAME)
self.assertIsNotNone(user)
self.assertEqual(TestUserRepository.TEST_USER_NAME, user.username)
self.assertTrue(
user.verify_password(TestUserRepository.TEST_USER_PASSWORD))
def test_cannot_find_nonexisting_user(self):
user = self._user_repository.get_user("nosuchuser")
self.assertIsNone(user)
def test_user_gets_assigned_correct_settings(self):
user = self._user_repository.get_user(
TestUserRepository.TEST_USER_NAME)
user_settings = self._fake_settings_repository.get_settings_by_username(
TestUserRepository.TEST_USER_NAME)
self.assertEqual(id(user.settings), id(user_settings))
def test_saving_non_existing_user_settings_does_nothing(self):
self._user_repository.save_settings(None)
self.assertEqual(0,
self._fake_settings_repository.user_settings_saved())
def test_saving_user_settings_calls_settings_repository(self):
user = self._user_repository.get_user(
TestUserRepository.TEST_USER_NAME)
self.assertEqual(
0,
self._fake_settings_repository.settings_saved_by_username(
user.username))
self._user_repository.save_settings(user)
self.assertEqual(
1,
self._fake_settings_repository.settings_saved_by_username(
user.username))
class TestUserRepository(TestCase):
repository = UserRepository()
helper = UserHelper()
def setUp(self):
clean_db()
def test_get_all_should_return_no_users(self):
response = self.repository.get_all()
self.assertEqual(0, len(response))
def test_get_all_should_return_two_users(self):
users = [self.helper.add_user(1), self.helper.add_user(2)]
response = self.repository.get_all()
self.assertListEqual(users, response)
def test_get_by_id_should_return_user(self):
user = self.helper.add_user(1)
response = self.repository.get_by_id(1)
self.assertEqual(user, response)
def test_get_unexisting_user_should_raise_entity_not_found(self):
with self.assertRaises(EntityNotFound):
self.repository.get_by_id(1)
def test_save_should_add_user_to_database(self):
user = User(user_id=1, username="******", password="******")
self.repository.save(user.to_dict())
self.assertEqual(user, self.helper.get_user(user.user_id))
def test_save_user_with_same_id_should_raise_integrity_error(self):
user = self.helper.add_user(1)
with self.assertRaises(IntegrityError):
self.repository.save(user.to_dict())
def test_put_should_update_user(self):
user = self.helper.add_user(1)
user.password = "******"
response = self.repository.put(user.user_id, user.to_dict())
self.assertEqual(user, self.helper.get_user(user.user_id))
def test_put_unexisting_user_should_raise_entity_not_found(self):
user = User(user_id=1, username="******", password="******")
with self.assertRaises(EntityNotFound):
self.repository.put(1, user.to_dict())
def test_delete_should_remove_user_from_database(self):
user = self.helper.add_user(1)
response = self.repository.delete(user.user_id)
with self.assertRaises(EntityNotFound):
self.repository.get_by_id(user.user_id)
def test_delete_unexisting_user_should_raise_entity_not_found(self):
with self.assertRaises(EntityNotFound):
self.repository.delete(1)
def setUp(self):
self.repository = UserRepository()
self.repository.register("maija", "Ahlie8oh")
class TestUserRepository(unittest.TestCase):
def setUp(self):
self.user_repository = UserRepository(test_database_connection())
self.user_repository.delete_all()
self.test_user_one = User('test_user_one', 'testpw')
self.test_user_two = User('test_user_two', 'test')
self.user_repository.create_user(self.test_user_one)
self.user_repository.create_user(self.test_user_two)
def test_get_all_users(self):
users = self.user_repository.get_all_users()
self.assertEqual(len(users), 2)
self.assertEqual(users[0].username, self.test_user_one.username)
def test_login_user(self):
user = self.user_repository.login_user(self.test_user_one)
self.assertEqual(user.username, self.test_user_one.username)
def test_login_user_fails_with_wrong_credentials(self):
invalid_user = User('test_user_one', 'passwordwrong')
user = self.user_repository.login_user(invalid_user)
self.assertEqual(user, None)
def test_create_user(self):
user = User('masamainio', 'anttiangeli')
created_user = self.user_repository.create_user(user)
users = self.user_repository.get_all_users()
self.assertEqual(created_user.username, 'masamainio')
self.assertEqual(len(users), 3)
def test_get_single_user(self):
user = self.user_repository.get_single_user(self.test_user_one)
self.assertEqual(user.username, self.test_user_one.username)
def test_get_single_user_returns_none_if_not_found(self):
fake_user = User('risu', 'mies')
user = self.user_repository.get_single_user(fake_user)
self.assertEqual(user, None)
class TestPasswordRepository(unittest.TestCase):
def setUp(self):
# Reset tables users, passwords
self.password_repository = PasswordRepository(test_database_connection())
self.user_repository = UserRepository(test_database_connection())
self.password_repository.delete_all_passwords()
self.user_repository.delete_all()
self.test_user_one = User('testiuser', 'testiuser666', 1)
self.test_user_two = User('secondtestuesr', 'testingggggg', 2)
self.test_user_one = self.user_repository.create_user(self.test_user_one)
self.test_user_two = self.user_repository.create_user(self.test_user_two)
self.test_password_one = Password('matti', 'teppo', 'www.vauva.fi')
self.test_password_two = Password('testpassword', 'testpassword2', 'www.coinbase.com')
self.test_password_one.set_user_id(self.test_user_one.user_id)
self.test_password_two.set_user_id(self.test_user_one.user_id)
def test_create_password(self):
self.password_repository.create_password(self.test_password_one)
passwords = self.password_repository.get_all_passwords()
self.assertEqual(len(passwords), 1)
self.assertEqual(passwords[0].username, self.test_password_one.username)
def test_get_all_users(self):
user_id = self.test_user_one.user_id
for i in range(5):
password = Password(
f'user{i}',
f'password{i}',
f'site{i}',
user_id
)
self.password_repository.create_password(password)
passwords = self.password_repository.get_all_passwords()
self.assertEqual(len(passwords), 5)
self.assertEqual(passwords[2].username, 'user2')
def test_get_all_passwords_by_user(self):
user_id = self.test_user_one.user_id
for i in range(5):
password = Password(
f'user{i}',
f'password{i}',
f'site{i}',
user_id
)
self.password_repository.create_password(password)
user_id = self.test_user_two.user_id
for i in range(5, 10):
password = Password(
f'user{i}',
f'password{i}',
f'site{i}',
user_id
)
self.password_repository.create_password(password)
passwords_by_user_one = self.password_repository.get_all_passwords_by_user(self.test_user_one)
self.assertEqual(len(passwords_by_user_one), 5)
self.assertEqual(passwords_by_user_one[1].user_id, self.test_user_one.user_id)
def test_tuple_to_password_returns_none_if_no_password_given(self):
result = self.password_repository.tuple_to_password(None)
self.assertIsNone(result)
from login import SECRET_KEY
from flask import render_template, Blueprint, redirect, url_for, flash
from templates.login import LoginForm
from templates.register import RegisterForm
from models.user import User
from flask_login import login_user, current_user
from repositories.user_repository import UserRepository
from peewee import PeeweeException
from hashlib import sha512
REGISTER_API = Blueprint("register", __name__)
USER_REPOSITORY = UserRepository()
@REGISTER_API.route("/register", methods=["GET", "POST"])
def register():
if current_user.is_authenticated:
return redirect(url_for("mainpage.index"))
registerForm = RegisterForm()
if registerForm.validate_on_submit():
username = registerForm.username.data
mail = registerForm.mail.data
if len(username) < 3 or len(registerForm.password.data) < 5:
flash("Username or password is too short!", "register")
return render_template("register.html",
form=registerForm,
from flask import Blueprint, render_template, request, redirect, url_for, abort, flash
from flask_login import current_user, login_required
from repositories.task_repository import TaskRepository
from repositories.user_repository import UserRepository
from repositories.ticket_repository import TicketRepository
from repositories.comment_repository import CommentRepository
from templates.create_task import CreateTaskForm
from templates.create_comment_ticket import CreateCommentForm
from upload_handler import handle_image, InvalidFile
from utilities import make_thumbnail
from peewee import PeeweeException
TASK_API = Blueprint("task", __name__)
TASK_REPO = TaskRepository()
TICKET_REPO = TicketRepository()
USER_REPO = UserRepository()
COMMENT_REPO = CommentRepository()
HTTP_UNAUTHORIZED = 401
HTTP_NOT_FOUND = 404
MANAGER = 2
TASK_MAX_THUMBNAIL_LENGTH = 23
@TASK_API.route("/tasks")
@login_required
def get_tasks():
assignedTasks = TASK_REPO.get_user_tasks(current_user.id)
for task in assignedTasks:
task.title = make_thumbnail(task.title, TASK_MAX_THUMBNAIL_LENGTH)
createdTasks = TASK_REPO.get_tasks_by(current_user.id)
for task in createdTasks:
task.title = make_thumbnail(task.title, TASK_MAX_THUMBNAIL_LENGTH)
class TestReadingTip(unittest.TestCase):
def setUp(self):
self.user_repository = UserRepository()
self.user = self.user_repository.register("maija", "Tiothee6")
self.repository = ReadingTipRepository()
def test_create_tip(self):
tags = [Tag("kirjat"), Tag("maksulliset")]
self.repository.create_tip(
ReadingTip("Hyvä kirja", "kirjakauppa.fi/123", self.user, tags))
tips = self.repository.get_tips(self.user, "all")
self.assertEqual(tips[0].title, "Hyvä kirja")
self.assertEqual(tips[0].tags[0].name, "kirjat")
self.assertEqual(tips[0].tags[1].name, "maksulliset")
def test_contains_title_if_not_present(self):
assert not self.repository.contains_title(self.user, "Hyvä kirja")
def test_contains_title_if_present(self):
tags = [Tag("kirjat"), Tag("maksulliset")]
self.repository.create_tip(
ReadingTip("Hyvä kirja", "kirjakauppa.fi/123", self.user, tags))
assert self.repository.contains_title(self.user, "Hyvä kirja")
def test_deletes_tip(self):
tags = [Tag("kirjat"), Tag("maksulliset")]
self.repository.create_tip(
ReadingTip("Hyvä kirja", "kirjakauppa.fi/123", self.user, tags))
tip = self.repository.get_tips(self.user, "all")[0]
self.repository.delete_tip(tip)
self.assertEqual(self.repository.get_tips(self.user, "all"), [])
def test_cannot_see_others_tip(self):
tags = [Tag("kirjat"), Tag("maksulliset")]
second_user = self.user_repository.register("mikko", "oko7Aeko")
self.repository.create_tip(
ReadingTip("Hyvä kirja", "kirjakauppa.fi/123", second_user, tags))
assert not self.repository.contains_title(self.user, "Hyvä kirja")
self.assertEqual(self.repository.get_tips(self.user, "all"), [])
def test_can_get_tips_based_on_tags(self):
tags = [Tag("Hyvä")]
self.repository.create_tip(
ReadingTip("Hyvä kirja", "kirjakauppa.fi/123", self.user, tags))
second_tags = [Tag("Huono")]
self.repository.create_tip(
ReadingTip("Huono kirja", "kirjakauppa.fi/123", self.user,
second_tags))
self.assertEqual(len(self.repository.get_tips(self.user, "all")), 2)
self.assertEqual(len(self.repository.get_tips(self.user, "Hyvä")), 1)
def test_update_tip(self):
tags = [Tag("kirjat"), Tag("maksulliset")]
self.repository.create_tip(
ReadingTip("Hyvä kirja", "kirjakauppa.fi/123", self.user, tags))
tags.append(Tag("uusi"))
self.repository.update_tip(1, "Muutettu kirja", "kirjakauppa.fi/123",
tags)
self.assertEqual(
self.repository.get_tips(self.user)[0].title, "Muutettu kirja")
self.assertEqual(
self.repository.get_tips(self.user)[0].tags[2].name, "uusi")
def test_get_tip(self):
tags = [Tag("kirjat"), Tag("maksulliset")]
self.repository.create_tip(
ReadingTip("Uusi kirja", "kirjakauppa.fi/123", self.user, tags))
tip = self.repository.get_tip(1)
self.assertEqual(tip.title, "Uusi kirja")
def test_marks_tip_as_read(self):
tags = [Tag("kirjat"), Tag("maksulliset")]
self.repository.create_tip(
ReadingTip("Hyvä kirja", "kirjakauppa.fi/123", self.user, tags))
assert self.repository.get_tips(self.user)[0].read is None
self.repository.read_tip(
self.repository.get_tips(self.user)[0], "2021")
assert self.repository.get_tips(self.user)[0].read is not None
def setUp(self):
self.user_repository = UserRepository()
self.user = self.user_repository.register("maija", "Tiothee6")
self.repository = ReadingTipRepository()
def __init__(self, dbcontext: DbContext):
self._dbcontext: DbContext = dbcontext
self._repository: UserRepository = UserRepository(dbcontext)
def __init__(self, conn, image):
self.conn = conn
self.http = Http()
self.user = UserRepository(conn)
self.image = image
class TestUserRepository(unittest.TestCase):
def setUp(self):
self.i_o = test_io()
self.repository = UserRepository(self.i_o)
self.test_user1 = User("Paavo", "Pesusieni666_", 1)
self.test_user2 = User("MacGyver", "_käpyKranaatti13", 2)
self.repository.empty_users_table()
def test_add_user(self):
self.repository.add_user(self.test_user1.name,
self.test_user1.password)
user = self.repository.find_all_users()[0]
self.assertEqual(user.name, self.test_user1.name)
self.assertEqual(user.id, self.test_user1.id)
def test_find_all_users(self):
self.repository.add_user(self.test_user1.name,
self.test_user1.password)
self.repository.add_user(self.test_user2.name,
self.test_user2.password)
users = self.repository.find_all_users()
self.assertEqual(len(users), 2)
self.assertEqual(users[0].name, self.test_user1.name)
self.assertIsInstance(users[0], User)
self.assertEqual(users[1].password, self.test_user2.password)
self.assertEqual(users[1].id, self.test_user2.id)
def test_find_by_username(self):
self.repository.add_user(self.test_user1.name,
self.test_user1.password)
user = self.repository.find_by_username(self.test_user1.name)
self.assertEqual(user.name, self.test_user1.name)
self.assertEqual(user.password, self.test_user1.password)
self.assertEqual(user.id, self.test_user1.id)
self.assertIsNone(self.repository.find_by_username('Voldemort'))
def test_empty_users_table(self):
self.repository.add_user(self.test_user1.name,
self.test_user1.password)
self.assertEqual(len(self.repository.find_all_users()), 1)
self.repository.empty_users_table()
self.assertEqual(len(self.repository.find_all_users()), 0)
class TestUserService(unittest.TestCase):
def setUp(self):
self.user_repository = UserRepository(test_database_connection())
self.user_service = UserService(self.user_repository)
self.user_repository.delete_all()
self.test_user_one = User('testuser', 'testuser1', 1)
self.test_user_two = User('secondo', 'testuser2', 2)
def test_create_user(self):
result = self.user_service.create_user(self.test_user_one)
users = self.user_repository.get_all_users()
self.assertEqual(result.username, self.test_user_one.username)
self.assertEqual(len(users), 1)
def test_create_user_fails_if_too_long_username(self):
test_user = User('a' * 31, 'test_pw')
result = self.user_service.create_user(test_user)
users = self.user_repository.get_all_users()
self.assertEqual(result, None)
self.assertEqual(len(users), 0)
def test_create_user_fails_if_too_long_password(self):
test_user = User('aasi_boy', 'a' * 51)
result = self.user_service.create_user(test_user)
users = self.user_repository.get_all_users()
self.assertEqual(result, None)
self.assertEqual(len(users), 0)
def test_create_user_returns_none_if_user_exists(self):
user = self.user_service.create_user(self.test_user_one)
result = self.user_service.create_user(self.test_user_one)
self.assertIsNone(result)
def test_create_user_returns_none_if_no_username_given(self):
test_user = User(None, 'testing', 69)
result = self.user_service.create_user(test_user)
self.assertIsNone(result)
def test_create_user_returns_none_if_no_password_given(self):
test_user = User('testing', None, 69)
result = self.user_service.create_user(test_user)
self.assertIsNone(result)
def test_get_user(self):
self.user_service.create_user(self.test_user_two)
result = self.user_service.get_user(self.test_user_two)
self.assertEqual(result.username, self.test_user_two.username)
def test_login_user(self):
self.user_service.create_user(self.test_user_one)
result = self.user_service.login_user(self.test_user_one)
self.assertEqual(result.username, self.test_user_one.username)
