Move dangling functions to common.UserOps

Since they have much in common, I am moving them under UserOps
static class.  This allows for better flexibility and readability.

8 files changed, 138 insertions, 102 deletions

diff --git a/src/account/test/TestAccount.py b/src/account/test/TestAccount.py
index 31c3a96..05d0071 100644
--- a/src/account/test/TestAccount.py
+++ b/src/account/test/TestAccount.py
@@ -18,12 +18,12 @@
 # Authors: Roman Rakus <rrakus@redhat.com>
 #
 
-from common import AccountBase
+import common
 from methods import *
 from lmi.shell import LMIInstance
 import subprocess
 
-class TestAccount(AccountBase):
+class TestAccount(common.AccountBase):
     """
     Class for testing LMI_Account class
     """
@@ -31,7 +31,7 @@ class TestAccount(AccountBase):
     CLASS_NAME = "LMI_Account"
 
     def tearDown(self):
-        clean_account(self.user_name)
+        common.UserOps.clean_account(self.user_name)
 
     def test_account_properties(self):
         """
@@ -53,33 +53,33 @@ class TestAccount(AccountBase):
         Account: Test to create user account
         """
         # make sure the account will not exist
-        clean_account(self.user_name)
+        common.UserOps.clean_account(self.user_name)
         lams = self.ns.LMI_AccountManagementService.first_instance()
         self.assertIsInstance(lams, LMIInstance)
         (retval, rparam, errorstr) = lams.CreateAccount({'Name': self.user_name,
                                                          'System': self.system_iname})
         self.assertEqual(retval, 0)
         # The user now should be created, check it
-        self.assertTrue(user_exists(self.user_name))
+        self.assertTrue(common.UserOps.is_user(self.user_name))
 
     def test_delete_account(self):
         """
         Account: Test to delete account
         """
         # make sure the account will exist
-        create_account(self.user_name)
+        common.UserOps.create_account(self.user_name)
         inst = self.cim_class.first_instance({"Name": self.user_name})
         self.assertIsInstance(inst, LMIInstance)
         r = inst.delete()
         self.assertTrue(r)
         # check if it was really deleted
-        self.assertFalse(user_exists(self.user_name))
+        self.assertFalse(common.UserOps.is_user(self.user_name))
 
     def test_modify_account(self):
         """
         Account: Test several modifications
         """
-        create_account(self.user_name)
+        common.UserOps.create_account(self.user_name)
         inst = self.cim_class.first_instance({"Name": self.user_name})
         self.assertIsInstance(inst, LMIInstance)
         # gecos
diff --git a/src/account/test/TestAccountRaceConditions.py b/src/account/test/TestAccountRaceConditions.py
index cd13d61..3523b96 100644
--- a/src/account/test/TestAccountRaceConditions.py
+++ b/src/account/test/TestAccountRaceConditions.py
@@ -17,9 +17,9 @@
 #
 # Authors: Alois Mahdal <amahdal@redhat.com>
 
+import common
 import lmi.test.util
 import methods
-from common import AccountBase, PasswdFile
 from pywbem import CIMError
 
 import threading
@@ -119,7 +119,7 @@ class DeletionAttempt(AccountActionAttempt):
 ## Actual test
 ## ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' ##
 
-class TestAccountRaceConditions(AccountBase):
+class TestAccountRaceConditions(common.AccountBase):
 
     def setUp(self):
         self.user_count = 20        # = thread count
@@ -142,7 +142,7 @@ class TestAccountRaceConditions(AccountBase):
         """
         Assert /etc/passwd is not corrupt
         """
-        pf = PasswdFile()
+        pf = common.PasswdFile()
         errors = pf.get_errors()
         msg = ("/etc/passwd corrupt: %s\n\nFull text follows:\n%s\n"
                % (errors, pf.fulltext))
@@ -154,7 +154,7 @@ class TestAccountRaceConditions(AccountBase):
         """
         if count is None:
             count = self.user_count
-        pf = PasswdFile({'username_prefix': self.prefix})
+        pf = common.PasswdFile({'username_prefix': self.prefix})
         oc = count
         rc = len(pf.users)
         self.assertEqual(rc, oc,
@@ -166,7 +166,7 @@ class TestAccountRaceConditions(AccountBase):
         """
         if nameset is None:
             nameset = self.names
-        pf = PasswdFile({'username_prefix': self.prefix})
+        pf = common.PasswdFile({'username_prefix': self.prefix})
         on = sorted(nameset)
         rn = sorted(pf.get_names())
         self.assertEqual(rn, on,
@@ -188,7 +188,7 @@ class TestAccountRaceConditions(AccountBase):
         """
         Account: Test modifications from many threads.
         """
-        [methods.create_account(n) for n in self.names]
+        [common.UserOps.create_account(n) for n in self.names]
         perform_attempts(ModificationAttempt, self.names, self.args)
         self.assertUserCount()
         self.assertPasswdNotCorrupt()
@@ -197,7 +197,7 @@ class TestAccountRaceConditions(AccountBase):
         """
         Account: Test deletions from many threads.
         """
-        [methods.create_account(n) for n in self.names]
+        [common.UserOps.create_account(n) for n in self.names]
         perform_attempts(DeletionAttempt, self.names, self.args)
         self.assertUserCount(0)
         self.assertPasswdNotCorrupt()
diff --git a/src/account/test/TestGroup.py b/src/account/test/TestGroup.py
index 4a7fc6d..50450c0 100644
--- a/src/account/test/TestGroup.py
+++ b/src/account/test/TestGroup.py
@@ -18,11 +18,11 @@
 # Authors: Roman Rakus <rrakus@redhat.com>
 #
 
-from common import AccountBase
+import common
 from methods import *
 from lmi.shell import LMIInstance
 
-class TestGroup(AccountBase):
+class TestGroup(common.AccountBase):
     """
     Class for testing LMI_Group class
     """
@@ -30,7 +30,7 @@ class TestGroup(AccountBase):
     CLASS_NAME = "LMI_Group"
 
     def tearDown(self):
-        clean_group(self.group_name)
+        common.UserOps.clean_group(self.group_name)
 
     def test_group_properties(self):
         """
@@ -51,7 +51,7 @@ class TestGroup(AccountBase):
         Account: Test to create group
         """
         # make sure the group will not exist
-        clean_group(self.group_name)
+        common.UserOps.clean_group(self.group_name)
         lams = self.ns.LMI_AccountManagementService.first_instance()
         self.assertIsInstance(lams, LMIInstance)
         (retval, rparam, errorstr) = lams.CreateGroup({'Name': self.group_name,
@@ -65,7 +65,7 @@ class TestGroup(AccountBase):
         Account: Test to delete group
         """
         # make sure the group will exist
-        create_group(self.group_name)
+        common.UserOps.create_group(self.group_name)
         inst = self.cim_class.first_instance({"Name": self.group_name})
         self.assertIsInstance(inst, LMIInstance)
         r = inst.delete()
diff --git a/src/account/test/TestIndications.py b/src/account/test/TestIndications.py
index 7861eed..00f4dd0 100644
--- a/src/account/test/TestIndications.py
+++ b/src/account/test/TestIndications.py
@@ -17,11 +17,11 @@
 # Authors: Roman Rakus <rrakus@redhat.com>
 #
 
-from common import AccountBase
+import common
 from methods import *
 import time
 
-class TestIndications(AccountBase):
+class TestIndications(common.AccountBase):
     """
     Class for testing LMI_Account indications
     """
@@ -46,10 +46,10 @@ class TestIndications(AccountBase):
         """
         Account: Test indication of group deletion
         """
-        create_group(self.group_name)
+        common.UserOps.create_group(self.group_name)
         filter_name = "test_delete_group_%d" % (time.time() * 1000000)
         sub = self.subscribe(filter_name, "select * from LMI_AccountInstanceDeletionIndication where SourceInstance isa LMI_Group")
-        clean_group(self.group_name)
+        common.UserOps.clean_group(self.group_name)
         indication = self.get_indication(10)
         self.assertEqual(indication.classname, "LMI_AccountInstanceDeletionIndication")
         self.assertIn("SourceInstance", indication.keys())
@@ -61,26 +61,26 @@ class TestIndications(AccountBase):
         """
         Account: Test indication of group creation
         """
-        clean_group(self.group_name)
+        common.UserOps.clean_group(self.group_name)
         filter_name = "test_create_group_%d" % (time.time() * 1000000)
         sub = self.subscribe(filter_name, "select * from LMI_AccountInstanceCreationIndication where SourceInstance isa LMI_Group")
-        create_group(self.group_name)
+        common.UserOps.create_group(self.group_name)
         indication = self.get_indication(10)
         self.assertEqual(indication.classname, "LMI_AccountInstanceCreationIndication")
         self.assertIn("SourceInstance", indication.keys())
         self.assertTrue(indication["SourceInstance"] is not None)
         self.assertEqual(indication["SourceInstance"]["Name"], self.group_name)
-        clean_group(self.group_name)
+        common.UserOps.clean_group(self.group_name)
         self.unsubscribe(sub);
 
     def test_account_deletion_indication(self):
         """
         Account: Test indication of account deletion
         """
-        create_account(self.user_name)
+        common.UserOps.create_account(self.user_name)
         filter_name = "test_delete_account_%d" % (time.time() * 1000000)
         sub = self.subscribe(filter_name, "select * from LMI_AccountInstanceDeletionIndication where SourceInstance isa LMI_Account")
-        clean_account(self.user_name)
+        common.UserOps.clean_account(self.user_name)
         indication = self.get_indication(10)
         self.assertEqual(indication.classname, "LMI_AccountInstanceDeletionIndication")
         self.assertIn("SourceInstance", indication.keys())
@@ -92,15 +92,15 @@ class TestIndications(AccountBase):
         """
         Account: Test indication of account creation
         """
-        clean_account(self.user_name)
+        common.UserOps.clean_account(self.user_name)
         filter_name = "test_create_account_%d" % (time.time() * 1000000)
         sub = self.subscribe(filter_name, "select * from LMI_AccountInstanceCreationIndication where SourceInstance isa LMI_Account")
-        create_account(self.user_name)
+        common.UserOps.create_account(self.user_name)
         indication = self.get_indication(10)
         self.assertEqual(indication.classname, "LMI_AccountInstanceCreationIndication")
         self.assertIn("SourceInstance", indication.keys())
         self.assertTrue(indication["SourceInstance"] is not None)
         self.assertEqual(indication["SourceInstance"]["Name"], self.user_name)
-        clean_account(self.user_name)
+        common.UserOps.clean_account(self.user_name)
         self.unsubscribe(sub);
 
diff --git a/src/account/test/TestMemberOfGroup.py b/src/account/test/TestMemberOfGroup.py
index 0c74dff..40ff33c 100644
--- a/src/account/test/TestMemberOfGroup.py
+++ b/src/account/test/TestMemberOfGroup.py
@@ -18,26 +18,26 @@
 # Authors: Roman Rakus <rrakus@redhat.com>
 #
 
-from common import AccountBase
+import common
 from methods import *
 from lmi.shell import LMIInstance
 from lmi.shell import LMIInstanceName
 
-class TestMemberOfGroup(AccountBase):
+class TestMemberOfGroup(common.AccountBase):
     """
     Class for testing LMI_MemberOfGroup class
     """
 
     def tearDown(self):
-        clean_account(self.user_name)
-        clean_group(self.group_name)
+        common.UserOps.clean_account(self.user_name)
+        common.UserOps.clean_group(self.group_name)
 
     def test_add_user_to_group(self):
         """
         Account: Test to add user to group
         """
-        create_account(self.user_name)
-        create_group(self.group_name)
+        common.UserOps.create_account(self.user_name)
+        common.UserOps.create_group(self.group_name)
         user = self.ns.LMI_Account.first_instance({"Name": self.user_name})
         group = self.ns.LMI_Group.first_instance_name({"Name": self.group_name})
         self.assertIsInstance(user, LMIInstance)
@@ -54,21 +54,21 @@ class TestMemberOfGroup(AccountBase):
         Account: Test remove user from group
         """
         # make sure the account will exist
-        create_account(self.user_name)
+        common.UserOps.create_account(self.user_name)
         inst = self.ns.LMI_Account.first_instance({"Name": self.user_name})
         self.assertIsInstance(inst, LMIInstance)
         r = inst.delete()
         self.assertTrue(r)
         # check if it was really deleted
-        self.assertFalse(user_exists(self.user_name))
+        self.assertFalse(common.UserOps.is_user(self.user_name))
 
     def test_user_in_groups(self):
         """
         Account: Test correct list of groups for user
         """
-        create_account(self.user_name)
-        create_group(self.group_name)
-        add_user_to_group(self.user_name, self.group_name)
+        common.UserOps.create_account(self.user_name)
+        common.UserOps.create_group(self.group_name)
+        common.UserOps.add_user_to_group(self.user_name, self.group_name)
         user = self.ns.LMI_Account.first_instance({"Name": self.user_name})
         self.assertIsInstance(user, LMIInstance)
         ident = self.ns.LMI_Identity.first_instance({"InstanceID": "LMI:UID:%s" % user.UserID})
diff --git a/src/account/test/TestService.py b/src/account/test/TestService.py
index f62d1cf..69a5054 100644
--- a/src/account/test/TestService.py
+++ b/src/account/test/TestService.py
@@ -18,12 +18,12 @@
 # Authors: Roman Rakus <rrakus@redhat.com>
 #
 
-from common import AccountBase
+import common
 from methods import *
 from lmi.shell import LMIInstance
 from lmi.shell import LMIInstanceName
 
-class TestService(AccountBase):
+class TestService(common.AccountBase):
     """
     Class for testing LMI_AccountManagementService
     """
@@ -35,7 +35,7 @@ class TestService(AccountBase):
         Account: Test create account parameters
         """
         # make sure the account will not exist
-        clean_account(self.user_name)
+        common.UserOps.clean_account(self.user_name)
         lams = self.cim_class.first_instance()
         self.assertIsInstance(lams, LMIInstance)
 
@@ -84,13 +84,13 @@ class TestService(AccountBase):
         self.assertEqual(field_in_passwd(self.user_name, 5), home_dir)
         self.assertEqual(field_in_passwd(self.user_name, 6), shell)
         self.assertEqual(field_in_shadow(self.user_name, 1), password)
-        clean_account(self.user_name)
+        common.UserOps.clean_account(self.user_name)
 
     def test_create_group(self):
         """
         Account: Test create group parameters
         """
-        clean_group(self.group_name)
+        common.UserOps.clean_group(self.group_name)
         lams = self.cim_class.first_instance()
         self.assertIsInstance(lams, LMIInstance)
         system_account = True
@@ -109,4 +109,4 @@ class TestService(AccountBase):
             self.assertEqual(identity.InstanceID, "LMI:GID:%d" %gid)
 
         self.assertEqual(field_in_group(self.group_name, 2), str(gid))
-        clean_group(self.group_name)
+        common.UserOps.clean_group(self.group_name)
diff --git a/src/account/test/common.py b/src/account/test/common.py
index 95abd38..2818006 100644
--- a/src/account/test/common.py
+++ b/src/account/test/common.py
@@ -121,3 +121,92 @@ class PasswdFile():
         """
         return [u['name'] for u in self.users]
 
+
+class UserOps(object):
+
+    @classmethod
+    def _field_in_group(cls, groupname, number):
+        """
+        Return numberth field in /etc/group for given groupname
+        """
+        for line in open("/etc/group").readlines():
+            if line.startswith(groupname):
+                return line.split(":")[number].strip()
+
+    @classmethod
+    def add_user_to_group(cls, username, groupname):
+        """
+        Will add user to group
+        """
+        subprocess.check_call(["usermod", "-a", "-G", groupname, username])
+
+    @classmethod
+    def clean_account(cls, name):
+        """
+        Force to delete testing account and remove home dir
+        """
+        if cls.is_user(name):
+            subprocess.check_call(["userdel", "-fr", name])
+        if cls.is_group(name):
+            # groups should be expicitely deleted
+            subprocess.check_call(["groupdel", name])
+
+    @classmethod
+    def clean_group(cls, group):
+        """
+        Force to delete testing group
+        """
+        if cls.is_group(group):
+            subprocess.check_call(["groupdel", group])
+
+    @classmethod
+    def create_account(cls, username):
+        """
+        Force to create account; run clean_account before creation
+        """
+        if not cls.is_user(username):
+            subprocess.check_call(["useradd", username])
+
+    @classmethod
+    def create_group(cls, group_name):
+        """
+        Force to create group
+        """
+        if not cls.is_group(group_name):
+            subprocess.check_call(["groupadd", group_name])
+
+    @classmethod
+    def list_users(cls):
+        """
+        List user names currently on the system
+        """
+        accts = []
+        for line in open("/etc/passwd").readlines():
+            acct, __ = line.split(":", 1)
+            accts.append(acct)
+        return accts
+
+    @classmethod
+    def list_groups(cls):
+        """
+        List group names currently on the system
+        """
+        accts = []
+        for line in open("/etc/group").readlines():
+            acct, __ = line.split(":", 1)
+            accts.append(acct)
+        return accts
+
+    @classmethod
+    def is_group(cls, name):
+        """
+        Return true/false if user does/does not exist
+        """
+        return name in cls.list_groups()
+
+    @classmethod
+    def is_user(cls, name):
+        """
+        Return true/false if user does/does not exist
+        """
+        return name in cls.list_users()
diff --git a/src/account/test/methods.py b/src/account/test/methods.py
index 9659d4f..ce05e7e 100644
--- a/src/account/test/methods.py
+++ b/src/account/test/methods.py
@@ -19,22 +19,6 @@
 #
 
 import random
-import string
-import subprocess
-
-def user_exists(username):
-    """
-    Return true/false if user does/does not exists
-    """
-    got = field_in_passwd(username, 0)
-    return got == username
-
-def group_exists(groupname):
-    """
-    Return true/false if user does/does not exists
-    """
-    got = field_in_group(groupname, 0)
-    return got == groupname
 
 def field_in_passwd(username, number):
     """
@@ -60,43 +44,6 @@ def field_in_group(groupname, number):
         if line.startswith(groupname):
             return line.split(":")[number].strip()
 
-def clean_account(user_name):
-    """
-    Force to delete testing account and remove home dir
-    """
-    if user_exists(user_name):
-        subprocess.check_call(["userdel", "-fr", user_name])
-    if group_exists(user_name):
-        # groups should be expicitely deleted
-        subprocess.check_call(["groupdel", user_name])
-
-def add_user_to_group(user_name, group_name):
-    """
-    Will add user to group
-    """
-    subprocess.check_call(["usermod", "-a", "-G", group_name, user_name])
-
-def create_account(user_name):
-    """
-    Force to create account; run clean_account before creation
-    """
-    if not user_exists(user_name):
-        subprocess.check_call(["useradd", user_name])
-
-def clean_group(group_name):
-    """
-    Force to delete testing group
-    """
-    if group_exists(group_name):
-        subprocess.check_call(["groupdel", group_name])
-
-def create_group(group_name):
-    """
-    Force to create group
-    """
-    if not group_exists(group_name):
-        subprocess.check_call(["groupadd", group_name])
-
 def random_shell():
     """
     Make up a funny shell