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)