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)
async def check_service(request: CheckRequest) -> Verdict:
async with Api(f'http://{request.hostname}:3000') as api:
first_user = User()
second_user = User()
try:
resp = await api.register(first_user.get_register_data())
if 'userId' not in resp:
return Verdict.MUMBLE('Invalid contract in user login', '')
first_user.user_id = resp['userId']
resp = await api.register(second_user.get_register_data())
if 'userId' not in resp:
return Verdict.MUMBLE('Invalid contract in user login', '')
second_user.user_id = resp['userId']
except InvalidResponseException:
return Verdict.MUMBLE('Could not register login.',
traceback.format_exc())
except:
return Verdict.DOWN('Could not connect to service.',
traceback.format_exc())
verdict = await check_user_info(api, first_user)
if verdict:
return verdict
verdict = await check_chats(api, first_user, second_user)
if verdict:
return verdict
verdict = await check_users_searching(api, first_user)
if verdict:
return verdict
return Verdict.OK()
def setUp(self):
todo_repository.delete_all()
user_repository.delete_all()
self.todo_a = Todo('testing a')
self.todo_b = Todo('testing b')
self.user_kalle = User('kalle', 'kalle123')
self.user_matti = User('matti', 'matti123')
def _prepare_users(cls):
users = []
users.append(User("Paavo", "Pesusieni666_", 1))
users.append(User("MacGyver", "_Käpykranaatti13", 2))
users.append(User("Gunnar", "Surströmming<3", 3))
return users
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):
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 setUpClass(cls):
cls.i_o = test_io()
cls.repository = MealRepository(cls.i_o)
cls.meal_set = test_set(cls.repository)
cls.repository.empty_tables()
cls.test_user = User("Paavo", "Pesusieni", 1)
cls.false_user = User("Darth", "Vader", 666)
cls.meals = cls.meal_set.create_meals(cls.test_user)
cls.ingredients = cls.meal_set.create_ingredients()
def setUpClass(cls):
cls.i_o = test_io()
cls.meal_repository = MealRepository()
cls.menu_repository = MenuRepository(cls.meal_repository, cls.i_o)
cls.meal_set = test_set(cls.meal_repository)
cls.meal_repository.empty_tables()
cls.test_user1 = User("Paavo", "Pesusieni", 1)
cls.test_user2 = User("Matti", "Meikäläinen", 2)
cls.meals = cls.meal_set.create_meals(cls.test_user1)
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 create():
roleAdmin = []
roleAdmin.append('admin')
user1 = User("user1", roleAdmin)
roleDev = []
roleDev.append('user')
user2 = User("user2", roleDev)
createBaseUser.userData[user1.get_username()] = user1.get_roles()
createBaseUser.userData[user2.get_username()] = user2.get_roles()
print(createBaseUser.userData)
def user(uno=None, email=None, password=None):
db = UserDB.db()
if uno:
return User(db.get(uno))
elif email:
for doc in db:
if doc['email'] == email:
if password:
if doc['password'] != authhelper.crypt(password):
return User()
return User(doc)
return User()
def setUp(self):
# ---------------------------------------------------------------------
# First the test database is cleared just to be sure it's empty.
# ---------------------------------------------------------------------
DatabaseServices(test_database).database.execute(
"DROP TABLE IF EXISTS Users")
DatabaseServices(test_database).database.execute(
"DROP TABLE IF EXISTS Questions")
# ---------------------------------------------------------------------
# Then the services and test database are initialized.
# ---------------------------------------------------------------------
self.database = DatabaseServices(test_database)
self.service = CustomContentServices(self.database)
# ---------------------------------------------------------------------
# Finally, entities and attributes are initialized to ease testing.
# ---------------------------------------------------------------------
self.user = User("samushka", "13")
self.database.add_user(self.user.username, self.user.password)
self.database.add_logged_in_user(self.user.username)
self.question_invalid = Question(1, "", "", "", "")
self.question = Question(1, "Category", "Difficulty", "Question?",
"Answer!")
self.database.save_question_item(
self.question.user_id,
self.question.category,
self.question.difficulty,
self.question.question,
self.question.answer,
)
def setup(env, conf, scenario):
scenario["containers"] = []
# Create and setup the resources
resources = {}
for i in range(conf["resources"]["number"]):
id_capacity_conf = random.randint(
0,
len(conf["resources"]["capacities"]) - 1)
resources[i] = Resource(
i, conf["resources"]["capacities"][id_capacity_conf], env, seed=i)
scenario["resources"] = resources
# Create Service Discovery process
service_discovery = ServiceDiscovery(env, resources, scenario)
scenario["SD"] = service_discovery
# Population infrastructure
for id in range(conf["users"]):
u = User(id, env, service_discovery, scenario)
env.process(u.start())
env.process(execution_context(env, scenario))
# setup function must be a simpy.generator, not elegant but...
while True:
yield env.timeout(10000000)
def setUp(self):
self.todo_service = TodoService(FakeTodoRepository(),
FakeUserRepository())
self.todo_a = Todo('testing a')
self.todo_b = Todo('testing b')
self.user_kalle = User('kalle', 'kalle123')
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_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 create_user(self, username, password, login=True):
"""Creates new user and logs the user in if login is set True
Args:
username (str): Username of the user
password (str): Password of the user
login:
Voluntary, default True.
Boolean-value, that tells if the user logs in after succesfull creation
of a new user
Raises:
UsernameExists: Raises exception if username is already taken
Returns:
New user as User-object
"""
existing_user = self.user_repository.find_by_username(username)
if existing_user:
raise UsernameExists(f'Username {username} already exists')
user = self.user_repository.create(User(username, password))
if login:
self.user = user
return user
def _create_user(user_creator: UserCreator, username: str,
hashed_pass: str) -> None:
try:
user_creator.create_user(User(username=username, password=hashed_pass))
except Exception as e:
print(e)
raise exceptions.Internal()
def signIn(username, password):
user = users_table.find_one(username=username)
if (user):
user = User(**(user))
if (password == user.password):
user.password = ''
return user
def check_session(request):
if 'session' not in request.cookies:
raise Unauthorized('You need to log in')
user = User(session=request.cookies['session'])
if user.check_session(jeopardyDB):
return user
raise Unauthorized('Invalid session')
def pickup():
global smart_car
# Retrieves the cookie header and splits the string so only the value remains
user_id = request.headers['Cookie'][3:]
# Parses the JSON payload
location = node_finder(carpool.graph, request.json["location"][0], request.json["location"][1])
destination = node_finder(carpool.graph, request.json["destination"][0], request.json["destination"][1])
# Finds or creates a user
user = carpool.find_user(user_id)
if user is None:
user = User(user_id, location, destination)
carpool.add_user(user)
# Updates the user's location with the ones send in the JSON payload
user.update_location(location)
car = carpool.logic(location, destination)
if car:
# If a car was found for the customer, then this customer is added as a passenger.
car.add_passenger(user)
# This returns the location of the car that was found.
return jsonify({"carLocation": car.location.json()}), 200
# This return message should be improved.
# The intention is to return status that no car was found.
return "no car"
def login():
user = User(request.form['name'], request.form['password'])
if(user.login(jeopardyDB)):
resp = make_response(json.dumps({}))
resp.set_cookie('session', value=user.session)
return resp
return jsonify(user.to_dict())
def log_in(self, username, password):
"""Log the user in, i.e. set self.user to User with given username and password.
Args:
username: The user's username.
password: The user's password."""
self.user = User(username, password)
def create_user(self, username, password, login=True):
"""Luo uuden käyttäjän ja tarvittaessa kirjaa sen sisään.
Args:
username: Merkkijonoarvo, joka kuvastaa käyttäjän käyttäjätunnusta.
password: Merkkijonoarvo, joka kuvastaa käyttäjän salasanaa.
login:
Vapaahtoinen, oletusarvo True.
Boolean-arvo, joka kertoo kirjataanko käyttäjä sisään onnistuneen luonnin jälkeen.
Raises:
UsernameExistsError: Virhe, joka tapahtuu, kun käyttäjätunnus on jo käytössä.
Returns:
Luotu käyttäjä User-olion muodossa.
"""
existing_user = self._user_repository.find_by_username(username)
if existing_user:
raise UsernameExistsError(f'Username {username} already exists')
user = self._user_repository.create(User(username, password))
if login:
self._user = user
return user
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 create(self, username, password, login=True):
"""Creates a new user and logs them in if needed.
Args:
username (str): User's username
password (str): User's password
login (bool, optional): Tells whether the user will be logged in. Defaults to True.
Raises:
UsernameExistsError: Raised if the username already exists.
Returns:
User: The user that has just been created.
"""
existing = self._user_repo.find_by_username(username)
if existing:
raise UsernameExistsError(f'Username {username} already exists')
user = self._user_repo.create(User(username, password))
if login:
self._user = user
return user
def post(self):
"""
Creates a user entry if user date is valid,
if no sends an error message
:return:
"""
user = self.request.get('user')
fullname = self.request.get('fullname')
password = self.request.get('password')
params = dict()
have_error = SignInValidator\
.user_data_are_valid(fullname, user, password, params)
if have_error:
self.render('signin.html', **params)
else:
salt = HashUtils.gen_salt()
hash = HashUtils.crypt(password, salt)
u = User(user=user,
fullname=fullname,
hash=hash,
salt=salt,
created=datetime.datetime.now())
u.put()
time.sleep(2)
self.response.set_cookie('user_id', u.hash)
self.response.set_cookie('user_desc', u.user)
self.redirect('/main')
def post(self):
try:
email = self.request.get('email')
hkey = self.request.get('hkey')
tenant_id = tenant.get_tenant_id(email)
namespace_manager.set_namespace(tenant_id)
if User.get_by_key_name(email):
raise AppError(u'このメールアドレスは、既に登録されています。')
if self.request.get('button') == 'Send Activate Key':
key = ActivateKey.make(email)
self.send_activate_key(email, key[:12])
hkey = key[12:]
self.render_template('signup.html', {'email': email, 'hkey': hkey})
return
else:
key = self.request.get('key1') + self.request.get('key2') + self.request.get('key3') + self.request.get('hkey')
if not ActivateKey.validate(email, key):
raise AppError(u'不正な Activate Key です。')
password = self.request.get('password')
if not string.strip(password):
raise AppError(u'パスワードが未入力です。')
user = User(key_name=email, email=email, password=hashlib.md5(email + password).hexdigest())
user.put()
self.redirect('/')
except AppError, e:
self.render_template('signup.html', {'error_msg': e.message, 'email': email, 'hkey': hkey})
async def put_flag_in_deleted_messages(request: PutRequest) -> Verdict:
async with Api(f'http://{request.hostname}:3000') as api:
user = User()
try:
await api.register(user.get_register_data())
await api.login(user.username, user.password)
except InvalidResponseException as e:
return Verdict.MUMBLE('Could not login or register',
traceback.format_exc())
except:
return Verdict.DOWN('Could not connect to service',
traceback.format_exc())
chat_name = utils.generate_random_text()
try:
chat_resp = await api.create(chat_name)
chat_id = chat_resp['chatId']
message_id_resp = await api.send_message(chat_id, request.flag)
message_id = message_id_resp['messageId']
await api.delete_message(message_id)
except:
return Verdict.MUMBLE(
'Could not create chat or invite link or send message',
traceback.format_exc())
return Verdict.OK(
f'{user.username}:{user.password}:{chat_id}:{message_id}')
def create_user(self, username, password):
if username in self._users:
return None
new_user = User(username, password, None)
self._users[username] = new_user
return new_user
