def testTrainingsAPIInput():
connection = sqlite3.connect("incollege_test.db")
cursor = connection.cursor()
cursor.execute("DROP TABLE IF EXISTS trainings")
db.initTables(cursor)
incollege.inputAPITrainings(cursor, connection)
assert len(db.getAllTrainings(cursor)) <= len(API.createTrainings())
def testJobsAPIInput():
connection = sqlite3.connect("incollege_test.db")
cursor = connection.cursor()
cursor.execute("DROP TABLE IF EXISTS jobs")
db.initTables(cursor)
incollege.inputAPIJobs(cursor, connection)
assert db.getNumJobs(cursor) <= len(API.createJobs())
def testInvalidFriendSearch(monkeypatch): # todo: fix (broke because of change in findUser function)
monkeypatch.setattr("sys.stdin", StringIO("2\n"))
settings.currentState = states.userSearch
connection = sqlite3.connect("incollege_test.db")
cursor = connection.cursor()
db.initTables(cursor)
db.insertUser(cursor, "username1", "password", "first", "last", 0, "01/01/2020")
def testStudentAccountAPIInput():
connection = sqlite3.connect("incollege_test.db")
cursor = connection.cursor()
cursor.execute("DROP TABLE IF EXISTS Users") #delete tables to make sure no conflicts when running test multiple times
db.initTables(cursor)
incollege.inputAPIUsers(cursor, connection)
assert db.getNumUsers(cursor) <= len(API.createStudentAccounts())
def testCreateUser(): # todo: potentially change this test to utilize createUser function from main program instead
connection = sqlite3.connect("incollege_test.db")
cursor = connection.cursor()
# Initialize database and run insert function
db.initTables(cursor)
db.insertUser(cursor, "username", "password", "first", "last", 0, "01/01/2020")
assert db.getUserByName(cursor, "username") # Check successful insert
connection.close()
def testUpdateUserLanguage():
connection = sqlite3.connect("incollege_test.db")
cursor = connection.cursor()
db.initTables(cursor)
db.insertUserSettings(cursor, "testname", 1, 1, 1, "testlanguage")
db.updateUserLanguage(cursor, "testname", "testlanguage2")
userSetting = namedtuple('User', 'uname emailnotif smsnotif targetadvert languagepref')
currentUser = userSetting._make(db.getUserSettingsByName(cursor, "testname"))
assert currentUser.languagepref == "testlanguage2"
def testCreateStudentProfile():
connection = sqlite3.connect("incollege_test.db")
cursor = connection.cursor()
db.initTables(cursor)
db.insertProfilePage(cursor, "uname", "major", "university", "about")
db.insertProfileEducation(cursor, "uname", "university_name", "user_degree", "2016", "2020")
db.insertProfileJob(cursor, "uname", "title", "employer", "date_start", "date_end", "location", "job_description")
assert db.getProfilePage(cursor, "uname") is not None
assert db.getProfileJobs(cursor, "uname") is not None
assert db.getProfileEducation(cursor, "uname") is not None
def testMaxAccountsCreated(monkeypatch, capfd):
connection = sqlite3.connect("incollege_test.db")
cursor = connection.cursor()
db.initTables(cursor)
for i in range(10):
db.insertUser(cursor, f"username{i}", "password", f"first{i}", f"last{i}", 0, "01/01/2020")
users.createUser(cursor, connection)
out, err = capfd.readouterr() # Output should display max users created
assert out == "All permitted accounts have been created, please come back later\n"
assert db.getNumUsers(cursor) == 10
def testValidJobPost(monkeypatch):
monkeypatch.setattr("sys.stdin", StringIO("Title\nDescription\nEmpName\nLocation\n1"))
connection = sqlite3.connect("incollege_test.db")
cursor = connection.cursor()
db.initTables(cursor)
db.insertUser(cursor, "username1", "password", "first", "last", 0, "01/01/2020")
settings.signedInUname = "username1"
jobs.postJob(cursor, connection)
out = db.getJobByTitle(cursor, "Title") # Confirms that job has been added into DB correctly
assert out is not None
def testInvalidUserLogin(monkeypatch, capfd):
monkeypatch.setattr("sys.stdin", StringIO("username1\npassword\nusername2\npassword\n")) #invalid credentials first, valid credentials second
connection = sqlite3.connect("incollege_test.db")
cursor = connection.cursor()
db.initTables(cursor)
db.insertUser(cursor, "username2", "password", "first", "last", 0, "01/01/2020")
settings.signedIn = False # fix
users.loginUser(cursor, connection) # Fails because it gets trapped in while loop
out, err = capfd.readouterr()
assert "Enter your password: Incorrect" in out
assert settings.signedIn
def testValidUserLogin(monkeypatch, capfd):
connection = sqlite3.connect("incollege_test.db")
cursor = connection.cursor()
cursor.execute("DROP TABLE IF EXISTS Users")
db.initTables(cursor)
db.insertUser(cursor, "username1", "password", "first", "last", 0, "01/01/2020")
db.insertUserSettings(cursor, "username1", "*****@*****.**", "123-123-1234", 0, "English")
monkeypatch.setattr("sys.stdin", StringIO("username1\npassword\n")) # Patch in user input
users.loginUser(cursor, connection)
out, err = capfd.readouterr() # Output should display successfully sign in and state change
assert "You have successfully logged in." in out
assert settings.signedIn
def testSendFriendRequest(monkeypatch):
monkeypatch.setattr("sys.stdin", StringIO("A\nfirst2 last2\nY\n"))
connection = sqlite3.connect("incollege_test.db")
cursor = connection.cursor()
cursor.execute("DROP TABLE IF EXISTS Users") #delete tables to make sure no conflicts when running test multiple times
db.initTables(cursor)
db.insertUser(cursor, "username1", "password", "first1", "last1", 0, "2020-01-01 12:30:00")
db.insertUser(cursor, "username2", "password", "first2", "last2", 0, "2020-01-01 12:30:00")
settings.signedInUname = "username1"
settings.signedIn = True
settings.currentState = states.userSearch
users.findUser(cursor, connection)
assert len(db.getUserFriendRequests(cursor, "username2")) == 1
def testUserAlreadyExists(monkeypatch, capfd):
monkeypatch.setattr("sys.stdin", StringIO("username1\nusername2\nPassword1!\nfname\nlname\nN\n")) #after username1 is taken, pick a different uname and exit menu
connection = sqlite3.connect("incollege_test.db")
cursor = connection.cursor()
cursor.execute("DROP TABLE IF EXISTS Users") #delete tables to make sure no conflicts when running test multiple times
cursor.execute("DROP TABLE IF EXISTS user_settings")
cursor.execute("DROP TABLE IF EXISTS profile_page")
db.initTables(cursor)
db.insertUser(cursor, "username1", "password", "first", "last", 0, "01/01/2020")
users.createUser(cursor, connection)
out, err = capfd.readouterr()
assert "Sorry, that username has already been taken" in out
assert settings.currentState == states.loggedOut
def testImportantLinks(monkeypatch, capfd):
monkeypatch.setattr("sys.stdin", StringIO("f\nz\nz\nz\n"))
settings.signedInUname = "username1"
connection = sqlite3.connect("incollege_test.db")
cursor = connection.cursor()
cursor.execute("DROP TABLE IF EXISTS Users") #delete tables to make sure no conflicts when running test multiple times
cursor.execute("DROP TABLE IF EXISTS profile_page")
db.initTables(cursor)
db.insertUser(cursor, "username1", "password", "first1", "last1", 0, "2020-01-01 12:30:00")
db.insertProfilePage(cursor, "username1", "major", "university", "about")
settings.currentState = states.mainMenu
ui.enterMainMenu(cursor, connection)
out, err = capfd.readouterr()
assert "Important Links" in out
def testCreateMaxJobPosts(capfd):
connection = sqlite3.connect("incollege_test.db")
cursor = connection.cursor()
cursor.execute("DROP TABLE IF EXISTS Users") #delete tables to make sure no conflicts when running test multiple times
cursor.execute("DROP TABLE IF EXISTS jobs")
db.initTables(cursor)
db.insertUser(cursor, "username1", "password", "first1", "last1", 0, "01/01/2020")
for _ in range(10):
db.insertJob(cursor, "title", "desc", "emp", "loc", "sal", "username1")
jobs.postJob(cursor, connection)
out, err = capfd.readouterr()
assert "All permitted jobs have been created, please come back later.\n" in out
assert db.getNumJobs(cursor) == 10
assert settings.currentState == states.jobMenu
def testApplyForJob(monkeypatch):
connection = sqlite3.connect("incollege_test.db")
cursor = connection.cursor()
cursor.execute("DROP TABLE IF EXISTS Users") #delete tables to make sure no conflicts when running test multiple times
cursor.execute("DROP TABLE IF EXISTS user_job_applications")
db.initTables(cursor)
db.insertUser(cursor, "username1", "password", "first1", "last1", 0, "01/01/2020")
db.insertUser(cursor, "username2", "password", "first2", "last2", 0, "01/01/2020")
db.insertJob(cursor, "title1", "desc1", "emp1", "loc1", "sal1", "first1 last1")
selectedJob = db.getAllJobs(cursor)[0]
settings.signedInUname = "username2"
monkeypatch.setattr("sys.stdin", StringIO("1\n01/01/1234\n01/02/1234\ncredentials\n"))
jobs.applyForJob(cursor, connection, selectedJob)
assert len(db.getAppliedJobs(cursor, "username2")) == 1
def testFavoriteAJob(monkeypatch):
connection = sqlite3.connect("incollege_test.db")
cursor = connection.cursor()
cursor.execute("DROP TABLE IF EXISTS Users") #delete tables to make sure no conflicts when running test multiple times
cursor.execute("DROP TABLE IF EXISTS favorited_jobs")
db.initTables(cursor)
db.insertUser(cursor, "username1", "password", "first1", "last1", 0, "2020-01-01 12:30:00")
db.insertUser(cursor, "username2", "password", "first2", "last2", 0, "2020-01-01 12:30:00")
db.insertJob(cursor, "title1", "desc1", "emp1", "loc1", "sal1", "first1 last1")
selectedJob = db.getAllJobs(cursor)[0]
settings.signedInUname = "username2"
monkeypatch.setattr("sys.stdin", StringIO("b\nz\n"))
jobs.viewJobDetails(cursor, connection, selectedJob)
assert len(db.getFavoriteJobsByUser(cursor, "username2")) == 1
def testRemoveFriend(monkeypatch):
monkeypatch.setattr("sys.stdin", StringIO("A\n1\nZ\n"))
connection = sqlite3.connect("incollege_test.db")
cursor = connection.cursor()
cursor.execute("DROP TABLE IF EXISTS Users") #delete tables to make sure no conflicts when running test multiple times
cursor.execute("DROP TABLE IF EXISTS user_friends")
db.initTables(cursor)
db.insertUser(cursor, "uname", "password", "first", "last", 0, "01/01/2020")
db.insertUser(cursor, "friend_uname", "password", "first2", "last2", 0, "01/01/2020")
db.insertUserFriend(cursor, "uname", "friend_uname")
db.insertUserFriend(cursor, "friend_uname", "uname")
settings.currentState = states.friendsMenu
settings.signedInUname = "uname"
ui.enterFriendsMenu(cursor, connection)
assert settings.currentState == states.mainMenu
assert len(db.getUserFriendsByName(cursor, "uname")) == 0
def testDeleteJobPost(monkeypatch):
connection = sqlite3.connect("incollege_test.db")
cursor = connection.cursor()
cursor.execute("DROP TABLE IF EXISTS Users") #delete tables to make sure no conflicts when running test multiple times
db.initTables(cursor)
db.insertUser(cursor, "username1", "password", "first1", "last1", 0, "2020-01-01 12:30:00")
db.insertUser(cursor, "username2", "password", "first2", "last2", 0, "2020-01-01 12:30:00")
settings.signedInUname = "username1"
db.insertJob(cursor, "title1", "desc1", "emp1", "loc1", "sal1", "first1 last1")
db.insertJob(cursor, "title2", "desc2", "emp2", "loc2", "sal2", "first1 last1")
assert db.getNumJobs(cursor) == 2
db.insertUserJobApplication(cursor, "username2", "title1", "01/01/1243", "01/02/1243", "credentials", "2020-01-01 12:30:00")
monkeypatch.setattr("sys.stdin", StringIO("1\nN\n"))
jobs.enterDeleteAJobMenu(cursor, connection)
assert db.getNumJobs(cursor) == 1
assert len(db.getAppliedJobs(cursor, "username2")) == 0
def testViewFriendList(monkeypatch, capfd):
connection = sqlite3.connect("incollege_test.db")
cursor = connection.cursor()
cursor.execute("DROP TABLE IF EXISTS Users") #delete tables to make sure no conflicts when running test multiple times
db.initTables(cursor)
db.insertUser(cursor, "uname", "password", "first", "last", 0, "01/01/2020")
db.insertUser(cursor, "friend_uname", "password", "first2", "last2", 0, "01/01/2020")
db.insertUserFriend(cursor, "uname", "friend_uname")
settings.currentState = states.friendsMenu
settings.signedInUname = "uname"
monkeypatch.setattr("sys.stdin", StringIO("Z\n"))
ui.enterFriendsMenu(cursor, connection)
out, err = capfd.readouterr()
assert out is not None
assert settings.currentState == states.mainMenu
assert db.getUserFriendsByName(cursor, "uname") is not None
def testProfileAddFourJobs(monkeypatch, capfd):
connection = sqlite3.connect("incollege_test.db")
cursor = connection.cursor()
cursor.execute("DROP TABLE IF EXISTS profile_jobs")
db.initTables(cursor)
db.insertUser(cursor, "uname", "password", "first", "last", 0, "01/01/2020")
db.insertProfilePage(cursor, "uname", "major", "university", "about")
for _ in range(3): # add 3 jobs
db.insertProfileJob(cursor, "uname", "title", "employer", "date_start", "date_end", "location", "job_description")
settings.currentState = states.profilePage #settings needed for enterProfilePageMenu to work
settings.signedInUname = "uname"
monkeypatch.setattr("sys.stdin", StringIO("a\nd\nz\nz\n")) #navigate menu. pressing d tries to add a new job which should fail
profiles.enterProfilePageMenu(cursor, connection)
out, err = capfd.readouterr()
assert out is not None
assert len(db.getProfileJobs(cursor, settings.signedInUname)) == 3
assert settings.currentState == states.mainMenu
def testAcceptFriendRequest(monkeypatch):
monkeypatch.setattr("sys.stdin", StringIO("A\n"))
connection = sqlite3.connect("incollege_test.db")
cursor = connection.cursor()
cursor.execute("DROP TABLE IF EXISTS Users") #delete tables to make sure no conflicts when running test multiple times
cursor.execute("DROP TABLE IF EXISTS friend_requests")
cursor.execute("DROP TABLE IF EXISTS user_friends")
db.initTables(cursor)
db.insertUser(cursor, "username1", "password", "first1", "last1", 0, "01/01/2020")
db.insertUser(cursor, "username2", "password", "first2", "last2", 0, "01/01/2020")
db.insertFriendRequest(cursor, "username1", "username2")
settings.signedInUname = "username2"
utils.handleUserFriendRequests(cursor, connection, settings.signedInUname)
assert len(db.getUserFriendsByName(cursor, "username1")) == 1
assert len(db.getUserFriendsByName(cursor, "username2")) == 1
assert ((db.getUserFriendsByName(cursor, "username1"))[0])[0] == "username2"
assert ((db.getUserFriendsByName(cursor, "username2"))[0])[0] == "username1"
def testInsertUserSettings():
connection = sqlite3.connect("incollege_test.db")
cursor = connection.cursor()
db.initTables(cursor)
db.insertUserSettings(cursor, "testname", 1, 1, 1, "testlanguage")
assert db.getUserSettingsByName(cursor, "testname") is not None
# Incorrect day code
# Check if received number that was waiting
if number in waitingNums:
print "received number name", number,":", body
# Add name and phone number to database
database.addPhoneAndName(number, body)
waitingNums.remove(number)
form.send(number,body)
return twilioResponse("Thanks " + body+ "! Your attendance has been recorded!")
else:
print "Received incorrect day code", number, ":", body
return twilioResponse("Incorrect Day Code!")
phone.exposed = True
def slack(self, **params):
if params["channel_id"] == "G033ULLLB":
return getDayHash()[:4]
else:
return self.phone(From="@" + params["user_name"], Body=params["text"]).split("<Message>")[1].split("</Message>")[0]
slack.exposed = True
database.initTables()
cherrypy.config.update({
'server.socket_port': config.port,
'server.socket_host': config.host
})
cherrypy.quickstart(PhoneServer())
def install(): try: initTables() except: pass
def testAddFriend():
connection = sqlite3.connect("incollege_test.db")
cursor = connection.cursor()
db.initTables(cursor)
db.insertUserFriend(cursor, "uname", "friend_uname")
assert db.getUserFriendsByName(cursor, "uname") is not None
import profiles
import settings
import states
import ui
import users
import training
import API
# connect to database
connection = sqlite3.connect('inCollege.db')
# create cursor
cursor = connection.cursor()
# create tables if none exist
db.initTables(cursor)
# Create users
def inputAPIUsers(dbCursor, dbConnection):
today = date.today() # Get today's date
date_format = "%m/%d/%Y"
todayDate = today.strftime(date_format) # Format date mm/dd/yyyy
currentDate = datetime.strptime(todayDate,
date_format) # Today's date as a string
user_count = db.getNumUsers(dbCursor)
student_accounts = API.createStudentAccounts()
if student_accounts:
for obj in student_accounts:
# only create up to 10 accounts, don't recreate accounts
def install():
try:
initTables()
except:
pass
