class TestContact(unittest.TestCase):
'''
Test class that defines the test cases for the the user class behaviours.
Args:
unittest.TestCase: TestCase class that helps in creating test cases
'''
def setUp(self):
'''
Setup method to run before each test case
'''
self.new_user = User('Joseph', 'Adediji', '123456')
def test_init(self):
'''
test_init test case to test if the object is initialized properly
'''
self.assertEqual(self.new_user.first_name, "Joseph")
self.assertEqual(self.new_user.last_name, "Adediji")
self.assertEqual(self.new_user.password, "123456")
def test_save_user(self):
'''
Test to check if the new users info is saved into the users list
'''
self.new_user.save_user()
self.assertEqual(len(User.users_list), 1)
def tearDown(self):
'''
tearDown method that does clean up after each test case has run.
'''
User.users_list = []
def process_message(message_obj):
""" Processes a message:
Step 1: Finds user in database or creates new user
Step 2: Store raw message object in database
Step 3: Formulate response
"""
user_id, timestamp, message = ut.extract_obj_info(message_obj)
#=====[ Find user in db ]=====
user = users.find_one({"user_id": user_id})
#=====[ Add message to existing user database or add new user ]=====
if not user:
#=====[ Create new user ]=====
user = User(user_id)
users.insert_one({"user_id":user_id, "user_object": pickle.dumps(user)})
else:
user = pickle.loads(user["user_object"])
#=====[ Store message in user object ]=====
user.add_message(message)
#=====[ Formulates and sends response ]=====
respond(message, user)
def main():
TOKEN = get_token()
API = auth(TOKEN)
lapssh = User('stupport', API)
print(lapssh.groups_get())
target_id = get_target(API)
target = User(target_id, API)
get_age(target) # получаем возраст цели
if not target.city: # уточняем город цели
get_city(target)
base_users = get_match_users(
target, API) # получаем список найденных пользователей
get_top3_photos(base_users, API) # сопоставляем три фотограифи
sorted_users = reversed(sorted(
base_users, key=operator.attrgetter('kpi'))) # сортируем по весам
# - - - П Р А В К И - - -
if sql.get_db_status() == False:
db = False # проверка доступности БД
else:
db = True
sql.delete_tables() # удаляем старые таблицы
sql.create_db(target.id) # создаем новые таблицы
for i in sorted_users:
temp = i.show_result()
# print(temp)
temp_json = json.dumps(temp)
if db:
sql.add_user(i.id, i.kpi,
temp_json) # отправляем все, что нашли в БД
else:
file_base.add_user(i.id, i.kpi,
temp_json) # отправляем все, что нашли в файл
show_results(db) # выводим результат
def test_query_for_user(self):
my_user = User(VALID_UNAME, VALID_PSSWD)
rv = main.query_for_user(my_user)
assert rv is not None
my_user = User(INVALID_UNAME, INVALID_PSSWD)
rv = main.query_for_user(my_user)
assert rv is None
def test_save_multiple_user(self):
'''
check if we can hold multiple user accounts
'''
self.new_user.save_user()
test_user = User("andrew", "password")
test_user.save_user()
self.assertEqual(len(User.user_list), 2)
def test_user_exists(self):
self.new_user.save_new_user()
test_user = User("James","jamo") # new contact
test_user.save_new_user()
user_exists = User.user_exist("James")
self.assertTrue(user_exists)
def test_authenticate_user(self):
my_user = User(VALID_UNAME, VALID_PSSWD)
rv = main.authenticate_user(my_user)
assert rv == True
my_user = User(INVALID_UNAME, INVALID_PSSWD)
rv = main.authenticate_user(my_user)
assert rv == False
def test_multiple_account(self):
'''
this test case tocheck if we can save multiple
accounts
'''
self.new_user.save_account()
another_account=User("shema yvan","yvan-buravan")
another_account.save_account()
self.assertEqual(len(User.user_account),2)
def test_save_multiple_users(self):
'''
test_save_multiple_contact to check if we can save multiple contact
objects to our contact_list
'''
self.new_user.save_new_user()
test_user = User("juya","1234") # new user
test_user.save_new_user()
self.assertEqual(len(User.list_of_users),2)
def test_save_multiple_user(self):
'''
to check if we can save multiple user
objects to our contact_list
'''
self.new_user.save_user()
test_user = User("test", "user", "babigando") # new contact
test_user.save_user()
self.assertEqual(len(User.user_list), 2)
def test_find_account(self):
'''
this test case checks whether you can find an
account using the user name
'''
self.new_user.save_account()
another_account=User("shema yvan","yvan-buravan")
another_account.save_account()
find_acc=User.find_by_name("shema yvan")
self.assertEqual(find_acc.password,another_account.password)
def test_account_saved(self):
'''
This test case checks wether the account is saved
or not
'''
self.new_user.save_account()
another_account=User("shema yvan","yvan-buravan")
another_account.save_account()
accounts_saved=User.account_saved("shema yvan")
self.assertTrue(accounts_saved)
def test_delete_user(self):
'''
test_delete_contact to test if we can remove a contact from our contact list
'''
self.new_user.save_new_user()
test_user = User("testy","Simpson") # new contact
test_user.save_new_user()
self.new_user.delete_user()# Deleting a contact object
self.assertEqual(len(User.list_of_users),1)
def test_delete_user(self):
'''
test_delete_user to test if we can remove a user from our user list
'''
self.new_user.save_user()
test_user = User("michael", "password")
test_user.save_user()
self.new_user.delete_user()
self.assertEqual(len(User.user_list), 1)
def test_delete_account(self):
'''
this test case check wether a user can delete the
account
'''
self.new_user.save_account()
another_account=User("shema yvan","yvan-buravan")
another_account.save_account()
self.new_user.delete_acc()
self.assertEqual(len(User.user_account),1)
def main_menu():
print('which one do you want to do?\n'
'1-sign in\n'
'2-sign up\n'
'3-close program')
try:
sign_input = int(input('- '))
except ValueError:
print('Only integers are allowed!')
logging.error('invalid input in main menu: not a number')
main_menu()
else:
if sign_input == 1:
user_line = []
username = input('enter username: '******'r') as f:
reader = csv.reader(f, delimiter=',')
for line in reader:
if line[1] == username:
user_line.append(line)
break
if len(user_line) == 1:
user = User(user_line[0][0], user_line[0][1], user_line[0][2],
user_line[0][3], user_line[0][4])
log_output = User.log_in(user)
if log_output:
logging.info('user logged in')
print('user logged in successfully!')
task_menu(user)
else:
print('Wrong password!')
logging.warning('wrong password')
main_menu()
else:
print('username does not exist!')
logging.warning('entered username does not exist')
main_menu()
elif sign_input == 2:
id = user_id()
user = create_account(id)
add_user_to_file(user)
logging.info('new user added')
print('new account created')
main_menu()
elif sign_input == 3:
print('See You Later:)')
logging.info('user exit')
exit()
else:
print('Invalid input: number does not exist in menu')
logging.warning(
'invalid input in main menu: unavailable number in menu')
main_menu()
def test_find_user_by_name(self):
'''
test to check if we can find a user by name and display information
'''
self.new_user.save_new_user()
test_user = User("testy","Simpson")
test_user.save_new_user()
active_user = User.find_by_name("testy")
print(active_user.user_name)
self.assertEqual(active_user.user_name,test_user.user_name)
def register():
form = Form()
if request.method == "GET":
return render_template('register.html', form=form)
if request.method == "POST":
name = request.form['name']
email = request.form['email']
password = request.form['password']
user = User()
user.save_user_in_db(name, email, password)
return render_template('login.html')
def generate_face_ads(self):
photo = config.face_photos
user = User(config.email, config.password)
user.register()
user.authorize()
for i in photo:
photo = user.user_upload_image(i)
photo = photo["data"]
photo = photo[0].get("id")
user.create_ad(ad_photos=photo)
def login():
if request.method == "GET":
return render_template('login.html')
if request.method == "POST":
user = User()
email = request.form['email']
password = request.form['password']
if user.login(email, password):
flash("Successful log in")
return redirect(url_for('home'))
else:
flash("Wrong deatils")
return redirect(url_for('login'))
def get(self):
"""Get mail blast."""
db = connect_to_cloudsql()
cursor = db.cursor()
cursor.execute('SELECT username, password, email, fname, \
lname, dob, timezone, email_verified FROM '
+ ENV_DB + '.Users')
rows = cursor.fetchall()
for row in rows:
user = User(*row)
rec = recommender.Recommend(user)
events = rec.get_events()
interests = set()
for e in events:
interests.add(e[-3])
for (event_index, e) in enumerate(events):
events[event_index] = helper_strip_date(e)
formatted_event_email(user.email, list(interests), events)
# event_string = ''
# for eid, ename, desc, start_date, end_date, num_cap, num_attending, lname, add, tag, lat, lon in events:
# if (desc is None):
# desc = ''
# event_string += "{}, {} to {}, {}/{} filled\n{}\n\n".format(ename, start_date, end_date, num_attending, num_cap, desc)
# print(event_string)
# body = 'Hey {},\n\nHere are some upcoming events we think you might be interested in:\n\n\n{}'.format(user.fname, event_string)
# print(user.email)
# send_events_email(user.email, body)
return ({}, 200)
def test_methods():
"""
Testing user methods
"""
test_user = User(20, "*****@*****.**", "fkoij1f", "Richard", "Park", "richardpark", constants.PERMISSION_GLOBAL_OWNER)
assert test_user.is_owner_of_slackr()
assert not test_user.is_member_of_slackr()
assert test_user.release_user_info() == {
"u_id": 20,
"email": "*****@*****.**",
"name_first": "Richard",
"name_last": "Park",
"handle_str": "richardpark"
}
def main():
# Authentification
api = auth_api()
users = pd.read_csv('depressed_username_and_userid.csv')['username'].tolist()
for username in users:
print('USERNAME: '******'KILL PROCRESS NOW')
time.sleep(5)
except tw.TweepError as error:
print(error)
def create_NewUser(myE, myHR, myA, myAvg, myTi, myID):
""" This function creates a new User object with associated input values.
Args:
myE: String Email address of user.
myHR: float64, heart rate of user. Converts to np.array
myA: int, age of user.
myAvg: int, forced average heart rate.
myTi: string, time at point of data entry.
Returns:
A User object with associated input values installed.
"""
if not isinstance(myE, str) or not isinstance(myA, int) or not isinstance(
myTi, list) or not isinstance(myAvg, float):
raise TypeError(
"Error: Values did not match correct types. Please try again.")
if not isinstance(myHR, int) and not isinstance(myHR, float):
raise TypeError(
"Error2: Values did not match correct types. Please try again.")
myHR = np.array([myHR])
x = User(myE, myA, myHR, myAvg, myTi, myID)
return x
def getProfile(self, entryList):
# this method saves Wnrey values from user to a local variable,
# After, is called a method for saving new user information on DB
#userParms = [str(entryList[0]), str(entryList[1]), int(entryList[2]), str(entryList[3])]
userParms = []
for i in entryList:
userParms.append(i.get())
userLogic = User(userParms)
userLogic.setUserDb()
profTab = tkinter.Tk()
profTab.title('User Info shuld be saved on DB')
nameLabel = tkinter.Label(profTab, text='Name ' + str(userLogic.name))
nameLabel.pack()
profTab.mainloop
def test_properties():
"""
Testing basic user properties
"""
test_user = User(20, "*****@*****.**", "fkoij1f", "Richard", "Park", "richardpark", constants.PERMISSION_GLOBAL_OWNER)
# Test u_id getter
assert test_user.u_id == 20
# Test u_id setter
test_user.u_id = 4
assert test_user.u_id == 4
# Test email getter
assert test_user.email == "*****@*****.**"
# Test email setter
test_user.email = "*****@*****.**"
assert test_user.email == "*****@*****.**"
# Test password getter
assert test_user.password == "fkoij1f"
# Test password setter
test_user.password = "******"
assert test_user.password == "testpassword"
# Test handle setter
assert test_user.handle == "richardpark"
# Test handle getter
test_user.handle = "stevenyang"
assert test_user.handle == "stevenyang"
# Test name_first getter
assert test_user.name_first == "Richard"
# Test name_first setter
test_user.name_first = "Steven"
assert test_user.name_first == "Steven"
assert test_user.name_first == test_user._name_first
# Test name_last getter
assert test_user.name_last == "Park"
# Test name_last setter
test_user.name_last = "Yang"
assert test_user.name_last == "Yang"
assert test_user.name_last == test_user._name_last
# Test global_permission_id getter
assert test_user.global_permission_id == constants.PERMISSION_GLOBAL_OWNER
# Test global_permission_id setter
test_user.global_permission_id = constants.PERMISSION_GLOBAL_MEMBER
assert test_user.global_permission_id == constants.PERMISSION_GLOBAL_MEMBER
def discussion_board(board):
'''
Discussion Board Thead pages: Performs GET, POST, DELETE, PUT, or PATCH action based on the requet method.
Parameters:
board
Returns:
dependant on method
'''
if request.method == 'GET':
resp = User().get_thread(board)
if resp is None:
return jsonify({"error": "Thread not found"}), 404
resp = jsonify(resp)
resp.status_code = 200
return resp
elif request.method == 'POST':
post_to_add = request.get_json()
resp = User().add_post(post_to_add, board)
if resp is None:
return jsonify({"error": "Thread not found"}), 404
resp = jsonify(post_to_add)
resp.status_code = 201
return resp
elif request.method == 'DELETE':
post = request.get_json()
if User().remove_post(post, board):
return post
return jsonify({"error": "Post not found"}), 404
elif request.method == 'PUT':
reply = request.get_json()
resp = User().reply_to_post(reply, board)
if resp is None:
return jsonify({"error": "Thread or Post not found"}), 404
resp = jsonify(resp)
resp.status_code = 201
return resp
def load_user(username):
cursor = g.conn.execute("SELECT * FROM Users U WHERE U.username=%s",
username)
data = cursor.fetchone()
cursor.close()
if data is None:
return None
return User(data[1], data[2], data[3], data[0])
def get_team_roster():
'''
Team Roster page: Performs GET, POST, or DELETE action based on the request method.
Parameters:
None
Returns:
resp (JSON): Contains status code and object based on the request method.
'''
collection = User().get_collection('TeamRoster')
if request.method == 'GET':
name = request.args.get('name')
status = request.args.get('member_status')
position = request.args.get('position')
specialization = request.args.get('specialization')
filters = roster_get_link_parse(name, status, position, specialization)
resp = jsonify(
User().find_by_filter(filters[0], collection, filters[1])
)
resp.status_code = 201
elif request.method == 'POST':
user_to_add = request.get_json()
User().add_user(user_to_add, collection)
resp = jsonify(user_to_add)
resp.status_code = 201
elif request.method == 'DELETE':
user_id = request.args.get('_id')
if User().remove_user(user_id, collection):
resp = jsonify(user_id)
resp.status_code = 201
else:
resp = jsonify({"error": "User not found"})
resp.status_code = 404
return resp
def generate_watches(self, ads_min_id, ads_max_id):
i = 0
while i < self.users_count:
if self.users_count != 1:
email_number = 100 * int(self.thread_number) + i + 1
email = config.email.format(str(email_number))
user = User(email, config.password)
user.register()
user.authorize()
y = ads_min_id
while y < self.watches_count + ads_min_id:
user.watch_ad(random.randint(ads_min_id, ads_max_id))
y += 1
def login():
error = None
if request.method == 'POST':
test_user = User(request.form['username'], request.form['password'])
if authenticate_user(test_user):
login_user(test_user)
return redirect(url_for('main'))
error = 'Invalid Credentials. Please try again.'
return render_template('login.html', error=error)
