def test_authenticateWithUsernameAndPassword_bad_user(self): """ `False` is returned when a bad user is provided. """ result, token = system_users.authenticateWithUsernameAndPassword( username=mk.string(), password=mk.string()) self.assertFalse(result) self.assertIsNone(token)
def test_assertWorkingFolderIsClean_with_file_and_folder(self): """ An error is raised if current working folder contains a temporary folder and file, and folder and folder is cleaned. """ file_name = mk.string() folder_name = mk.string() open(mk.fs.getEncodedPath(file_name), 'a').close() os.mkdir(mk.fs.getEncodedPath(folder_name)) self.check_assertWorkingFolderIsClean([file_name, folder_name])
def test_string(self): """ It will return different values at each call. Value is Unicode. """ self.assertNotEqual( mk.string(), mk.string(), ) self.assertIsInstance(text_type, mk.string())
def test_authenticateWithUsernameAndPassword_bad_user(self): """ Check authentication for bad password. This is slow since the OS adds a timeout or checks for various PAM modules. """ result, token = system_users.authenticateWithUsernameAndPassword( username=mk.string(), password=mk.string()) self.assertFalse(result) self.assertIsNone(token)
def test_KeyCertException_str(self): """ The message is the string serialization. """ message = mk.string() error = KeyCertException(message) self.assertEqual(message.encode('utf-8'), str(error))
def test_Mock(self): """ It creates a generic mock object. """ value = mk.string() mock = self.Mock(return_value=value) self.assertEqual(value, mock())
def test_assertWorkingFolderIsClean_with_file(self): """ An error is raised if current working folder contains a temporary file and file is cleaned. """ name = mk.string() open(mk.fs.getEncodedPath(name), 'a').close() self.check_assertWorkingFolderIsClean([name])
def test_authenticateWithUsernameAndPassword_bad_password(self): """ `False` is returned when a bad password is provided. """ result, token = system_users.authenticateWithUsernameAndPassword( username=TEST_ACCOUNT_USERNAME_DOMAIN, password=mk.string()) self.assertFalse(result) self.assertIsNone(token)
def test_KeyCertException(self): """ It provides a message. """ message = mk.string() error = KeyCertException(message) self.assertEqual(message, error.message)
def test_parseUPN_no_domain(self): """ Return the exact username and domain `None` when username UPN is not a domain. """ name = mk.string() (domain, username) = system_users._parseUPN(name) self.assertIsNone(domain) self.assertEqual(name, username)
def test_assertWorkingFolderIsClean_with_folder(self): """ An error is raised if current working folder contains a temporary folder and folder is cleaned. """ # Our compat filesystem API does not support creating files in # current working directory so we use direct API call to OS. name = mk.string() os.mkdir(mk.fs.getEncodedPath(name)) self.check_assertWorkingFolderIsClean([name])
def test_getHomeFolder_nt_good(self): """ If a valid token is provided the home folder path can be retrieved for it's corresponding account, as long as the process has the required capabilities. """ test_user = TestUser( name=mk.string(), password=mk.string(), create_local_profile=True, ) os_administration.addUser(test_user) home_folder = system_users.getHomeFolder( username=test_user.name, token=test_user.token) self.assertContains( test_user.name.lower(), home_folder.lower()) self.assertIsInstance(text_type, home_folder) self.addCleanup(os_administration.deleteUser, test_user)
def test_makeLink_good(self): """ Can create link under impersonated account. """ target_segments = self.filesystem.home_segments target_segments.append(mk.string()) file_object = self.filesystem.openFileForWriting(target_segments) file_object.close() self.addCleanup(self.filesystem.deleteFile, target_segments) link_segments = self.filesystem.home_segments link_segments.append(mk.string()) self.filesystem.makeLink( target_segments=target_segments, link_segments=link_segments, ) self.addCleanup(self.filesystem.deleteFile, link_segments) self.assertTrue(self.filesystem.isLink(link_segments)) self.assertTrue(self.filesystem.exists(link_segments))
def test_authenticateWithUsernameAndPassword_bad_password(self): """ authenticateWithUsernameAndPassword will return False if credentials are not valid. """ result, token = system_users.authenticateWithUsernameAndPassword( username=TEST_ACCOUNT_USERNAME, password=mk.string(), ) self.assertFalse(result) self.assertIsNone(token)
def test_makeLink_bad_target(self): """ Can create broken links under impersonated account. """ segments = self.filesystem.home_segments segments.append(mk.string()) self.filesystem.makeLink( target_segments=['z', 'no-such', 'target'], link_segments=segments, ) self.addCleanup(self.filesystem.deleteFile, segments) self.assertTrue(self.filesystem.isLink(segments)) self.assertFalse(self.filesystem.exists(segments))
def test_makeLink_missing_privilege(self): """ It will raise an error if user does not have sufficient privileges for creating symbolic links. """ link_segments = self.filesystem.home_segments link_segments.append(mk.string()) with self.assertRaises(OSError) as context: self.filesystem.makeLink( target_segments=['z', 'no-such', 'target'], link_segments=link_segments, ) self.assertContains( u'Process does not have', context.exception.strerror)
def test_patch(self): """ It can be used for patching classes. """ value = mk.string() with self.patch( 'chevah.compat.tests.normal.testing.test_testcase.Dummy.method', return_value=value, ): instance = Dummy() self.assertEqual(value, instance.method()) # After exiting the context, the value is restored. instance = Dummy() self.assertEqual(Dummy._value, instance.method())
def test_patchObject(self): """ It can be used for patching an instance of an object. """ value = mk.string() one_instance = Dummy() with self.patchObject( one_instance, 'method', return_value=value): self.assertEqual(value, one_instance.method()) # All other instances are not affected. new_instance = Dummy() self.assertEqual(Dummy._value, new_instance.method()) # After exiting the context, the value is restored. self.assertEqual(Dummy._value, one_instance.method())
def test_parseUPN_domain(self): """ Return the domain and username when username UPN contains a domain. """ # This test is only running on the domain controller slave. if '-dc-' not in self.getHostname(): raise self.skipTest() test_domain = TEST_DOMAIN test_pdc = TEST_PDC name = mk.string() upn = u'%s@%s' % (name, test_domain) (pdc, username) = system_users._parseUPN(upn) self.assertEqual(pdc, test_pdc) self.assertEqual(name, username)
def test_getHomeFolder_nt_no_existing_profile(self): """ On Windows, if user has no local home folder it will be created automatically when getting the home folder path. This test creates a temporary account and in the end it deletes the account and it's home folder. """ test_user = TestUser( name=u'no-home', password=mk.string(), create_local_profile=False, ) # Unfortunately there is no API to get default base home path for # users, we need to rely on an existing pattern. home_base = os.path.dirname(os.getenv('USERPROFILE')) expected_home_path = os.path.join(home_base, test_user.name) expected_home_segments = mk.fs.getSegmentsFromRealPath( expected_home_path) try: os_administration.addUser(test_user) # Home folder path is not created on successful login. token = test_user.token self.assertFalse(mk.fs.isFolder(expected_home_segments)) self.home_folder = system_users.getHomeFolder( username=test_user.name, token=token) self.assertContains( test_user.name.lower(), self.home_folder.lower()) self.assertIsInstance(text_type, self.home_folder) self.assertTrue(mk.fs.isFolder(expected_home_segments)) finally: os_administration.deleteUser(test_user) os_administration.deleteHomeFolder(test_user)