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)
