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)
