| @@ -1,119 +1,171 @@ | ||
| "use strict"; | ||
|
|
||
| $(function () { | ||
|
|
||
| $("#create_account").click(createAccountClick); | ||
|
|
||
| $("#forgot_pw").click(forgotPWClick); | ||
|
|
||
| $("button[name='cancel-add']").click(cancelAddClick); | ||
|
|
||
| $("button[name='pw_cancel']").click(cancelAddClick); | ||
|
|
||
| $("button[name='btnLogin']").click(loginClick); | ||
|
|
||
| $("button[name='save_user']").click(saveUserClick); | ||
|
|
||
| $("#new_user_box").on('hidden.bs.modal', onNewUserModalHide); | ||
|
|
||
| $("input[name='email_input_1']").blur(onEmail1InputBlur); | ||
|
|
||
| $("input[name='email_input_2']").blur(onEmail2InputBlur); | ||
|
|
||
| $("input[name='pw_input_1']").blur(onPw1InputBlur); | ||
|
|
||
| $("input[name='pw_input_2']").blur(onPw2InputBlur); | ||
|
|
||
| }); | ||
|
|
||
| function ValidateInputsMatch(matchClass, caseSensitive) { | ||
| var dotMatchClass = "." + matchClass | ||
| if ($(dotMatchClass).length == 0) { | ||
| throw new RangeError("There are no elements with class " + matchClass); | ||
| } | ||
| var firstValue = $(dotMatchClass).first().val(); | ||
| var loopValue = firstValue; | ||
| if (!caseSensitive) { | ||
| firstValue = firstValue.toLowerCase(); | ||
| } | ||
| var isMatch = true; | ||
| $(dotMatchClass).each(function () { | ||
| loopValue = $(this).val(); | ||
| if (!caseSensitive) { | ||
| loopValue = loopValue.toLowerCase(); | ||
| } | ||
| if (firstValue != loopValue) { | ||
| isMatch = false; | ||
| return isMatch; | ||
| } | ||
| }); | ||
| return isMatch; | ||
| } | ||
|
|
||
| function clearNewAccountWindow() { | ||
| $("input[name='email_input_1']").val(""); | ||
| $(".validation_message").addClass("hidden"); | ||
| $("input[name='email_input_2']").val(""); | ||
| $("input[name='pw_input_1']").val(""); | ||
| $("input[name='pw_input_2']").val(""); | ||
| $("input[name='ship_input']").val(""); | ||
| } | ||
|
|
||
|
|
||
| function createAccountClick() { | ||
| $('#new_user_box').modal('show'); | ||
| } | ||
|
|
||
| function forgotPWClick() { | ||
| $('#forgotten_pw_box').modal('show'); | ||
| } | ||
|
|
||
| function cancelAddClick() { | ||
| $('#new_user_box').modal('hide'); | ||
| } | ||
|
|
||
| function cancelForgotPassword() { | ||
| $('#forgotten_pw_box').modal('hide'); | ||
| } | ||
|
|
||
| function loginClick() { | ||
| $.ajax({ | ||
| url: 'login', | ||
| type: 'POST', | ||
| data: { | ||
| 'login': $("input[name='input_login']").val(), | ||
| 'pw': $("input[name='login_pw']").val() | ||
| }, | ||
| success: loginAjaxSuccess | ||
| }); | ||
| } | ||
|
|
||
| function saveUserClick() { | ||
| $.ajax({ | ||
| url: 'save_new_user', | ||
| type: 'POST', | ||
| data: { | ||
| 'email1': $("input[name='email_input_1']").val(), | ||
| 'email2': $("input[name='email_input_1']").val(), | ||
| 'pw1': $("input[name='pw_input_1']").val(), | ||
| 'pw2': $("input[name='pw_input_2']").val(), | ||
| 'shipName': $("input[name='ship_input']").val() | ||
| }, | ||
| success: loginAjaxSuccess | ||
| }); | ||
| } | ||
|
|
||
| function onNewUserModalHide() { | ||
| clearNewAccountWindow(); | ||
| } | ||
|
|
||
| function onEmail1InputBlur() { | ||
| $.ajax({ | ||
| url: 'validate/email', | ||
| type: 'POST', | ||
| data: { 'email': $("input[name='email_input_1']").val() }, | ||
| success: validateNewEmailAjaxSuccess | ||
| }); | ||
| } | ||
|
|
||
| function onEmail2InputBlur() { | ||
| if (ValidateInputsMatch("match_email")) { | ||
| $("#mismatched_email").addClass("hidden"); | ||
| }else { | ||
| $("#mismatched_email").removeClass("hidden"); | ||
| } | ||
| } | ||
|
|
||
| function onPw1InputBlur() { | ||
| if ($("input[name='pw_input_1']").val().length < 6) { | ||
| $("#short_pw").removeClass("hidden"); | ||
| } | ||
| else { | ||
| $("#short_pw").addClass("hidden"); | ||
| } | ||
| } | ||
|
|
||
| function onPw2InputBlur() { | ||
|
|
||
| if (ValidateInputsMatch("match_pw",true)) { | ||
| $("#mismatched_pw").addClass("hidden"); | ||
| } | ||
| else { | ||
| $("#mismatched_pw").removeClass("hidden"); | ||
| } | ||
| } | ||
|
|
||
| function validateNewEmailAjaxSuccess(data) { | ||
| if (data) { | ||
| $('.validation_success').addClass("hidden"); | ||
| $(data).removeClass("hidden"); | ||
| } | ||
| else { | ||
| $('.validation_success').removeClass("hidden"); | ||
| $('.email_error').addClass("hidden"); | ||
| } | ||
| } | ||
|
|
||
| function loginAjaxSuccess(data) { | ||
|
|
||
| $(".login_error").addClass("hidden"); | ||
|
|
||
| if (data['success']) { | ||
| window.location.replace("/") | ||
| } | ||
| else { | ||
| var errors = data['errors']; | ||
| for(var i = 0; i < errors.length; i++){ | ||
| $(errors[i]).removeClass("hidden"); | ||
| } | ||
| } | ||
| } | ||
|
|
| @@ -1,13 +1,39 @@ | ||
| from passlib.hash import pbkdf2_sha256 | ||
|
|
||
| """ | ||
| This module is a wrapper for encryption methods. | ||
| """ | ||
|
|
||
| def encrypt_str(str): | ||
|
|
||
| """ | ||
| This is a wrapper method for encrypting passwords | ||
| args: | ||
| str: this should be a string. This will be the password you want | ||
| to encrypt | ||
| returns: | ||
| the pbkdf2_sha256 encrypted version of str, the salt and other | ||
| useful information is built into it. | ||
| """ | ||
| hash = pbkdf2_sha256.encrypt(str) | ||
| return hash | ||
|
|
||
| def password_is_right(str,hash): | ||
| """ | ||
| wrapper to method that checks a password against the saved encrypted | ||
| password | ||
| args: | ||
| str: password sent by the user. We're checking to see if | ||
| it's the right one | ||
| hash: the encrypted version of the password that was saved in the | ||
| database | ||
| returns: | ||
| true or false: true if the str matches the hash, false if not. | ||
| """ | ||
| return pbkdf2_sha256.verify(str,hash) |
| @@ -0,0 +1,95 @@ | ||
| from SpaceUnitTest import SpaceUnitTest | ||
| import DatabaseLayer | ||
| import UserDBLayer | ||
| import MockDatabaseLayer | ||
| import AuthenticationLayer as auth | ||
|
|
||
| class Test_AuthenticationLayerTests(SpaceUnitTest): | ||
|
|
||
| @classmethod | ||
| def setUpClass(cls): | ||
| import MockSetUp | ||
| MockSetUp.set_up_mock_db_connections() | ||
| return super().setUpClass() | ||
|
|
||
| def tearDown(self): | ||
| MockDatabaseLayer.clean_up() | ||
| return super().tearDown() | ||
|
|
||
| def test_insert_new_user(self): | ||
| result = auth.insert_new_user("a@b.c","p","s") | ||
| self.assertEqual(result[0],MockDatabaseLayer.users+"0") | ||
| self.assertEqual(result[1],MockDatabaseLayer.accounts+"1") | ||
| self.assertEqual(result[2],MockDatabaseLayer.heros+"2") | ||
|
|
||
| def test_is_login_taken(self): | ||
| t = auth.is_login_taken("a@b.c") | ||
| self.assertFalse(t) | ||
| auth.insert_new_user("b@c.d","p","s") | ||
| t = auth.is_login_taken("b@c.d") | ||
| self.assertTrue(t) | ||
|
|
||
| def test_authenticate_user(self): | ||
| auth.insert_new_user("c@d.e","p","s") | ||
| result = auth.authenticate_user("d@e.f","") | ||
| self.assertEqual(len(result['errors']),1) | ||
| self.assertEqual(result['errors'][0],"#bad_login") | ||
| result = auth.authenticate_user("c@d.e","123") | ||
| self.assertEqual(len(result['errors']),1) | ||
| self.assertEqual(result['errors'][0],"#bad_login_pw") | ||
| result = auth.authenticate_user("c@d.e","p") | ||
| self.assertEqual(len(result['errors']),0) | ||
| self.assertTrue(result['success']) | ||
|
|
||
| def test_validate_email(self): | ||
| auth.insert_new_user("a@b.c","p","s") | ||
| t = auth.validate_email("@@") | ||
| self.assertFalse(t['success']) | ||
| self.assertEqual(t['messages'][0],"#bad_email") | ||
| t = auth.validate_email("a@b.c") | ||
| self.assertFalse(t['success']) | ||
| self.assertEqual(t['messages'][0],"#taken_email") | ||
| t = auth.validate_email("b@c.d") | ||
| self.assertTrue(t['success']) | ||
| self.assertEqual(t['messages'][0],"#good_email") | ||
|
|
||
| def test_validate_everything_new_user_bad_email(self): | ||
| t = auth.check_all_new_user_validations("bademail","bademail","123456","123456","ship") | ||
| self.assertEqual(len(t),1) | ||
| self.assertEqual(t[0],"#bad_email") | ||
|
|
||
|
|
||
| def test_validate_everything_new_user_bad_mismatched_email(self): | ||
| t = auth.check_all_new_user_validations("bademail","verybademail","123456","123456","ship") | ||
| self.assertEqual(len(t),2) | ||
| self.assertIn("#bad_email",t) | ||
| self.assertIn("#mismatched_email",t) | ||
|
|
||
| def test_validate_everything_new_user_bad_pw(self): | ||
| t = auth.check_all_new_user_validations("bademail","verybademail","123","123","ship") | ||
| self.assertEqual(len(t),3) | ||
| self.assertIn("#bad_email",t) | ||
| self.assertIn("#mismatched_email",t) | ||
| self.assertIn("#short_pw",t) | ||
|
|
||
|
|
||
| def test_validate_everything_new_user_bad_mismatched_pw(self): | ||
| t = auth.check_all_new_user_validations("bademail","verybademail","123","abc","ship") | ||
| self.assertEqual(len(t),4) | ||
| self.assertIn("#bad_email",t) | ||
| self.assertIn("#mismatched_email",t) | ||
| self.assertIn("#short_pw",t) | ||
| self.assertIn("#mismatched_pw",t) | ||
|
|
||
|
|
||
| def test_validate_everything_good_user_pw(self): | ||
| t = auth.check_all_new_user_validations("a@b.c","a@b.c","123456","123456","ship") | ||
| self.assertEqual(len(t),0) | ||
|
|
||
|
|
||
| def test_safe_insert_new_user(self): | ||
| id = auth.safe_insert_new_user("a","123") | ||
| self.assertEqual(id,"users0") | ||
|
|
||
| if __name__ == '__main__': | ||
| unittest.main() |
| @@ -0,0 +1,41 @@ | ||
| from SpaceUnitTest import SpaceUnitTest | ||
| from bson.objectid import ObjectId | ||
| from Account import COLLECTION_NAME as accounts | ||
| from Daily import COLLECTION_NAME as dailiesName | ||
| import random | ||
| import DatabaseLayer | ||
|
|
||
| class Test_Test_DatabaseLayer(SpaceUnitTest): | ||
| def setUp(self): | ||
| self.accountCount0 = DatabaseLayer.get_count_of_stuff_search({},accounts) | ||
| self.dailiesCount0 = DatabaseLayer.get_count_of_stuff_search({},dailiesName) | ||
| self.accountId = DatabaseLayer.insert_thing({'test':0},accounts) | ||
| testList = [] | ||
| self.controlList = [] | ||
| for i in range(0,500): | ||
| u = i // 100 | ||
| r = (500 -i) // 25 | ||
| f = i | ||
| tObj = {'ownerAccountId':self.accountId,'daysUntilTrigger':u,'urgency':r,'difficulty':f,'isCompleted':False} | ||
| testList.append(tObj) | ||
| self.controlList.append(tObj) | ||
| random.shuffle(testList) | ||
|
|
||
| for d in testList: | ||
| id = DatabaseLayer.insert_thing(d,dailiesName) | ||
| print(id) | ||
| print("done") | ||
| return super().setUp() | ||
|
|
||
| def tearDown(self): | ||
| dailyCollection = DatabaseLayer.get_table(dailiesName) | ||
| result = dailyCollection.delete_many( {'ownerAccountId':self.accountId}) | ||
| DatabaseLayer.delete_thing_by_key(self.accountId,accounts) | ||
| accountCount1 = DatabaseLayer.get_count_of_stuff_search({},accounts) | ||
| dailiesCount1 = DatabaseLayer.get_count_of_stuff_search({},dailiesName) | ||
| self.assertEqual(accountCount1,self.accountCount0) | ||
| self.assertEqual(dailiesCount1,self.dailiesCount0) | ||
| return super().tearDown() | ||
|
|
||
| if __name__ == '__main__': | ||
| unittest.main() |
| @@ -0,0 +1,36 @@ | ||
| from SpaceUnitTest import SpaceUnitTest | ||
| import MockDatabaseLayer | ||
| import MockDataLoader | ||
| import EverywhereConstants | ||
|
|
||
| class Test_MockDataLoader(SpaceUnitTest): | ||
| def test_insert_one_user(self): | ||
| idStuff = MockDataLoader.insert_one_user() | ||
| self.assertEqual(idStuff[EverywhereConstants.ID_KEY],"users0") | ||
| self.assertEqual(idStuff[MockDatabaseLayer.USER_LOGIN],"a@b.c") | ||
| self.assertEqual(len(idStuff[MockDatabaseLayer.USER_PASSWORD]),87) | ||
| self.assertEqual(len(idStuff[MockDatabaseLayer.USER_SALT]),32) | ||
| stuff = MockDatabaseLayer.get_thing_by_id(idStuff[EverywhereConstants.ID_KEY],MockDatabaseLayer.users) | ||
| self.assertTrue(MockDatabaseLayer.USER_PASSWORD in stuff) | ||
| self.assertTrue(MockDatabaseLayer.USER_LOGIN in stuff) | ||
| self.assertTrue(MockDatabaseLayer.USER_SALT in stuff) | ||
| login = stuff[MockDatabaseLayer.USER_LOGIN] | ||
| self.assertEqual(login,"a@b.c") | ||
| pw = stuff[MockDatabaseLayer.USER_PASSWORD] | ||
| self.assertEqual(len(pw),87) | ||
| salt = stuff[MockDatabaseLayer.USER_SALT] | ||
| self.assertEqual(len(salt),32) | ||
|
|
||
|
|
||
| def test_insert_user_mixed_case(self): | ||
| MockDatabaseLayer.insert_user("A@B.C","123","salt") | ||
| stuff = MockDatabaseLayer.get_user("a@b.c") | ||
| self.assertIsNotNone(stuff) | ||
| self.assertIn(MockDatabaseLayer.USER_DESC, stuff) | ||
| desc = stuff[MockDatabaseLayer.USER_DESC] | ||
| self.assertEqual(desc,"A@B.C") | ||
| login = stuff[MockDatabaseLayer.USER_LOGIN] | ||
| self.assertEqual(login, "a@b.c") | ||
|
|
||
| if __name__ == '__main__': | ||
| unittest.main() |
| @@ -0,0 +1,13 @@ | ||
| from SpaceUnitTest import SpaceUnitTest | ||
|
|
||
| class Test_SpaceUnitTest(SpaceUnitTest): | ||
| def test_assertBool(self): | ||
| t1 = None | ||
| t2 = 6 | ||
| self.assertRaises(AssertionError, lambda :self.assertFalse(t1)) | ||
| self.assertRaises(AssertionError, lambda :self.assertTrue(t2)) | ||
| self.assertNotEqual(t1,False) | ||
| self.assertNotEqual(t2,True) | ||
|
|
||
| if __name__ == '__main__': | ||
| unittest.main() |
| @@ -0,0 +1,34 @@ | ||
| from SpaceUnitTest import SpaceUnitTest | ||
| import TestFunctionBuilder | ||
|
|
||
| class Test_TestFunctionBuilder(SpaceUnitTest): | ||
| def test_build_sort_function_single_property(self): | ||
| dictDict = {} | ||
| dictDict[10] = {'a':0} | ||
| dictDict[11] = {'a':1} | ||
| dictDict[12] = {'a':2} | ||
| compareFieldList = [('a',1)] | ||
| comparer = TestFunctionBuilder.build_sort_by_function(compareFieldList,dictDict) | ||
| t = comparer(dictDict[10],dictDict[11]) | ||
| self.assertTrue(t) | ||
| t = comparer(dictDict[11],dictDict[10]) | ||
| self.assertFalse(t) | ||
| t = comparer(dictDict[10],dictDict[10]) | ||
| self.assertTrue(t) | ||
|
|
||
| def test_build_sort_function_double_property(self): | ||
| dictDict = {} | ||
| for i in range(0,15): | ||
| dictDict[10 + i] = {'a':i % 5, 'b': 15-i} | ||
| compareFieldList = [('a',1),('b',-1)] | ||
| comparer = TestFunctionBuilder.build_sort_by_function(compareFieldList,dictDict) | ||
| t = comparer(dictDict[10],dictDict[20]) | ||
| self.assertTrue(t) | ||
| t = comparer(dictDict[10],dictDict[11]) | ||
| self.assertTrue(t) | ||
| t = comparer(dictDict[10],dictDict[24]) | ||
| self.assertTrue(t) | ||
|
|
||
|
|
||
| if __name__ == '__main__': | ||
| unittest.main() |
| @@ -0,0 +1,53 @@ | ||
| from SpaceUnitTest import SpaceUnitTest | ||
| from Account import COLLECTION_NAME as TABLE_ACCOUNT | ||
| from Daily import COLLECTION_NAME as TABLE_DAILIES | ||
| import DatabaseLayer | ||
| import random | ||
|
|
||
|
|
||
| class Test_Daily(SpaceUnitTest): | ||
|
|
||
| def setUp(self): | ||
| self.accountCount0 = DatabaseLayer.get_count_of_stuff_search({},TABLE_ACCOUNT) | ||
| self.dailiesCount0 = DatabaseLayer.get_count_of_stuff_search({},TABLE_DAILIES) | ||
| self.accountId = DatabaseLayer.insert_thing({'test':0},TABLE_ACCOUNT) | ||
| testList = [] | ||
| self.controlList = [] | ||
| for i in range(0,500): | ||
| u = i // 100 | ||
| r = (500 -i) // 25 | ||
| f = i | ||
| tObj = {'ownerAccountId':self.accountId,'daysUntilTrigger':u,'urgency':r,'difficulty':f,'isCompleted':False} | ||
| testList.append(tObj) | ||
| self.controlList.append(tObj) | ||
| random.shuffle(testList) | ||
|
|
||
| for d in testList: | ||
| id = DatabaseLayer.insert_thing(d,TABLE_DAILIES) | ||
| print(id) | ||
| print("done") | ||
| return super().setUp() | ||
|
|
||
| def tearDown(self): | ||
| dailyCollection = DatabaseLayer.get_table(TABLE_DAILIES) | ||
| result = dailyCollection.delete_many( {'ownerAccountId':self.accountId}) | ||
| DatabaseLayer.delete_thing_by_key(self.accountId,TABLE_ACCOUNT) | ||
| accountCount1 = DatabaseLayer.get_count_of_stuff_search({},TABLE_ACCOUNT) | ||
| dailiesCount1 = DatabaseLayer.get_count_of_stuff_search({},TABLE_DAILIES) | ||
| self.assertEqual(accountCount1,self.accountCount0) | ||
| self.assertEqual(dailiesCount1,self.dailiesCount0) | ||
| return super().tearDown() | ||
|
|
||
|
|
||
|
|
||
|
|
||
| def test_db_daily_sorting(self): | ||
| import Daily | ||
| dailies = Daily.get_dailies_by_account(self.accountId) | ||
| for d,c in zip(dailies,self.controlList): | ||
| self.assertEqual(d['daysUntilTrigger'],c.daysUntilTrigger) | ||
| self.assertEqual(d['urgency'],c.urgency) | ||
| self.assertEqual(d['difficulty'],c.difficulty) | ||
|
|
||
| if __name__ == '__main__': | ||
| unittest.main() |
| @@ -0,0 +1,101 @@ | ||
| from SpaceUnitTest import SpaceUnitTest | ||
| import SpaceHabitServer | ||
| import MockSetUp | ||
| import threading | ||
| import cherrypy | ||
| import time | ||
| from selenium import webdriver | ||
| import SeleniumHelper | ||
| import requests | ||
| import MockDataLoader | ||
|
|
||
|
|
||
|
|
||
| class Test_LoginPageTest(SpaceUnitTest): | ||
|
|
||
| @classmethod | ||
| def setUpClass(cls): | ||
| MockSetUp.set_up_mock_db_connections() | ||
| cls.server = SpaceHabitServer.HabitServer() | ||
| cls.server.start() | ||
| ticks = 0 | ||
| while cherrypy.engine.state != cherrypy.engine.states.STARTED: | ||
| time.sleep(1) | ||
| ticks += 1 | ||
| if ticks >= 10: | ||
| raise TimeoutError("ran out of time") | ||
| return super().setUpClass() | ||
|
|
||
| @classmethod | ||
| def tearDownClass(cls): | ||
| cls.server.stop() | ||
| ticks = 0 | ||
| while cherrypy.engine.state != cherrypy.engine.states.STOPPED: | ||
| time.sleep(1) | ||
| ticks += 1 | ||
| if ticks >= 10: | ||
| raise TimeoutError("ran out of time") | ||
| return super().tearDownClass() | ||
|
|
||
| def setUp(self): | ||
| self.driver = webdriver.Firefox() | ||
| self.driver.implicitly_wait(5) | ||
| self.driver.get("http://127.0.0.1:8080") | ||
| return super().setUp() | ||
|
|
||
| def tearDown(self): | ||
| import MockDatabaseLayer | ||
| MockDatabaseLayer.clean_up() | ||
| self.driver.quit() | ||
| return super().tearDown() | ||
|
|
||
| def test_initial_page_is_login(self): | ||
| self.assertEqual(self.driver.current_url,"http://127.0.0.1:8080/login/") | ||
| self.assertEqual(self.driver.title,"Login to Space Habit Frontier") | ||
|
|
||
| def test_login_page_default_state(self): | ||
| elem = self.driver.find_element_by_id("bad_login") | ||
| self.assertFalse(elem.is_displayed()) | ||
|
|
||
| elem = self.driver.find_element_by_id("bad_login_pw") | ||
| self.assertFalse(elem.is_displayed()) | ||
|
|
||
| elem = self.driver.find_element_by_id("new_user_box") | ||
| self.assertFalse(elem.is_displayed()) | ||
|
|
||
| elem = self.driver.find_element_by_id("forgotten_pw_box") | ||
| self.assertFalse(elem.is_displayed()) | ||
|
|
||
| def open_new_user_box(self): | ||
| clickElem = self.driver.find_element_by_id("create_account") | ||
| clickElem.click() | ||
|
|
||
| def test_create_user_model_validation_is_clean(self): | ||
| self.open_new_user_box() | ||
| elem = self.driver.find_element_by_id("new_user_box") | ||
| self.assertTrue(elem.is_displayed()) | ||
|
|
||
| elem = self.driver.find_element_by_id("bad_email") | ||
| self.assertFalse(elem.is_displayed()) | ||
|
|
||
| elem = self.driver.find_element_by_id("taken_email") | ||
| self.assertFalse(elem.is_displayed()) | ||
|
|
||
| elem = self.driver.find_element_by_id("mismatched_email") | ||
| self.assertFalse(elem.is_displayed()) | ||
|
|
||
| elem = self.driver.find_element_by_id("good_email") | ||
| self.assertFalse(elem.is_displayed()) | ||
|
|
||
| elem = self.driver.find_element_by_id("short_pw") | ||
| self.assertFalse(elem.is_displayed()) | ||
|
|
||
| elem = self.driver.find_element_by_id("mismatched_pw") | ||
| self.assertFalse(elem.is_displayed()) | ||
|
|
||
|
|
||
|
|
||
|
|
||
|
|
||
| if __name__ == '__main__': | ||
| unittest.main() |
| @@ -0,0 +1,113 @@ | ||
| from SpaceUnitTest import SpaceUnitTest | ||
| import SpaceHabitServer | ||
| import MockSetUp | ||
| import threading | ||
| import cherrypy | ||
| import time | ||
| import requests | ||
| import MockDataLoader | ||
| import MockDatabaseLayer | ||
| import json | ||
|
|
||
|
|
||
| class Test_LoginSaveNewUserWithRequests(SpaceUnitTest): | ||
|
|
||
| @classmethod | ||
| def setUpClass(cls): | ||
| MockSetUp.set_up_mock_db_connections() | ||
| cls.server = SpaceHabitServer.HabitServer() | ||
| cls.server.start() | ||
| ticks = 0 | ||
| while cherrypy.engine.state != cherrypy.engine.states.STARTED: | ||
| time.sleep(1) | ||
| ticks += 1 | ||
| if ticks >= 10: | ||
| raise TimeoutError("ran out of time") | ||
| return super().setUpClass() | ||
|
|
||
| @classmethod | ||
| def tearDownClass(cls): | ||
| cls.server.stop() | ||
| ticks = 0 | ||
| while cherrypy.engine.state != cherrypy.engine.states.STOPPED: | ||
| time.sleep(1) | ||
| ticks += 1 | ||
| if ticks >= 10: | ||
| raise TimeoutError("ran out of time") | ||
| return super().tearDownClass() | ||
|
|
||
| def tearDown(self): | ||
| import MockDatabaseLayer | ||
| MockDatabaseLayer.clean_up() | ||
| return super().tearDown() | ||
|
|
||
| def test_send_success(self): | ||
| s = requests.Session() | ||
| r = s.post("http://127.0.0.1:8080/login/save_new_user/",params={'email1':"a@b.c", | ||
| 'email2':"a@b.c",'pw1':"123456",'pw2':"123456",'shipName':"USS Enterprise"}) | ||
| self.assertEqual(r.status_code,200) | ||
| data = json.loads(r.text) | ||
| self.assertEqual(data['success'], True) | ||
|
|
||
|
|
||
| def test_insert_user_missing_param(self): | ||
| s = requests.Session() | ||
| r = s.post("http://127.0.0.1:8080/login/save_new_user/",params={'email1':"a@b.c", | ||
| 'email2':"a@b.c",'pw1':"123456",'pw2':"123456"}) | ||
| self.assertEqual(r.status_code,404) | ||
|
|
||
|
|
||
| def test_send_missing_input2_pw1_pw2(self): | ||
| s = requests.Session() | ||
| r = s.post("http://127.0.0.1:8080/login/save_new_user/",params={'email1':"a@b.c", | ||
| 'email2':"",'pw1':"",'pw2':"",'shipName':""}) | ||
| self.assertEqual(r.status_code,200) | ||
| data = json.loads(r.text) | ||
| self.assertEqual(data['success'], False) | ||
|
|
||
|
|
||
| def test_send_missing_pw(self): | ||
| s = requests.Session() | ||
| r = s.post("http://127.0.0.1:8080/login/save_new_user/",params={'email1':"a@b.c", | ||
| 'email2':"a@b.c",'pw1':"",'pw2':"",'shipName':""}) | ||
| self.assertEqual(r.status_code,200) | ||
| data = json.loads(r.text) | ||
| self.assertEqual(data['success'], False) | ||
|
|
||
|
|
||
| def test_send_taken_email(self): | ||
| MockDataLoader.insert_one_user() | ||
| s = requests.Session() | ||
| r = s.post("http://127.0.0.1:8080/login/save_new_user/",params={'email1':"a@b.c", | ||
| 'email2':"a@b.c",'pw1':"123456",'pw2':"123456",'shipName':""}) | ||
| self.assertEqual(r.status_code,200) | ||
| data = json.loads(r.text) | ||
| self.assertEqual(data['success'], False) | ||
|
|
||
| def test_send_mismatched_email(self): | ||
| s = requests.Session() | ||
| r = s.post("http://127.0.0.1:8080/login/save_new_user/",params={'email1':"a@b.c", | ||
| 'email2':"b@c.d",'pw1':"123456",'pw2':"123456",'shipName':""}) | ||
| self.assertEqual(r.status_code,200) | ||
| data = json.loads(r.text) | ||
| self.assertEqual(data['success'], False) | ||
|
|
||
| def test_send_bad_pw(self): | ||
| s = requests.Session() | ||
| r = s.post("http://127.0.0.1:8080/login/save_new_user/",params={'email1':"a@b.c", | ||
| 'email2':"b@c.d",'pw1':"123",'pw2':"123",'shipName':""}) | ||
| self.assertEqual(r.status_code,200) | ||
| data = json.loads(r.text) | ||
| self.assertEqual(data['success'], False) | ||
|
|
||
| def test_send_mismatched_pw(self): | ||
| s = requests.Session() | ||
| r = s.post("http://127.0.0.1:8080/login/save_new_user/",params={'email1':"a@b.c", | ||
| 'email2':"b@c.d",'pw1':"123456",'pw2':"abcdef",'shipName':""}) | ||
| self.assertEqual(r.status_code,200) | ||
| data = json.loads(r.text) | ||
| self.assertEqual(data['success'], False) | ||
|
|
||
|
|
||
| if __name__ == '__main__': | ||
| unittest.main() |
| @@ -0,0 +1,92 @@ | ||
| from SpaceUnitTest import SpaceUnitTest | ||
| from selenium import webdriver | ||
| from selenium.webdriver.support.ui import WebDriverWait | ||
| from selenium.webdriver.support import expected_conditions as EC | ||
| import SpaceHabitServer | ||
| import MockSetUp | ||
| import threading | ||
| import cherrypy | ||
| import time | ||
| import requests | ||
| import MockDataLoader | ||
| import MockDatabaseLayer | ||
| import SeleniumHelper | ||
|
|
||
|
|
||
| class Test_LoginSaveNewUser(SpaceUnitTest): | ||
|
|
||
| @classmethod | ||
| def setUpClass(cls): | ||
| MockSetUp.set_up_mock_db_connections() | ||
| cls.server = SpaceHabitServer.HabitServer() | ||
| cls.server.start() | ||
| ticks = 0 | ||
| while cherrypy.engine.state != cherrypy.engine.states.STARTED: | ||
| time.sleep(1) | ||
| ticks += 1 | ||
| if ticks >= 10: | ||
| raise TimeoutError("ran out of time") | ||
| return super().setUpClass() | ||
|
|
||
| @classmethod | ||
| def tearDownClass(cls): | ||
| cls.server.stop() | ||
| ticks = 0 | ||
| while cherrypy.engine.state != cherrypy.engine.states.STOPPED: | ||
| time.sleep(1) | ||
| ticks += 1 | ||
| if ticks >= 10: | ||
| raise TimeoutError("ran out of time") | ||
| return super().tearDownClass() | ||
|
|
||
| def setUp(self): | ||
| self.driver = webdriver.Firefox() | ||
| self.driver.implicitly_wait(5) | ||
| self.driver.get("http://127.0.0.1:8080") | ||
| self.input1 = self.driver.find_element_by_xpath("//input[@name='email_input_1']") | ||
| self.input2 = self.driver.find_element_by_xpath("//input[@name='email_input_2']") | ||
| self.pw1 = self.driver.find_element_by_xpath("//input[@name='pw_input_1']") | ||
| self.pw2 = self.driver.find_element_by_xpath("//input[@name='pw_input_2']") | ||
| self.modal = self.driver.find_element_by_id("new_user_box") | ||
| self.loginEmail = self.driver.find_element_by_xpath("//input[@name='input_login']") | ||
| self.loginPw = self.driver.find_element_by_xpath("//input[@name='login_pw']") | ||
| self.loginButton = self.driver.find_element_by_xpath("//button[@name='btnLogin']") | ||
| return super().setUp() | ||
|
|
||
|
|
||
| def tearDown(self): | ||
| import MockDatabaseLayer | ||
| MockDatabaseLayer.clean_up() | ||
| self.driver.quit() | ||
| return super().tearDown() | ||
|
|
||
|
|
||
| def open_new_user_box(self): | ||
| clickElem = self.driver.find_element_by_id("create_account") | ||
| clickElem.click() | ||
|
|
||
| def test_create_new_user(self): | ||
| self.open_new_user_box() | ||
| self.input1.send_keys("a@b.c") | ||
| self.input2.send_keys("a@b.c") | ||
| self.pw1.send_keys("123456") | ||
| self.pw2.send_keys("123456") | ||
| self.driver.find_element_by_xpath("//button[@name='save_user']").click() | ||
| WebDriverWait(self.driver,10).until(EC.title_is("Space Habit Frontier!")) | ||
| self.assertEqual(self.driver.title,"Space Habit Frontier!") | ||
|
|
||
| def test_login(self): | ||
| from selenium.common.exceptions import TimeoutException | ||
| MockDataLoader.insert_one_user() | ||
| self.loginEmail.send_keys("a@b.c") | ||
| self.loginPw.send_keys("123456") | ||
| self.loginButton.click() | ||
| WebDriverWait(self.driver,10).until(EC.title_is("Space Habit Frontier!")) | ||
| self.assertEqual(self.driver.title,"Space Habit Frontier!") | ||
| self.driver.get("http://127.0.0.1:8080/login") | ||
| self.assertRaises(TimeoutException,lambda :WebDriverWait(self.driver,5).until(EC.title_is("Login to Space Habit Frontier"))) | ||
|
|
||
|
|
||
|
|
||
| if __name__ == '__main__': | ||
| unittest.main() |
| @@ -0,0 +1,48 @@ | ||
| from SpaceUnitTest import SpaceUnitTest | ||
| import SpaceHabitServer | ||
| import MockSetUp | ||
| import threading | ||
| import cherrypy | ||
| import time | ||
| from selenium import webdriver | ||
| import requests | ||
| import MockDataLoader | ||
| import MockDatabaseLayer | ||
| import SeleniumHelper | ||
|
|
||
| class Test_PlaygroundLoad(SpaceUnitTest): | ||
|
|
||
| @classmethod | ||
| def setUpClass(cls): | ||
| MockSetUp.set_up_mock_db_connections() | ||
| cls.server = SpaceHabitServer.HabitServer() | ||
| cls.server.start() | ||
| ticks = 0 | ||
| while cherrypy.engine.state != cherrypy.engine.states.STARTED: | ||
| time.sleep(1) | ||
| ticks += 1 | ||
| if ticks >= 10: | ||
| raise TimeoutError("ran out of time") | ||
| return super().setUpClass() | ||
|
|
||
| @classmethod | ||
| def tearDownClass(cls): | ||
| cls.server.stop() | ||
| ticks = 0 | ||
| while cherrypy.engine.state != cherrypy.engine.states.STOPPED: | ||
| time.sleep(1) | ||
| ticks += 1 | ||
| if ticks >= 10: | ||
| raise TimeoutError("ran out of time") | ||
| return super().tearDownClass() | ||
|
|
||
|
|
||
| def test_load(self): | ||
| driver = webdriver.Firefox() | ||
| driver.implicitly_wait(5) | ||
| driver.get("http://127.0.0.1:8080/playground") | ||
| self.assertEqual(driver.title,"Test Playground") | ||
| driver.quit() | ||
|
|
||
| if __name__ == '__main__': | ||
| unittest.main() |
| @@ -0,0 +1,211 @@ | ||
| from SpaceUnitTest import SpaceUnitTest | ||
| from selenium import webdriver | ||
| from selenium.webdriver.support.ui import WebDriverWait | ||
| from selenium.webdriver.support import expected_conditions as EC | ||
| import SpaceHabitServer | ||
| import MockSetUp | ||
| import threading | ||
| import cherrypy | ||
| import time | ||
| import requests | ||
| import MockDataLoader | ||
| import MockDatabaseLayer | ||
| import AuthenticationLayer | ||
|
|
||
| class Test_LoginJSTest(SpaceUnitTest): | ||
|
|
||
| @classmethod | ||
| def setUpClass(cls): | ||
| MockSetUp.set_up_mock_db_connections() | ||
| cls.server = SpaceHabitServer.HabitServer() | ||
| cls.server.start() | ||
| ticks = 0 | ||
| while cherrypy.engine.state != cherrypy.engine.states.STARTED: | ||
| time.sleep(1) | ||
| ticks += 1 | ||
| if ticks >= 10: | ||
| raise TimeoutError("ran out of time") | ||
| return super().setUpClass() | ||
|
|
||
| @classmethod | ||
| def tearDownClass(cls): | ||
| cls.server.stop() | ||
| ticks = 0 | ||
| while cherrypy.engine.state != cherrypy.engine.states.STOPPED: | ||
| time.sleep(1) | ||
| ticks += 1 | ||
| if ticks >= 10: | ||
| raise TimeoutError("ran out of time") | ||
| return super().tearDownClass() | ||
|
|
||
| def setUp(self): | ||
| self.driver = webdriver.Firefox() | ||
| self.driver.implicitly_wait(5) | ||
| self.driver.get("http://127.0.0.1:8080") | ||
| self.input1 = self.driver.find_element_by_xpath("//input[@name='email_input_1']") | ||
| self.input2 = self.driver.find_element_by_xpath("//input[@name='email_input_2']") | ||
| self.pw1 = self.driver.find_element_by_xpath("//input[@name='pw_input_1']") | ||
| self.pw2 = self.driver.find_element_by_xpath("//input[@name='pw_input_2']") | ||
| self.ship = self.driver.find_element_by_xpath("//input[@name='ship_input']") | ||
| self.newUserModal = self.driver.find_element_by_id("new_user_box") | ||
| self.pwModal = self.driver.find_element_by_id("forgotten_pw_box") | ||
| return super().setUp() | ||
|
|
||
| def tearDown(self): | ||
| import MockDatabaseLayer | ||
| MockDatabaseLayer.clean_up() | ||
| self.driver.quit() | ||
| return super().tearDown() | ||
|
|
||
| def open_new_user_box(self): | ||
| clickElem = self.driver.find_element_by_id("create_account") | ||
| clickElem.click() | ||
|
|
||
| def test_clearNewAccountWindow(self): | ||
| self.open_new_user_box() | ||
| self.input1.send_keys("aaaaa") | ||
| self.input2.send_keys("bbbbb") | ||
| self.pw1.send_keys("cccc") | ||
| self.pw2.send_keys("dddd") | ||
| self.ship.send_keys("eeee") | ||
| self.driver.execute_script("clearNewAccountWindow();") | ||
| self.assertEqual(self.input1.get_attribute('value'),"") | ||
| self.assertEqual(self.input2.get_attribute('value'),"") | ||
| self.assertEqual(self.pw1.get_attribute('value'),"") | ||
| self.assertEqual(self.pw2.get_attribute('value'),"") | ||
| self.assertEqual(self.ship.get_attribute('value'),"") | ||
|
|
||
| elem = self.driver.find_element_by_id("bad_email") | ||
| self.assertFalse(elem.is_displayed()) | ||
|
|
||
| elem = self.driver.find_element_by_id("taken_email") | ||
| self.assertFalse(elem.is_displayed()) | ||
|
|
||
| elem = self.driver.find_element_by_id("mismatched_email") | ||
| self.assertFalse(elem.is_displayed()) | ||
|
|
||
| elem = self.driver.find_element_by_id("good_email") | ||
| self.assertFalse(elem.is_displayed()) | ||
|
|
||
| elem = self.driver.find_element_by_id("short_pw") | ||
| self.assertFalse(elem.is_displayed()) | ||
|
|
||
| elem = self.driver.find_element_by_id("mismatched_pw") | ||
| self.assertFalse(elem.is_displayed()) | ||
|
|
||
|
|
||
| def test_createAccountClick(self): | ||
| elem = self.driver.find_element_by_id("new_user_box") | ||
| self.assertFalse(elem.is_displayed()) | ||
| self.driver.execute_script("createAccountClick();") | ||
| self.assertTrue(elem.is_displayed()) | ||
|
|
||
|
|
||
| def test_forgotPWClick(self): | ||
| self.assertFalse(self.pwModal.is_displayed()) | ||
| self.driver.execute_script("forgotPWClick();") | ||
| self.assertTrue(self.pwModal.is_displayed()) | ||
|
|
||
|
|
||
| def test_cancelAddClick(self): | ||
| self.open_new_user_box() | ||
| self.assertTrue(self.newUserModal.is_displayed()) | ||
| self.driver.execute_script("cancelAddClick();") | ||
| self.assertFalse(self.newUserModal.is_displayed()) | ||
|
|
||
|
|
||
| def test_cancelForgotPassword(self): | ||
| self.driver.find_element_by_id("forgot_pw").click() | ||
| self.assertTrue(self.pwModal.is_displayed()) | ||
| self.driver.execute_script("cancelForgotPassword();") | ||
| self.assertFalse(self.pwModal.is_displayed()) | ||
|
|
||
|
|
||
| def test_validateEmailAjaxSuccess(self): | ||
| self.open_new_user_box() | ||
| self.driver.execute_script("validateNewEmailAjaxSuccess('#bad_email');") | ||
|
|
||
| elem = self.driver.find_element_by_id("bad_email") | ||
| self.assertTrue(elem.is_displayed()) | ||
|
|
||
| self.driver.execute_script("validateNewEmailAjaxSuccess('#taken_email');") | ||
|
|
||
| elem = self.driver.find_element_by_id("bad_email") | ||
| self.assertTrue(elem.is_displayed()) | ||
|
|
||
| elem = self.driver.find_element_by_id("taken_email") | ||
| self.assertTrue(elem.is_displayed()) | ||
|
|
||
| self.driver.execute_script("validateNewEmailAjaxSuccess('');") | ||
|
|
||
| elem = self.driver.find_element_by_id("bad_email") | ||
| self.assertFalse(elem.is_displayed()) | ||
|
|
||
| elem = self.driver.find_element_by_id("taken_email") | ||
| self.assertFalse(elem.is_displayed()) | ||
|
|
||
| elem = self.driver.find_element_by_id("good_email") | ||
| self.assertTrue(elem.is_displayed()) | ||
|
|
||
| def test_loginAjaxSuccessSession(self): | ||
| AuthenticationLayer.disableAuthenticationRedirects = True | ||
| self.driver.execute_script("loginAjaxSuccess({'errors':[\"#bad_login\",\"#bad_login_pw\"],'success':false});") | ||
|
|
||
| self.assertEqual(self.driver.title,"Login to Space Habit Frontier") | ||
| elem = self.driver.find_element_by_id("bad_login") | ||
| self.assertTrue(elem.is_displayed()) | ||
| elem = self.driver.find_element_by_id("bad_login_pw") | ||
| self.assertTrue(elem.is_displayed()) | ||
|
|
||
| self.driver.execute_script("loginAjaxSuccess({'errors':[\"#bad_login_pw\"],'success':false});") | ||
|
|
||
| self.assertEqual(self.driver.title,"Login to Space Habit Frontier") | ||
| elem = self.driver.find_element_by_id("bad_login") | ||
| self.assertFalse(elem.is_displayed()) | ||
| elem = self.driver.find_element_by_id("bad_login_pw") | ||
| self.assertTrue(elem.is_displayed()) | ||
|
|
||
| self.driver.execute_script("loginAjaxSuccess({'errors':[],'success':true});") | ||
| #WebDriverWait(self.driver,10).until(EC.title_is("Space Habit Frontier!")) | ||
| self.assertEqual(self.driver.title,"Space Habit Frontier!") | ||
|
|
||
| def test_onEmail2InputBlur(self): | ||
| self.open_new_user_box() | ||
| self.input1.send_keys("a@b.c") | ||
| self.input2.send_keys("b@c.d") | ||
| self.driver.execute_script("onEmail2InputBlur();") | ||
| elem = self.driver.find_element_by_id("mismatched_email") | ||
| self.assertTrue(elem.is_displayed()) | ||
| self.input2.clear() | ||
| self.input2.send_keys("a@b.c") | ||
| self.assertEqual(self.input1.get_attribute('value'),self.input2.get_attribute('value')) | ||
| self.driver.execute_script("onEmail2InputBlur();") | ||
| self.assertFalse(elem.is_displayed()) | ||
|
|
||
| def test_onPw1InputBlur(self): | ||
| self.open_new_user_box() | ||
| self.pw1.send_keys("123") | ||
| self.driver.execute_script("onPw1InputBlur();") | ||
| elem = self.driver.find_element_by_id("short_pw") | ||
| self.assertTrue(elem.is_displayed()) | ||
| self.pw1.clear() | ||
| self.pw1.send_keys("123456") | ||
| self.driver.execute_script("onPw1InputBlur();") | ||
| self.assertFalse(elem.is_displayed()) | ||
|
|
||
| def test_onPw2InputBlur(self): | ||
| self.open_new_user_box() | ||
| self.pw1.send_keys("abcdef") | ||
| self.pw2.send_keys("Abcdef") | ||
| self.driver.execute_script("onPw2InputBlur();") | ||
| elem = self.driver.find_element_by_id("mismatched_pw") | ||
| self.assertTrue(elem.is_displayed()) | ||
| self.pw2.clear() | ||
| self.pw2.send_keys("abcdef") | ||
| self.assertEqual(self.pw1.get_attribute('value'),self.pw2.get_attribute('value')) | ||
| self.driver.execute_script("onPw2InputBlur();") | ||
| self.assertFalse(elem.is_displayed()) | ||
|
|
||
|
|
||
| if __name__ == '__main__': | ||
| unittest.main() |
| @@ -0,0 +1,108 @@ | ||
| from SpaceUnitTest import SpaceUnitTest | ||
| import SpaceHabitServer | ||
| import MockSetUp | ||
| import threading | ||
| import cherrypy | ||
| import time | ||
| from selenium import webdriver | ||
| import requests | ||
| import MockDataLoader | ||
| import MockDatabaseLayer | ||
| import SeleniumHelper | ||
|
|
||
| class Test_PlaygroundLoginJS(SpaceUnitTest): | ||
|
|
||
| @classmethod | ||
| def setUpClass(cls): | ||
| MockSetUp.set_up_mock_db_connections() | ||
| cls.server = SpaceHabitServer.HabitServer() | ||
| cls.server.start() | ||
| ticks = 0 | ||
| while cherrypy.engine.state != cherrypy.engine.states.STARTED: | ||
| time.sleep(1) | ||
| ticks += 1 | ||
| if ticks >= 10: | ||
| raise TimeoutError("ran out of time") | ||
| return super().setUpClass() | ||
|
|
||
| @classmethod | ||
| def tearDownClass(cls): | ||
| cls.server.stop() | ||
| ticks = 0 | ||
| while cherrypy.engine.state != cherrypy.engine.states.STOPPED: | ||
| time.sleep(1) | ||
| ticks += 1 | ||
| if ticks >= 10: | ||
| raise TimeoutError("ran out of time") | ||
| return super().tearDownClass() | ||
|
|
||
| def setUp(self): | ||
| self.driver = webdriver.Firefox() | ||
| self.driver.implicitly_wait(5) | ||
| self.driver.get("http://127.0.0.1:8080/playground") | ||
| self.input1 = self.driver.find_element_by_xpath("//input[@name='input1']") | ||
| self.input2 = self.driver.find_element_by_xpath("//input[@name='input2']") | ||
| self.input3 = self.driver.find_element_by_xpath("//input[@name='input3']") | ||
| self.email1 = self.driver.find_element_by_xpath("//input[@name='email_input_1']") | ||
| self.email2 = self.driver.find_element_by_xpath("//input[@name='email_input_2']") | ||
| self.pw1 = self.driver.find_element_by_xpath("//input[@name='pw_input_1']") | ||
| self.pw2 = self.driver.find_element_by_xpath("//input[@name='pw_input_2']") | ||
| self.ship = self.driver.find_element_by_xpath("//input[@name='ship_input']") | ||
| return super().setUp() | ||
|
|
||
| def tearDown(self): | ||
| import MockDatabaseLayer | ||
| MockDatabaseLayer.clean_up() | ||
| self.driver.quit() | ||
| return super().tearDown() | ||
|
|
||
| def test_match(self): | ||
| self.input1.send_keys("abcdefg") | ||
| self.input2.send_keys("abcdefg") | ||
| self.input3.send_keys("abcdefg") | ||
| r = self.driver.execute_script("return ValidateInputsMatch('match');") | ||
| self.assertTrue(r) | ||
|
|
||
| def test_match_two(self): | ||
| self.email1.send_keys("abcdefg") | ||
| self.email2.send_keys("abcdefg") | ||
| r = self.driver.execute_script("return ValidateInputsMatch('match_email');") | ||
| self.assertTrue(r) | ||
|
|
||
| def test_mismatch_two(self): | ||
| self.email1.send_keys("abcdefg") | ||
| self.email2.send_keys("abcd") | ||
| r = self.driver.execute_script("return ValidateInputsMatch('match_email');") | ||
| self.assertFalse(r) | ||
|
|
||
| def test_mismatch_first(self): | ||
| self.input1.send_keys("abcdefi") | ||
| self.input2.send_keys("abcdefg") | ||
| self.input3.send_keys("abcdefg") | ||
| r = self.driver.execute_script("return ValidateInputsMatch('match');") | ||
| self.assertFalse(r) | ||
|
|
||
| def test_mismatch_last(self): | ||
| self.input1.send_keys("abcdefg") | ||
| self.input2.send_keys("abcdefg") | ||
| self.input3.send_keys("abcdefj") | ||
| r = self.driver.execute_script("return ValidateInputsMatch('match');") | ||
| self.assertFalse(r) | ||
|
|
||
| def test_match_empty(self): | ||
| from selenium.common.exceptions import WebDriverException | ||
| self.assertRaises(WebDriverException,lambda :self.driver.execute_script("return ValidateInputsMatch('empty');")) | ||
|
|
||
|
|
||
| def test_caseSensitivity(self): | ||
| self.input1.send_keys("abcdefg") | ||
| self.input2.send_keys("Abcdefg") | ||
| self.input3.send_keys("abcdefg") | ||
| r = self.driver.execute_script("return ValidateInputsMatch('match',true);") | ||
| self.assertFalse(r) | ||
| r = self.driver.execute_script("return ValidateInputsMatch('match');") | ||
| self.assertTrue(r) | ||
|
|
||
|
|
||
| if __name__ == '__main__': | ||
| unittest.main() |
| @@ -0,0 +1,27 @@ | ||
| class MockDBResult(object): | ||
| """ | ||
| This will be used with the mock version of get_sorted_stuff_by_search. | ||
| It's basically a mock mongodb cursor | ||
| """ | ||
|
|
||
| def __init__(self,data): | ||
| """ | ||
| args: | ||
| data: | ||
| this should be a list of dicts. Doesn't really matter | ||
| what's in those dicts | ||
| """ | ||
| self._data = data | ||
|
|
||
| def next(self): | ||
| """ | ||
| this is a generator function that gets the next item in the list | ||
| yieds: | ||
| a dict containing dummy data most likely | ||
| """ | ||
| for d in self._data: | ||
| yield d | ||
|
|
||
|
|
| @@ -1,7 +1,9 @@ | ||
| import MockDatabaseLayer | ||
| import AuthenticationLayer | ||
| import EverywhereConstants | ||
|
|
||
| def insert_one_user(): | ||
| cryptPair = AuthenticationLayer.get_new_user_encrypted_details("123456") | ||
| id = MockDatabaseLayer.insert_user("a@b.c",cryptPair[0],cryptPair[1]) | ||
| return {EverywhereConstants.ID_KEY:id,MockDatabaseLayer.USER_LOGIN:"a@b.c", | ||
| MockDatabaseLayer.USER_PASSWORD:cryptPair[0],MockDatabaseLayer.USER_SALT:cryptPair[1]} |