class TestUser(unittest.TestCase): def setUp(self): ''' it ensure that the code is running in each instance of testing ''' self.new_credential = Credential("twitter","kennedymbithi12") def test_init(self): ''' it creates new instances of classes using the init method ''' self.assertEqual(self.new_credential.account_name,"twitter") self.assertEqual(self.new_credential.passwordkey,"kennedymbithi12") def test_save_credential(self): ''' it saves the addded creadential ''' self.new_credential.save_credential() self.assertEqual(len(Credential.credential_list),1) def test_display_credentials(self): self.assertEqual(Credential.display_credentials(),Credential.credential_list) def test_delete_credential(self): ''' test_delete_credential it removes the inputed credential from the list ''' self.new_credential.save_credential() test_credential = Credential("test","0893kennedy") test_credential.save_credential() self.new_credential.delete_credential() self.assertEqual(len(Credential.credential_list),1)
def test_delete_credential(self): ''' :return: ''' Credential.credentials_list.append(self.cred_one) Credential.delete_credential(self.cred_one.name) self.assertEqual(len(Credential.credentials_list), 0) # list is now empty
def delete_credential(self): ''' :return: ''' name = self.userInput( "delete") # input("name of credential to be deleted? \n") Credential.delete_credential(name) print("Length of list: ", len(Credential.credentials_list)) pass
def test_delete_credential(self): """ test_delete_credential case tests if a credential can be deleted successfully from the credential list :return: """ self.new_credentials.save_credential() new_user = Credential("instagram", "alan", "insta67836") new_user.save_credential() new_user.delete_credential() self.assertEqual(len(Credential.credential_list), 1)
class test_credential(unittest.TestCase): def setUp(self): self.new_credential = Credential("twitter","twitter001","hamisi") def tearDown(self): Credential.credential_list = [] def test_init(self): self.assertEqual(self.new_credential.password,"twitter001") self.assertEqual(self.new_credential.account,"twitter") self.assertEqual(self.new_credential.username,"hamisi") def test_save_credentials(self): self.new_credential.save_credentials() self.assertEqual(len(Credential.credential_list),1) def test_save_multiple_credentials(self): self.new_credential.save_credentials() another_credential = Credential("facebook","facebook001","salim") another_credential.save_credentials() self.assertEqual(len(Credential.credential_list),2) def test_display_credentials(self): self.assertEqual(Credential.displayCredentials(),Credential.credential_list) def test_delete_credential(self): self.new_credential.save_credentials() another_credential = Credential("facebook","facebook001","salim") another_credential.save_credentials() self.new_credential.delete_credential() self.assertEqual(len(Credential.credential_list),1) def test_search_credential(self): self.new_credential.save_credentials() another_credential = Credential("facebook","facebook001","salim") another_credential.save_credentials() found_account = Credential.search_account("facebook") self.assertEqual(found_account.username,another_credential.username)
class TestUser(unittest.TestCase): ''' Test class that defines the test cases for user class behaviours ''' def setUp(self): ''' Setup method to run before each test cases ''' self.new_credential = Credential("random", "any") def test_init(self): ''' test_init checks if the object is initialised properly ''' self.assertEqual(self.new_credential.account_name, "random") self.assertEqual(self.new_credential.passkey, "any") def test_save_credential(self): ''' test_save_credential tests if a new credential has been added to credentials list of a user ''' self.new_credential.save_credential() self.assertEqual(len(Credential.credential_list), 1) def test_display_credentials(self): ''' test to display the credentials of a user ''' self.assertEqual(Credential.display_credentials(), Credential.credential_list) def test_delete_credential(self): ''' test_delete_credential to see if we can remove a credential from credentials list ''' self.new_credential.save_credential() test_credential = Credential("testing", "okay") test_credential.save_credential() self.new_credential.delete_credential() self.assertEqual(len(Credential.credential_list), 1)
class testCredential(unittest.TestCase): def setUp(self): self.new_credential = Credential("pinterest", "kara", "dian3@10") #create crede object def test_init(self): self.assertEqual(self.new_credential.accountname, "pinterest") self.assertEqual(self.new_credential.username, "kara") self.assertEqual(self.new_credential.password, "dian3@10") def test_save_credential(self): self.new_credential.save_credential() #saving the new credential self.assertEqual(len(Credential.credential_list), 1) def tearDown(self): Credential.credential_list = [] def test_save_multiple_credential(self): self.new_credential.save_credential() test_credential = Credential("pinterest", "clack", "m3@10") #new credential test_credential.save_credential() self.assertEqual(len(Credential.credential_list), 2) def test_delete_credential(self): self.new_credential.save_credential() test_credential = Credential("pinterest", "clack", "m3@10") #new credential test_credential.save_credential() self.new_credential.delete_credential() #deleting a credential object self.assertEqual(len(Credential.credential_list), 1) #test to check if we can find a credential by accountname and display info def test_find_credential_by_accountname(self): self.new_credential.save_credential() test_credential = Credential("pinterest", "clack", "m3@10") #new credential test_credential.save_credential() found_credential = Credential.find_by_accountname("pinterest")
def delete_credential(credentials): ''' Function that deletes credentials ''' return Credential.delete_credential(credentials)
def delete_credential(Credential): ''' Function for deleting credentials ''' Credential.delete_credential(Credential)
class TestUser(unittest.TestCase): """ Test class that defines test cases for the user class behaviours. Arguments: unittest.TestCase: TestCase class that helps in creating test cases. """ def setUp(self): ''' setup method to run before each test case ''' self.new_credential = Credential( 'instagram', 'stacy', '1234', '*****@*****.**') #create a user object def tearDown(self): ''' tearDown method that does clean up after each test case has run ''' Credential.credential_list = [] def test_init(self): ''' test_init test case to test if the object is initialized properly ''' self.assertEqual(self.new_credential.account, "instagram") self.assertEqual(self.new_credential.username, "stacy") self.assertEqual(self.new_credential.password, "1234") self.assertEqual(self.new_credential.email, "*****@*****.**") def test_save_credential(self): ''' save_acct test case is to test if the account is being saved ''' self.new_credential.save_credential() self.assertEqual(len(Credential.credential_list), 1) def test_display_credentials(self): '''display_credential test case that returns list of credentials ''' self.assertEqual(Credential.display_credentials(), Credential.credential_list) def test_find_credentials(self): ''' test to check if we can find a credential by username and display information ''' self.new_credential.save_credential() test_credential = Credential("Test", "username", "123456", "*****@*****.**") #new credential test_credential.save_credential() def test_credential_exist(self): ''' test to check if credential exist ''' self.new_credential.save_credential() test_credential = Credential("test", "stacy", "123678", "*****@*****.**") test_credential.save_credential() credential_exists = Credential.credential_exist("*****@*****.**") self.assertTrue(credential_exist) def test_delete_credential(self): ''' test to test if a credential has been removed ''' self.new_credential.save_credential() test_credential = Credential("Test", "username", "123456", "*****@*****.**") test_credential.save_credential() self.new_credential.delete_credential() self.assertEqual(len(Credential.credential_list), 1)
def delete_credentials(credential): ''' Deletes credential after user command ''' return Credential.delete_credential(credential)
class TestCredentials(unittest.TestCase): ''' Test class that defines test cases for the credentials class behaviors. ''' def setUp(self): ''' Function to create credentials before each test ''' self.new_credential = Credential("Jack","Facebook","*****@*****.**","Pass2020") def tearDown(self): ''' tearDown method that does clean up after each test case has run. ''' Credential.credentials_list = [] def test__init(self): ''' test to check if initialization is properly done ''' self.assertEqual(self.new_credential.user_name, 'Jack') self.assertEqual(self.new_credential.acc_name,'Facebook') self.assertEqual(self.new_credential.email,'*****@*****.**') self.assertEqual(self.new_credential.acc_password,'Pass2020') def test_save_credential(self): ''' test case to test if the object is saved into the contact list ''' self.new_credential.save_credential() self.assertEqual(len(Credential.credentials_list),1) def test_save_multiple_credential(self): ''' Test to check if the new credential info is saved into the credential list ''' self.new_credential.save_credential() twitter = Credential("Jane","Twitter","*****@*****.**","Pass2019") twitter.save_credential() self.assertEqual(len(Credential.credentials_list),2) def test_delete_credential(self): ''' test to check whether we can remove a credential from the list ''' self.new_credential.save_credential() twitter_credential = Credential("Jane","Twitter","*****@*****.**","Pass2019") twitter_credential.save_credential() self.new_credential.delete_credential() self.assertEqual(len(Credential.credentials_list),1) def test_display_all_credentials(self): ''' test to check if display is done correctly ''' self.new_credential.save_credential() twitter_credential = Credential("Jane","Twitter","*****@*****.**","Pass2019") twitter_credential.save_credential() gmail = Credential('mary','Gmail','*****@*****.**','pswd200') gmail.save_credential() self.assertEqual(len(Credential.display_all_credentials(gmail.user_name)),2) def test_find_by_acc_name(self): ''' test to find credentials using the account name ''' self.new_credential.save_credential() twitter_credential = Credential("Jane","Twitter","*****@*****.**","Pass2019") twitter_credential.save_credential() credential_exists = Credential.find_by_acc_name("Twitter") self.assertTrue(credential_exists) def test_copy_credential(self): ''' Test to check if copy credential method works ''' self.new_credential.save_credential() twitter_credential = Credential("Jane","Twitter","*****@*****.**","Pass2019") twitter_credential.save_credential() find_credential = None for credential in Credential.credentials_list: find_credential = Credential.find_by_acc_name(credential.acc_name) return pyperclip.copy(find_credential.acc_password) Credential.copy_credential(self.new_credential.acc_name) self.assertEqual("Pass2019",pyperclip.paste()) print(pyperclip.paste())
class TestUser(unittest.TestCase): ''' Test case class for credential class behaviours Args: unittest.TestCase: TestCase class that will help in creatin test cases ''' def setUp(self): ''' method to run before each case ''' self.new_credential = Credential('facebook','facebook101') def tearDown(self): ''' clean up method ''' Credential.credential_list = [] def test_init(self): ''' test to test if the object is initialized properly ''' self.assertEqual(self.new_credential.account_name,'facebook') self.assertEqual(self.new_credential.account_password,'facebook101') def test_save_credentail(self): ''' test_save_credential to save credentials ''' self.new_credential.save_credential() self.assertEqual(len(Credential.credential_list),1) def test_delete_credential(self): ''' test to see if we can remove credential from list ''' self.new_credential.save_credential() test_credential = Credential('Netflix','watch100') test_credential.save_credential() self.new_credential.delete_credential() self.assertEqual(len(Credential.credential_list),1) def test_find_credential_by_account_name(self): ''' test case to check if we an find credentials using the account name ''' self.new_credential.save_credential() test_credential = Credential('Netflix','watch100') test_credential.save_credential() found_credential = Credential.find_by_account_name('Netflix') self.assertEqual(found_credential.account_password,test_credential.account_password) def test_credential_exists(self): ''' test to check if we can return a Boolean ''' self.new_credential.save_credential() test_credential = Credential('Netflix','watch100') test_credential.save_credential() credential_exists = Credential.credential_exists('Netflix') self.assertTrue(credential_exists) def test_display_all_credential(self): ''' method that returns a list of users saved ''' self.assertEqual(Credential.display_credential(),Credential.credential_list)
class TestProfile(unittest.TestCase): """ Test class that defines test cases for the credential class behaviours. Args: unittest.TestCase: TestCase class that helps in creating test cases """ def setUp(self): """ Set up method to run before each test cases. """ self.new_credential = Credential( "JohnD2020#", "Gmail", "gmail20*") # create credential object def tearDown(self): """ tearDown method that does clean up after each test case has run. """ Credential.credential_list = [] def test_init(self): """ test_init test case to test if the object is initialized properly """ self.assertEqual(self.new_credential.user_password, "JohnD2020#") self.assertEqual(self.new_credential.credential_name, "Gmail") self.assertEqual(self.new_credential.credential_password, "gmail20*") def test_save_credential(self): """ Test case to test if the credential object is saved into the credential_list """ # Save the new credential self.new_credential.save_credential() self.assertEqual(len(Credential.credential_list), 1) def test_save_multiple_credential(self): """ test_save_multiple_credentials to check if we can save multiple credential objects to our credential_list """ self.new_credential.save_credential() test_credential = Credential("JohnD2020#", "Gmail", "gmail20*") test_credential.save_credential() self.assertEqual(len(Credential.credential_list), 2) def test_delete_credential(self): """ test_delete_credential to test if we can remove an credential from our credential_list """ self.new_credential.save_credential() test_credential = Credential("JohnD2020#", "Twitter", "Twitter20*") test_credential.save_credential() self.new_credential.delete_credential( ) # Deleting an credential object self.assertEqual(len(Credential.credential_list), 1) def test_generate_password(self): """ Test case to test if a user can log into their """ generated_password = self.new_credential.generate_password() self.assertEqual(len(generated_password), 8) def test_display_credential(self): """ test case to test if user can access a list of all the credentials saved """ # save new credentials self.new_credential.save_credential() test_credential = Credential("JohnD2020#", "Instagram", "Instajd20*") test_credential.save_credential() test_credential = Credential("JohnD2020#", "Linkedin", "Linkjd20*") test_credential.save_credential() self.assertEqual(len(Credential.display_credential("JohnD2020#")), 3) def test_credential_exist(self): """ Test to check if we can return a boolean if we can't find the credential """ # Save the new credential self.new_credential.save_credential() test_credential = Credential("JohnD2020#", "Gmail", "gmail20*") test_credential.save_credential() # use contact exist method credential_exist = Credential.credential_exist("Gmail") self.assertTrue(credential_exist)
class TestCredential(unittest.TestCase): def setUp(self): ''' Set up method to run before each test cases. ''' self.new_credential = Credential('Susan', 'Kariuki', 'Instagram', 'SKaris', 'SueKaris123') def test_init(self): ''' test_init test case to test if the object is initialized properly ''' self.assertEqual(self.new_credential.first_name, "Susan") self.assertEqual(self.new_credential.second_name, "Kariuki") self.assertEqual(self.new_credential.account, "Instagram") self.assertEqual(self.new_credential.username, "SKaris") self.assertEqual(self.new_credential.password, "SueKaris123") def test_save_credential(self): ''' test_save_credential test case to test if the user object is saved into the credential list ''' self.new_credential.save_credential() # saving the new credential self.assertEqual(len(Credential.credential_list), 1) def tearDown(self): ''' tearDown method that does clean up after each test case has run. ''' Credential.credential_list = [] def test_save_multiple_credential(self): ''' test_save_multiple_credential to check if we can save multiple credential objects to our credential_list ''' self.new_credential.save_credential() test_credential = Credential('Susan', 'Kariuki', 'Instagram', 'SKaris', 'SueKaris123') # new credential test_credential.save_credential() # saving a credential object self.assertEqual(len(Credential.credential_list), 2) def test_delete_credential(self): ''' test_delete_credential to test if we can remove a credential from our credential list ''' self.new_credential.save_credential() test_credential = Credential('Susan', 'Kariuki', 'Instagram', 'SKaris', 'SueKaris123') # new credential test_credential.save_credential() self.new_credential.delete_credential( ) # Deleting a credential object self.assertEqual(len(Credential.credential_list), 1) def test_find_credential_by_username(self): ''' test to check if we can find a credential by username and display information ''' self.new_credential.save_credential() test_credential = Credential('Susan', 'Kariuki', 'Instagram', 'SKaris', 'SueKaris123') # new credential test_credential.save_credential() found_credential = Credential.find_by_username('SKaris') self.assertEqual(found_credential.username, test_credential.username) def test_credential_exists(self): ''' test to check if we can return a Boolean if we cannot find the credential. ''' self.new_credential.save_credential() test_credential = Credential('Susan', 'Kariuki', 'Instagram', 'SKaris', 'SueKaris123') # new credential test_credential.save_credential() credential_exists = Credential.credential_exist('SKaris') self.assertTrue(credential_exists) def test_display_all_credential(self): ''' method that returns a list of all credential saved ''' self.assertEqual(Credential.display_credentials(), Credential.credential_list)
class TestCredential(unittest.TestCase): """ Test class that defines test cases for the credential class behaviours. Arguments: unittest.TestCase: TestCase class that helps in creating test cases """ def setUp(self): ''' Set up method to run before each test cases. ''' self.new_credential = Credential("Carl", "Twitter", "carl", "xyz") def test_init(self): ''' test_init test case to test if the object is initialized properly ''' self.assertEqual(self.new_credential.first_name, "Carl") self.assertEqual(self.new_credential.website_name, "Twitter") self.assertEqual(self.new_credential.login_name, "carl") self.assertEqual(self.new_credential.password, "xyz") def test_save_credential(self): ''' test_save_credential checks if the user instance is being saved to the user list ''' self.new_credential.save_credential() self.assertEqual(len(Credential.credentials_list), 1) def tearDown(self): ''' tearDown method that does clean up after each test case has run. ''' Credential.credentials_list = [] def test_save_multiple_credentials(self): ''' test_save_multiple_credentials tests if we can save more than one users on our user list ''' self.new_credential.save_credential() test_credential = Credential("Carl", "Twitter", "carl", "xyz") test_credential.save_credential() self.assertEqual(len(Credential.credentials_list), 2) def test_display_all_credentials(self): ''' method that returns a list of all credentials saved ''' self.assertEqual(Credential.display_credential(), Credential.credentials_list) # def test_find_credential(self): # ''' # test to check if we can find a credential by webisite name # ''' # for credential in self.credentials_list: # if credential.site_name == site_name: # return credential # # self.new_credential.save_credential() # # test_credential = Credential("Max","Facebook","max","abc") # # test_credential.save_credential() # # found_credential = Credential.find_credential("Facebook") # # self.assertEqual(found_credental.website_name,test_credential.website_name) def test_delete_credential(self): ''' To test if we can remove a credential from our credentials list ''' self.new_credential.save_credential() test_credential = Credential("Carl", "Twitter", "carl", "xyz") test_credential.save_credential() self.new_credential.delete_credential() self.assertEqual(len(Credential.credentials_list), 1) def test_display_all_credentials(self): ''' method that returns a list of all credentials saved ''' self.assertEqual(Credential.display_credentials(self), Credential.credentials_list) def test_find_by_website_name(self): ''' test to check if we can find a credential by using a website name ''' self.new_credential.save_credential() test_credential = Credential("Carl", "Twitter", "carl", "xyz") test_credential.save_credential() found_credential = Credential.find_by_website_name("Twitter") self.assertEqual(found_credential.website_name, test_credential.website_name)
class TestCredential(unittest.TestCase): def setUp(self): """setUp method run before most test case/s""" # Credential.credential_list = [] self.new_credential = Credential("Button", "up", "Dan") def test_init(self): self.assertEqual(self.new_credential.first_name, "Button") self.assertEqual(self.new_credential.last_name, "up") self.assertEqual(self.new_credential.password, "Dan") def test_save_credential(self): """test_save_credential ensures that save credentials works properly""" self.new_credential.save_credential() self.assertEqual(len(Credential.credential_list), 1) def tearDown(self): """tearDown method allows it to be the case that clean up exercises on apps can be done without too much friction """ Credential.credential_list = [] def test_save_multiple_credential(self): """This test_save_multiple_credential allows devs to check whether saving multiple credentials is a smooth run not to inhibit users who may have such a need """ self.new_credential.save_credential() test_credential = Credential("Humans", "are", "Mortal") test_credential.save_credential() self.assertEqual(len(Credential.credential_list), 2) def test_delete_credential(self): """This method, a test case allows to check for deletions which the user might inject""" self.new_credential.save_credential() test_credential = Credential("Humans", "are", "Mortal") test_credential.save_credential() self.new_credential.delete_credential() self.assertEqual(len(Credential.credential_list), 1) def test_find_credential_by_first_name(self): """This test_case allows the possibility of locating a credential while only using a name""" self.new_credential.save_credential() test_credential = Credential("Mighty", "Diamonds", "Marcus") test_credential.save_credential() found_credential = Credential.find_by_first_name("Mighty") self.assertEqual(found_credential.password, test_credential.password) def test_credential_exists(self): """this is to check whether there are existing credentials in a users account""" self.new_credential.save_credential() test_credential = Credential("Mighty", "Diamonds", "Marcus" ) test_credential.save_credential() credential_exists = Credential.credential_exist("Marcus") self.assertTrue(credential_exists) def test_display_all_credentials(self): """This test_case feature is responsible for displaying available account credentials""" self.assertEqual(Credential.display_credentials(), Credential.credential_list)
class TestCredential(unittest.TestCase): '''test class for credential class Args: TestCase class that helps in creating test ''' def setUp(self): ''' set up function to run before each test case ''' self.new_credential = Credential("Instagram", "mediay37", "5555") def tearDown(self): ''' tearDown method that does clean up after each test has run ''' Credential.credential_list = [] #--------------------first test----------------------- def test_init(self): ''' test to initialize the object ''' self.assertEqual(self.new_credential.account_type, "Instagram") self.assertEqual(self.new_credential.user_name, "mediay37") self.assertEqual(self.new_credential.password, "5555") #-------------------second test---------------------- def test_save_credential(self): ''' test save credential test case to test if the contact object is saved into the credential_list ''' self.new_credential.save_credential() self.assertEqual(len(Credential.credential_list), 1) # ---------------third test--------------------------- def test_save_multiple_credentials(self): ''' test_save_multiple_credentials to check if it can save multiple credentials objects to our credential_list ''' self.new_credential.save_credential() test_credential = Credential("Facebook", "eussy", "457823") test_credential.save_credential() self.assertEqual(len(Credential.credential_list), 2) # ---------------------------four test------------------ def test_display_credentials(self): ''' method that returns a list of all credentials save_credential ''' self.assertEqual(Credential.display_credentials(), Credential.credential_list) # -----------------------------five test----------- def test_delete_credential(self): ''' test_delete_credential to test if we can remove a credential from our credential list ''' self.new_credential.save_credential() test_credential = Credential("Facebook", "eussy", "457823") # new credential test_credential.save_credential() self.new_credential.delete_credential() # Deleting a credential object self.assertEqual(len(Credential.credential_list), 1)
class TestCredential(unittest.TestCase): def setUp(self): ''' setup up method to run before each test cases. ''' self.new_credential = Credential( "pinterest", "olamijin", "09037465697") # create contact oblect def test_init(self): ''' test_init test case to test if the object is initialized properly ''' self.assertEqual(self.new_credential.account, "pinterest") self.assertEqual(self.new_credential.user_name, "olamijin") self.assertEqual(self.new_credential.password, "09037465697") def test_save_credential(self): ''' test_save_credential test case to test if the credential object is saved into the credential_list array ''' self.new_credential.save_credential() # saving the new contact self.assertEqual(len(Credential.credential_list), 1) def tearDown(self): ''' tearDown method that does clean up after each test case has run. ''' Credential.credential_list = [] def test_delete_credential(self): ''' test to see if a credential can be deleted ''' self.new_credential.save_credential() test_credential = Credential("pinterest", "olamijin", "09037465697") # new credentials test_credential.save_credential() self.new_credential.delete_credential() # delete credential object self.assertEqual(len(Credential.credential_list), 1) def test_find_password_by_username(self): ''' test to see if we can find a password using the username ''' self.new_credential.save_credential() test_credential = Credential("pinterest", "olamijin", "09037465697") test_credential.save_credential() found_credential = Credential.find_by_username("olamijin") self.assertEqual(found_credential.password, test_credential.password) def test_credential_exists(self): ''' test to see if we can return a boolean if a credential is not found ''' self.new_credential.save_credential() test_credential = Credential("pinterest", "olamijin", "09037465697") test_credential.save_credential() credential_exists = Credential.credential_exist("olamijin") self.assertTrue(credential_exists) def test_display_all_credentials(self): ''' returns a list of all saved credentials ''' self.assertEqual(Credential.display_credentials(), Credential.credential_list) def test_copy_username(self): ''' test to confirm that a username can be copied from a found credential ''' self.new_credential.save_credential() Credential.copy_user_name("olamijin") self.assertEqual(self.new_credential.user_name, pyperclip.paste())
class TestUsers(unittest.TestCase): ''' Test class that defines test cases for the users Arg: unittest.TestCase: TestCase class that helps in creating test cases ''' def setUp(self): ''' This method stands for what is to to be loaded when the test class is run ''' self.new_user = User("admin", "admin") self.new_credentials = Credential("admin", "twitter", "admin", "*****@*****.**", "123456") def tearDown(self): ''' tearDown method that does clean up after each test case has run. ''' Credential.Credentials = [] def test_users_init(self): ''' This class is to test whether a new instance was created ''' # self.new_user = User("admin","admin") self.assertEqual(self.new_user.user_name, "admin") self.assertEqual(self.new_user.user_password, "admin") def test_save_user(self): ''' This is a test to see whether the user can save their user name ''' self.new_user.save_user() self.assertEqual(len(User.user_details), 1) ########################################################################################### #CREDENTIALS TESTS BEGIN HERE ########################################################################################### def test_credentials_init(self): ''' This test tests if the class credentials instanciates the data ''' self.assertEqual(self.new_credentials.user_name, "admin") self.assertEqual(self.new_credentials.site, "twitter") self.assertEqual(self.new_credentials.account_name, "admin") self.assertEqual(self.new_credentials.account_email, "*****@*****.**") self.assertEqual(self.new_credentials.account_password, "123456") def test_save_credentials(self): ''' This test is to test if we can save the credentials ''' self.new_credentials.save_credentials() self.assertEqual(len(Credential.Credentials), 1) # def test_password_randomiser(self): # ''' # test for random password generator # ''' # #self.password_characters = string.ascii_letters + string.digits + string.punctuation # self.new_credentials2 = Credential("admin2","twitter2","admin2","*****@*****.**",password_generator()) # self.new_credentials2.save_credentials() # self.assertEqual(new_credentials2.account_password,0) def test_delete_credential(self): ''' test for deleting of credentials ''' self.new_credentials.save_credentials() self.new_credentials2 = Credential("admin2", "twitter2", "admin2", "*****@*****.**", "1234567") self.new_credentials2.save_credentials() self.new_credentials.delete_credential() self.assertEqual(len(Credential.Credentials), 1) def test_display_all_credentials(self): ''' method that returns a list of all credentials saved ''' self.assertEqual(Credential.display_credentials(), Credential.Credentials)
class TestCredential(unittest.TestCase): ''' Test class that defines test cases for the credentials class behaviours. ''' def setUp(self): ''' Set up method to run before each test cases. ''' self.new_credentials = Credential("Felix", "Ouma", "0712345678", "*****@*****.**", "SecretKey") def test_init(self): ''' test_init test case to test if the object is initialized properly ''' self.assertEqual(self.new_credentials.first_name, "Felix") self.assertEqual(self.new_credentials.last_name, "Ouma") self.assertEqual(self.new_credentials.phone_number, "0712345678") self.assertEqual(self.new_credentials.email, "*****@*****.**") self.assertEqual(self.new_credentials.password, "SecretKey") def test_save_credentials(self): ''' test_save_credentials test case to test if the credentials object is saved into the credential list ''' self.new_credentials.save_credentials() self.assertEqual(len(Credential.credential_list), 1) def tearDown(self): ''' tearDown method that does clean up after each test case has run. ''' Credential.credential_list = [] def test_save_multiple_credentials(self): ''' test_save_multiple_credentials to check if we can save multiple credentials objects to our credential_list ''' self.new_credentials.save_credentials() test_credentials = Credential("Test", "user", "0712345678", "*****@*****.**", "SecretKey") test_credentials.save_credentials() self.assertEqual(len(Credential.credential_list), 2) def test_delete_credential(self): ''' test_delete_credential to test if we can remove a credential from our credential list ''' self.new_credentials.save_credentials() test_credentials = Credential("Test", "user", "0712345678", "*****@*****.**", "SecretKey") test_credentials.save_credentials() self.new_credentials.delete_credential() self.assertEqual(len(Credential.credential_list), 1) def test_find_credential_by_password(self): ''' test to check if we can find a credential by password and display credentials ''' self.new_credentials.save_credentials() test_credentials = Credential("Test", "user", "0711223344", "*****@*****.**", "SecretKey") test_credentials.save_credentials() found_credentials = Credential.find_by_password("SecretKey") self.assertEqual(found_credentials.email, test_credentials.email) def test_credentials_exists(self): ''' test to check if we can return a Boolean if we cannot find the credential. ''' self.new_credentials.save_credentials() test_credentials = Credential("Test", "user", "0711223344", "*****@*****.**", "SecretKey") test_credentials.save_credentials() credentials_exists = Credential.credentials_exist("SecretKey") self.assertTrue(credentials_exists) def test_display_all_credentials(self): ''' method that returns a list of all credentials saved ''' self.assertEqual(Credential.display_credentials(), Credential.credential_list)
def delete_credential(credential): ''' function to delete a credential ''' Credential.delete_credential()
class TestCredential(unittest.TestCase): ''' Test class that defines test cases for the credentials class behaviours. Args: unittest.TestCase: TestCase class that helps in creating tets cases ''' def setUp(self): ''' Method to run before each test cases. ''' self.new_credential = Credential("Instagram","1122") def tearDown(self): ''' Method that cleans up after each test case has run. ''' Credential.credentials_list = [] def test_init(self): """ Method that tests whether the new_credentials have been instantiated correctly """ self.assertEqual(self.new_credential.account_name, "Instagram") self.assertEqual(self.new_credential.account_password, "1122") def test_save_credentials(self): """ Method that tests whether the new created credential has been saved """ self.new_credential.save_credentials() self.assertEqual(len(Credential.credentials_list), 1) def test_save_multiple_credentials(self): """ Method that saves multiple credentials to credentials_list """ self.new_credential.save_credentials() new_test_credential = Credential("Uber", "1234") new_test_credential.save_credentials() self.assertEqual(len(Credential.credentials_list), 2) def test_find_credential_by_name(self): """ Test to check if we can find credential by name and return credential. """ self.new_credential.save_credentials() new_test_credential = Credential("Instagram", "1122") new_test_credential.save_credentials() found_credential = Credential.find_by_name("Instagram") self.assertEqual(found_credential.account_name, new_test_credential.account_name) def test_display_all_credentials(self): """ TestCase to test whether all contacts can be displayed """ self.assertEqual(Credential.display_credentials(), Credential.credentials_list) def test_delete_credential(self): ''' This to test if we can remove an account from our credential list ''' self.new_credential.save_credentials() test_credential = Credential("Test","cred123") test_credential.save_credentials() self.new_credential.delete_credential() self.assertEqual(len(Credential.credentials_list),1) def test_credential_exists(self): ''' This test is to check if credentials exists when searched with the user_account ''' self.new_credential.save_credential() test_credential = Credential("Twitter","test12") test_credential.save_credential() credential_exists = Credential.credential_exists("Twitter", "test12")) self.assertTrue(credential_exists)
class TestCredentials(unittest.TestCase): ''' Test class that defines test cases for the credential class behaviours. Args: unittest.TestCase: TestCase class that helps in creating test cases ''' def setUp(self): ''' Set up method to run before each test cases. ''' self.new_credential = Credential("IG", "Dema", 'd30') def test_init(self): ''' test_init test case to test if the object is initialized properly ''' self.assertEqual(self.new_credential.site_name, "IG") self.assertEqual(self.new_credential.username, "Dema") self.assertEqual(self.new_credential.password, "d30") def test_save_credential(self): ''' test_save_credential test case to test if the credential object is saved into the contact list ''' self.new_credential.save_credential() self.assertEqual(len(Credential.credential_list), 1) # setup and class creation up here def tearDown(self): ''' tearDown method that does clean up after each test case has run. ''' Credential.credential_list = [] def test_save_multiple_credentials(self): ''' test_save_multiple_credential to check if we can save multiple contact objects to our credential_list ''' self.new_credential.save_credential() test_credential = Credential('instagram', "user", "12dgj") test_credential.save_credential() self.assertEqual(len(Credential.credential_list), 2) def test_delete_credentials(self): ''' test_delete_contact to test if we can remove a credential from our credential list ''' self.new_credential.save_credential() test_save_credential = Credential("instagram", "user", "tes333") test_save_credential.save_credential() self.new_credential.delete_credential() self.assertEqual(len(Credential.credential_list), 1) def test_display_credentials(self): ''' Test to check if the display_credentials method, displays the correct credentials. ''' self.new_credential.save_credential() new_credential = Credential('Twitter', 'user', '1200') new_credential.save_credential() new_credential = Credential('Google', 'user2', 'we300') new_credential.save_credential() self.assertEqual(len(Credential.display_credentials()), 3) def test_find_by_site(self): ''' Test to check if the find_by_site method returns the correct credential ''' self.new_credential.save_credential() new_credential = Credential('Twitter', 'user', '1200') new_credential.save_credential() credential_exists = Credential.find_by_site('Twitter') self.assertEqual(credential_exists, new_credential)
class TestUser(unittest.TestCase): """ test class that defines test cases for the user class behaviour. """ #First test def setUp(self): """ setUp method to run before each test cases. """ self.new_credential = Credential("legionpunisher", "shadow521", "Facebook") def test_init(self): """ test_init test case to test if the object is initialized properly """ self.assertEqual(self.new_credential.username, "legionpunisher") self.assertEqual(self.new_credential.password, "shadow521") self.assertEqual(self.new_credential.account, "Facebook") #Second Test def test_save_credential(self): """ test_save_credential test case to test if the credential object is saved into the credential list """ self.new_credential.save_credential() self.assertEqual(len(Credential.credential_list), 1) #Third Test def tearDown(self): ''' tearDown method that does clean up after each test case has run. ''' Credential.credential_list = [] def test_save_multiple_credential(self): ''' test_save_multiple_credential to check if we can save multiple credential objects to our credential_list ''' self.new_credential.save_credential() test_credential = Credential("Test", "user", "duolingo") # new credential test_credential.save_credential() self.assertEqual(len(Credential.credential_list), 2) #Fourth Test def test_delete_credential(self): ''' test_delete_credential to test if we can remove a credential from our credential list ''' self.new_credential.save_credential() test_credential = Credential("Test", "user", "Github") test_credential.save_credential() self.new_credential.delete_credential() self.assertEqual(len(Credential.credential_list), 1) #Fifth Test def test_find_credential_by_account(self): ''' test to check if we can find a credential by account and display information ''' self.new_credential.save_credential() test_credential = Credential("Test", "falcon456", "duolingo") test_credential.save_credential() found_credential = Credential.find_by_account("duolingo") self.assertEqual(found_credential.username, test_credential.username) def test_credential_exists(self): ''' test to check if we can return a Boolean if we cannot find the credentials. ''' self.new_credential.save_credential() test_credential = Credential("legionpunisher", "Test", "duolingo") test_credential.save_credential() credential_exists = Credential.credential_exist("duolingo") self.assertTrue(credential_exists) def test_display_all_credentials(self): ''' method that returns a list of all credentials saved ''' self.assertEqual(Credential.display_credentials(), Credential.credential_list)