[testfix] Use library methods in test_256_snaps

The test case 'test_256_snapshots.py' contains hard-coded commands
which can be run using the existing library functions from the
snap_ops.py library, such as:
* snap_create
* set_snap_config

This patch includes usage of appropriate functions in place of the
hard-coded commands along with various cosmetic changes.

Change-Id: I6da7444d903efd1be6582c8fea037a5c4fddc111
Signed-off-by: Vinayak Papnoi <vpapnoi@redhat.com>

1 files changed, 101 insertions, 109 deletions

diff --git a/tests/functional/snapshot/test_256_snapshots.py b/tests/functional/snapshot/test_256_snapshots.py
index 72528022d..75df2ed4f 100644
--- a/tests/functional/snapshot/test_256_snapshots.py
+++ b/tests/functional/snapshot/test_256_snapshots.py
@@ -1,4 +1,4 @@
-#  Copyright (C) 2016-2017  Red Hat, Inc. <http://www.redhat.com>
+#  Copyright (C) 2016-2020  Red Hat, Inc. <http://www.redhat.com>
 #
 #  This program is free software; you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by
@@ -14,39 +14,25 @@
 #  with this program; if not, write to the Free Software Foundation, Inc.,
 #  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
-"""
-Description : The purpose of this test is to validate create snap>256
-"""
-
 import sys
-
+from time import sleep
 from glusto.core import Glusto as g
-
 from glustolibs.gluster.exceptions import ExecutionError
 from glustolibs.gluster.gluster_base_class import GlusterBaseClass, runs_on
 from glustolibs.misc.misc_libs import upload_scripts
-from glustolibs.io.utils import validate_io_procs, get_mounts_stat
-from glustolibs.gluster.snap_ops import get_snap_list, snap_delete_all
+from glustolibs.io.utils import (
+    wait_for_io_to_complete,
+    get_mounts_stat)
+from glustolibs.gluster.snap_ops import (
+    snap_create,
+    set_snap_config,
+    get_snap_list,
+    snap_delete_all)
 
 
 @runs_on([['distributed', 'replicated', 'distributed-replicated', 'dispersed',
            'distributed-dispersed'], ['glusterfs', 'nfs', 'cifs']])
-class SanpCreate256(GlusterBaseClass):
-    """
-    Test for snapshot create for max 256
-    Steps :
-        1. Create and start a volume
-        2. Mount the volume on a client
-        3. Perform some heavy IO
-        4. Varify IO
-        5. modify max snap limit to default to 256.
-        6. Create 256 snapshots
-        7. Varify 256 created successfully
-        8. Create 257th snapshot -  check for failure
-          -- it should fail.
-        9. Cleanup
-
-    """
+class TestValidateSnaps256(GlusterBaseClass):
     @classmethod
     def setUpClass(cls):
         cls.get_super_method(cls, 'setUpClass')()
@@ -67,108 +53,114 @@ class SanpCreate256(GlusterBaseClass):
         """
         setUp method
         """
-        # Setup_Volume
         self.get_super_method(self, 'setUp')()
-        ret = self.setup_volume_and_mount_volume(mounts=self.mounts,
-                                                 volume_create_force=True)
+
+        # Setup_Volume
+        ret = self.setup_volume_and_mount_volume(mounts=self.mounts)
         if not ret:
             raise ExecutionError("Failed to setup and mount volume")
         g.log.info("Volume %s has been setup successfully", self.volname)
 
+        self.all_mounts_procs = []
+        self.snapshots = [('snap-test-validate-256-snapshots-%s-%s'
+                           % (self.volname, i))for i in range(0, 256)]
+
     def tearDown(self):
         """
         tearDown
         """
-        ret, _, _ = snap_delete_all(self.mnode)
-        if not ret:
-            raise ExecutionError("Failed to delete all snaps")
         self.get_super_method(self, 'tearDown')()
 
-    @classmethod
-    def tearDownClass(cls):
-        """
-        Clean up the volume & mount
-        """
-        g.log.info("Starting volume and  mount cleanup")
-        ret = cls.unmount_volume_and_cleanup_volume(cls.mounts)
+        # Delete all snapshots
+        ret, _, _ = snap_delete_all(self.mnode)
+        if ret:
+            raise ExecutionError("Failed to delete all snapshots")
+        g.log.info("Successfully deleted all snapshots")
+
+        # Unmount and cleanup volume
+        ret = self.unmount_volume_and_cleanup_volume(mounts=self.mounts)
         if not ret:
             raise ExecutionError("Failed to cleanup volume and mount")
         g.log.info("Cleanup successful for the volume and mount")
 
-        cls.get_super_method(cls, 'tearDownClass')()
-
     def test_validate_snaps_256(self):
+        """
+        Validate snapshot creation for 256 snapshots
 
-        # Start IO on all mounts.
-        all_mounts_procs = []
-        count = 1
-        for mount_obj in self.mounts:
-            g.log.info("Starting IO on %s:%s", mount_obj.client_system,
-                       mount_obj.mountpoint)
-            cmd = ("/usr/bin/env python%d %s create_deep_dirs_with_files "
-                   "--dirname-start-num %d "
-                   "--dir-depth 2 "
-                   "--dir-length 10 "
-                   "--max-num-of-dirs 5 "
-                   "--num-of-files 5 %s" % (
-                       sys.version_info.major, self.script_upload_path, count,
-                       mount_obj.mountpoint))
-            proc = g.run_async(mount_obj.client_system, cmd,
-                               user=mount_obj.user)
-            all_mounts_procs.append(proc)
-            count = count + 10
-
-        # Validate IO
-        g.log.info("Validating IO's")
-        ret = validate_io_procs(all_mounts_procs, self.mounts)
-        self.assertTrue(ret, "IO failed on some of the clients")
-        g.log.info("Successfully validated all io's")
-
-        # Get stat of all the files/dirs created.
-        g.log.info("Get stat of all the files/dirs created.")
+        * Perform some IO
+        * Set snapshot config option snap-max-hard-limit to 256
+        * Create 256 snapshots
+        * Verify 256 created successfully
+        * Create 257th snapshot - creation should fail as it will
+          exceed the hard-limit
+        * Verify snapshot list for 256 snapshots
+
+        """
+        # pylint: disable=too-many-statements
+        # Start IO on all mounts
+        cmd = (
+            "/usr/bin/env python%d %s create_files "
+            "-f 10 --base-file-name firstfiles %s"
+            % (sys.version_info.major,
+               self.script_upload_path,
+               self.mounts[0].mountpoint))
+        proc = g.run_async(
+            self.mounts[0].client_system, cmd, user=self.mounts[0].user)
+        self.all_mounts_procs.append(proc)
+
+        # Wait for IO to complete
+        self.assertTrue(
+            wait_for_io_to_complete(self.all_mounts_procs, self.mounts[0]),
+            "IO failed on %s" % self.mounts[0])
+        g.log.info("IO is successful on all mounts")
+
+        # Perform stat on all the files/dirs created
         ret = get_mounts_stat(self.mounts)
         self.assertTrue(ret, "Stat failed on some of the clients")
-        g.log.info("Successfully got stat of all files/dirs created")
-
-        # set config for 256 snpas (to make sure to override)
-        cmd_str = ("gluster snapshot config snap-max-hard-limit 256"
-                   " --mode=script")
-        ret = g.run(self.mnode, cmd_str)
-        self.assertTrue(ret, "Failed to set snap-max-hard-limit to 256.")
-        g.log.info("snap-max-hard limit successfully set for 256.")
-
-        # Create 256 snaps
-        for i in range(1, 257, 1):
-            cmd_str = "gluster snapshot create %s %s %s" % (
-                "snapy%s" % i, self.volname, "no-timestamp")
-            ret = g.run(self.mnode, cmd_str)
-            self.assertTrue(ret, ("Failed to create snapshot for %s"
-                                  % self.volname))
-            g.log.info("Snapshot %s created successfully for volume  %s",
-                       "snapy%s" % i, self.volname)
-
-        # Check for no. of snaps using snap_list it should be 256
+        g.log.info("Successfully performed stat on all files/dirs created")
+
+        # Set config option snap-max-hard-limit to 256
+        # This is to make sure to override
+        max_hard_limit = {'snap-max-hard-limit': '256'}
+        ret, _, _ = set_snap_config(self.mnode, max_hard_limit)
+        self.assertEqual(ret, 0, "Failed to set snapshot config option "
+                         "snap-max-hard-limit to 256")
+        g.log.info("Successfully set snapshot config option "
+                   "snap-max-hard-limit to 256")
+
+        # Create 256 snapshots
+        for snapname in self.snapshots:
+            ret, _, _ = snap_create(self.mnode, self.volname, snapname)
+            self.assertEqual(ret, 0, ("Failed to create snapshot %s for %s"
+                                      % (snapname, self.volname)))
+            sleep(1)
+        g.log.info("Snapshots created successfully for volume %s",
+                   self.volname)
+
+        # Validate snapshot list for 256 snapshots
         snap_list = get_snap_list(self.mnode)
-        self.assertTrue((len(snap_list) == 256), "No of snaps not consistent "
-                        "for volume %s" % self.volname)
-        g.log.info("Successfully validated number of snaps.")
-
-        # Validate all 256 snap names created during
-        for i in range(1, 257, 1):
-            self.assertTrue(("snapy%s" % i in snap_list), "%s snap not "
-                            "found " % ("snapy%s" % i))
-        g.log.info("Successfully validated names of snap")
-
-        # Try to create 257th snapshot
-        cmd_str = "gluster snapshot create %s %s %s" % ("snap", self.volname,
-                                                        "no-timestamp")
-        ret = g.run(self.mnode, cmd_str)
-        self.assertEqual(ret, 1, ("Unexpected: Successfully created 'snap'"
-                                  " for  volume %s" % self.volname))
-        g.log.info("Snapshot 'snap' not created as it is 257th snap")
-
-        # Check for no. of snaps using snap_list it should be 256
+        self.assertTrue((len(snap_list) == 256), "Failed: Number of snapshots "
+                        "is not consistent for volume %s" % self.volname)
+        g.log.info("Successfully validated number of snapshots")
+
+        # Validate snapshot existence using snap-name
+        for snapname in self.snapshots:
+            self.assertIn(snapname, snap_list,
+                          "Failed: Snapshot %s not found" % snapname)
+        g.log.info("Successfully validated snapshots existence using "
+                   "snap-name")
+
+        # Try to exceed snap-max-hard-limit by creating 257th snapshot
+        snap_257 = "snap-test-validate-256-snapshots-%s-257" % (self.volname)
+        ret, _, _ = snap_create(self.mnode, self.volname, snap_257)
+        self.assertEqual(
+            ret, 1, ("Unexpected: Successfully created %s for  volume %s"
+                     % (snap_257, self.volname)))
+        g.log.info("Snapshot %s not created as it exceeds the "
+                   "snap-max-hard-limit", snap_257)
+
+        # Validate snapshot list for 256 snapshots
         snap_list = get_snap_list(self.mnode)
-        self.assertEqual(256, len(snap_list), "No of snaps not consistent "
-                         "for volume %s" % self.volname)
-        g.log.info("Successfully validated number of snaps.")
+        self.assertEqual(len(snap_list), 256, "Failed: Number of snapshots "
+                         "is not consistent for volume %s" % self.volname)
+        g.log.info("Successfully validated number of snapshots")