Merge lp:~elopio/cloudspacesclient/refactor into lp:cloudspacesclient

[Leo Arias]

Refactor tests to make them smaller or clearer.

[Richard Huddie (rhuddie)]

review: Approve

=== modified file 'src/cloudspacesclient/tests/conformance/test_cloudspaces_api.py'
--- src/cloudspacesclient/tests/conformance/test_cloudspaces_api.py	2013-12-06 00:21:49 +0000
+++ src/cloudspacesclient/tests/conformance/test_cloudspaces_api.py	2013-12-06 00:21:49 +0000
@@ -39,13 +39,13 @@
     return getattr(test_server_module, test_server_adapter[-1])()
 
 
-class CloudspacesAPITestCase(unittest.TestCase):
+class BaseCloudspacesAPITestCase(unittest.TestCase):
 
     cloudspaces_server_url = config.get(
         'cloudspaces', 'cloudspaces_server_url')
 
     def setUp(self):
-        super(CloudspacesAPITestCase, self).setUp()
+        super(BaseCloudspacesAPITestCase, self).setUp()
         self.start_datetime = self._get_now_datetime()
         self.test_server = get_test_server_adapter()
         self.test_user = self.test_server.create_test_user()
@@ -64,6 +64,14 @@
         rfc3339_now = now.isoformat().replace("T ", "T").split(".")[0] + "Z"
         return parser.parse(rfc3339_now)
 
+    def assert_datetime_limits(self, datetime, start_datetime, end_datetime):
+        # The server doesn't return microseconds, so times may be equal.
+        self.assertGreaterEqual(datetime, start_datetime)
+        self.assertLessEqual(datetime, end_datetime)
+
+
+class UserRepresentationTestCase(BaseCloudspacesAPITestCase):
+
     def test_get_user_representation(self):
         user_rep = self.cloudspaces_api_client.get_user_representation()
 
@@ -80,23 +88,33 @@
                                      end_datetime):
         for volume in volumes:
             when_created = parser.parse(volume.get('when_created'))
-            self._assert_datetime_limits(
+            self.assert_datetime_limits(
                 when_created, start_datetime, end_datetime)
 
-    def _assert_datetime_limits(self, datetime, start_datetime, end_datetime):
-        # The server doesn't return microseconds, so times may be equal.
-        self.assertGreaterEqual(datetime, start_datetime)
-        self.assertLessEqual(datetime, end_datetime)
-
     def _assert_new_user_volumes_name(self, volumes):
         volume_names = [volume.get('name') for volume in volumes]
         self.assertEqual(
             volume_names, self.test_server.get_new_user_volume_names())
 
+
+class TestCaseWithRootNodeInfo(BaseCloudspacesAPITestCase):
+
+    def setUp(self):
+        super(TestCaseWithRootNodeInfo, self).setUp()
+        self.root_node_id = self._get_root_node_id()
+        
+    def _get_root_node_id(self):
+        user_rep = self.cloudspaces_api_client.get_user_representation()
+        root_volume = self._get_root_volume(user_rep.get('volumes'))
+        return root_volume.get('node_id')
+
+    def _get_root_volume(self, volumes):
+        # FIXME The first volume returned is not necessarily the root.
+        # --elopio - 2013-11-23
+        return volumes[0]
+        
     def test_get_root_metadata(self):
-        node_id = self._get_root_node_id()
-
-        metadata = self.cloudspaces_api_client.get_metadata(node_id)
+        metadata = self.cloudspaces_api_client.get_metadata(self.root_node_id)
 
         validictory.validate(
             metadata, schemas.GET_FOLDER_METADATA_RESPONSE_SCHEMA)
@@ -104,7 +122,7 @@
         path, filename = os.path.split(self.test_server.get_root_path())
         expected = dict(
             is_deleted=False, is_folder=True, is_root=True, filename=filename,
-            node_id=node_id, path=path)
+            node_id=self.root_node_id, path=path)
         self._assert_json_object_values(expected, metadata)
 
         self._assert_normal_folder_keys_not_in_root(metadata)
@@ -117,16 +135,6 @@
         # --elopio - 2013-11-25
         # TODO Check the volume_id field. --elopio - 2013-11-25
 
-    def _get_root_node_id(self):
-        user_rep = self.cloudspaces_api_client.get_user_representation()
-        root_volume = self._get_root_volume(user_rep.get('volumes'))
-        return root_volume.get('node_id')
-
-    def _get_root_volume(self, volumes):
-        # FIXME The first volume returned is not necessarily the root.
-        # --elopio - 2013-11-23
-        return volumes[0]
-
     def _assert_json_object_values(self, expected, actual):
         """Assert the values of the returned json object.
 
@@ -163,7 +171,7 @@
         metadata_log = []
         # if a node id is not given, then use the root as default
         if not parent_node_id:
-            parent_node_id = self._get_root_node_id()
+            parent_node_id = self.root_node_id
         # create the folders in the parent folder
         for count in range(folder_count):
             metadata = self.cloudspaces_api_client.make_folder(
@@ -177,13 +185,11 @@
         return metadata_log
 
     def test_create_folder_in_root(self):
-        # get the root node id and root folder name
-        root_node_id = self._get_root_node_id()
         # create the folder
         folder_name = 'root_folder_1'
 
         metadata = self.cloudspaces_api_client.make_folder(
-            root_node_id, folder_name)
+            self.root_node_id, folder_name)
         # validate the folder properties from response
         validictory.validate(
             metadata, schemas.GET_FOLDER_METADATA_RESPONSE_SCHEMA)
@@ -191,12 +197,10 @@
         root_path = self.test_server.get_root_path()
         expected = dict(
             is_folder=True, is_deleted=False, is_root=False, path=root_path,
-            filename=folder_name, parent_node_id=root_node_id, version=1)
+            filename=folder_name, parent_node_id=self.root_node_id, version=1)
         self._assert_json_object_values(expected, metadata)
 
     def test_create_folder_no_parent_id(self):
-        # get the root node id and root folder name
-        root_node_id = self._get_root_node_id()
         # create the folder without specifying the parent folder id
         # this should add folder to root level by default
         folder_name = 'folder_no_parent_id'
@@ -209,16 +213,14 @@
         root_path = self.test_server.get_root_path()
         expected = dict(
             is_folder=True, is_deleted=False, is_root=False, path=root_path,
-            filename=folder_name, parent_node_id=root_node_id, version=1)
+            filename=folder_name, parent_node_id=self.root_node_id, version=1)
         self._assert_json_object_values(expected, metadata)
 
     def test_create_child_folder(self):
-        # get the root node id and root folder name
-        root_node_id = self._get_root_node_id()
         parent_folder_name = 'parent_folder_1'
         # create the parent folder
         parent_metadata = self.cloudspaces_api_client.make_folder(
-            root_node_id, parent_folder_name)
+            self.root_node_id, parent_folder_name)
         # Now create a sub folder under the parent folder
         child_folder_name = 'child_folder_1'
         parent_node_id = parent_metadata.get('node_id')
@@ -237,12 +239,11 @@
         self._assert_json_object_values(expected, metadata)
 
     def test_create_new_file(self):
-        root_node_id = self._get_root_node_id()
         test_file_name = 'test.txt'
         test_file_mimetype = 'text/plain'
 
         metadata = self.cloudspaces_api_client.make_file(
-            root_node_id, test_file_name)
+            self.root_node_id, test_file_name)
 
         validictory.validate(
             metadata, schemas.GET_FILE_METADATA_RESPONSE_SCHEMA)
@@ -251,11 +252,12 @@
         expected = dict(
             hash=None, filename=test_file_name, is_deleted=False,
             is_folder=False, mimetype=test_file_mimetype,
-            parent_node_id=root_node_id, path=root_path, size=0, version=1)
+            parent_node_id=self.root_node_id, path=root_path, size=0,
+            version=1)
         self._assert_json_object_values(expected, metadata)
 
         # Assert that the file has just been created.
-        self._assert_datetime_limits(
+        self.assert_datetime_limits(
             parser.parse(metadata.get('server_modified')), self.start_datetime,
             self._get_now_datetime())
         # TODO update the spec because it says checksum instead of hash.
@@ -267,21 +269,19 @@
 
     def test_download_empty_file(self):
         test_file_name = 'test_file_to_download.txt'
-        root_node_id = self._get_root_node_id()
         create_metadata = self.cloudspaces_api_client.make_file(
-            root_node_id, test_file_name)
+            self.root_node_id, test_file_name)
         file_node_id = create_metadata.get('node_id')
 
         contents = list(self.cloudspaces_api_client.get_file(file_node_id))
         self.assertEqual(contents, [])
 
     def test_delete_file(self):
-        root_node_id = self._get_root_node_id()
         test_file_name = 'test_file_to_delete.txt'
         test_file_mimetype = 'text/plain'
 
         create_metadata = self.cloudspaces_api_client.make_file(
-            root_node_id, test_file_name)
+            self.root_node_id, test_file_name)
         file_node_id = create_metadata.get('node_id')
 
         delete_metadata = self.cloudspaces_api_client.delete(file_node_id)
@@ -292,11 +292,11 @@
         expected = dict(
             hash=None, filename=test_file_name, is_deleted=True,
             is_folder=False, mimetype=test_file_mimetype,
-            parent_node_id=root_node_id, path=root_path, size=0)
+            parent_node_id=self.root_node_id, path=root_path, size=0)
         self._assert_json_object_values(expected, delete_metadata)
 
         # Assert that the file has just been modified.
-        self._assert_datetime_limits(
+        self.assert_datetime_limits(
             parser.parse(delete_metadata.get('server_modified')),
             self.start_datetime,
             self._get_now_datetime())
@@ -304,12 +304,10 @@
         # TODO Check the volume_id field. --elopio - 2013-11-27
 
     def test_delete_folder_in_root(self):
-        # get the root node id and root folder name
-        root_node_id = self._get_root_node_id()
         # create the folder to be deleted later
         folder_name = 'delete_me_folder_1'
         metadata = self.cloudspaces_api_client.make_folder(
-            root_node_id, folder_name)
+            self.root_node_id, folder_name)
         # now delete the folder
         node_id = metadata.get('node_id')
         metadata = self.cloudspaces_api_client.delete(node_id)
@@ -329,10 +327,9 @@
             self.cloudspaces_api_client.delete(node_id)
 
     def test_delete_folder_and_children_in_root(self):
-        root_node_id = self._get_root_node_id()
         # create a new parent folder to hold the child items
         metadata = self.cloudspaces_api_client.make_folder(
-            root_node_id, 'test_delete_folder_and_children_in_root')
+            self.root_node_id, 'test_delete_folder_and_children_in_root')
         parent_node_id = metadata.get('node_id')
         # now create sub-files and folders within this folder
         # this content should be deleted by the test when top folder is deleted
@@ -355,12 +352,10 @@
 
     def test_create_folder_using_parent_file_id(self):
         # A negative test to create a folder using the node id of a file as
-        # the parent node id for the folder
-        root_node_id = self._get_root_node_id()
         # create a file first
         file_name = 'test_file.txt'
         metadata = self.cloudspaces_api_client.make_file(
-            root_node_id, file_name)
+            self.root_node_id, file_name)
         file_node_id = metadata.get('node_id')
         # now try and create a folder, using file id as parent
         # this should fail gracefully with a suitable error code
@@ -369,11 +364,9 @@
             self.cloudspaces_api_client.make_folder(file_node_id, folder_name)
 
     def test_folder_child_list_false(self):
-        # A test to get child objects from parent directory
-        root_node_id = self._get_root_node_id()
         # create a new parent folder to hold the child items
         metadata = self.cloudspaces_api_client.make_folder(
-            root_node_id, 'test_folder_child_list_false')
+            self.root_node_id, 'test_folder_child_list_false')
         parent_node_id = metadata.get('node_id')
         # Create a data structure from root folder
         file_count = 3
@@ -387,11 +380,9 @@
         self.assertEqual(None, metadata.get('contents'))
 
     def test_folder_child_list_true(self):
-        # A test to get child objects from parent directory
-        root_node_id = self._get_root_node_id()
         # create a new parent folder to hold the child items
         metadata = self.cloudspaces_api_client.make_folder(
-            root_node_id, 'test_folder_child_list_true')
+            self.root_node_id, 'test_folder_child_list_true')
         parent_node_id = metadata.get('node_id')
         # Create a data structure from root folder
         file_count = 3
@@ -408,17 +399,14 @@
 
     def test_folder_depth(self):
         # A test to create a hierarchichal directory structure and validate
-        # the folder path is correct for each sub-folder
-        root_node_id = self._get_root_node_id()
-        # create a new parent folder to hold the child items
-        parent_metadata = self.cloudspaces_api_client.make_folder(
-            root_node_id, 'test_folder_depth')
-        parent_node_id = parent_metadata.get('node_id')
-        folder_depth = 10
+        parent_node_id = self.root_node_id
+        parent_metadata = self.cloudspaces_api_client.get_metadata(
+            parent_node_id)
         # store the path of the top level folder
         parent_path = os.path.join(
             parent_metadata.get('path'), parent_metadata.get('filename'))
 
+        folder_depth = 10
         for level in range(folder_depth):
             # construct the expected folder path
             folder_name = 'folder_{}'.format(level + 1)
@@ -434,33 +422,25 @@
             parent_node_id = metadata.get('node_id')
 
     def test_create_folder_with_existing_name(self):
-        # attempt to create 2 folders with the same name in root
-        root_node_id = self._get_root_node_id()
-        # create a new parent folder to hold the child items
-        metadata = self.cloudspaces_api_client.make_folder(
-            root_node_id, 'test_create_folder_with_existing_name')
-        parent_node_id = metadata.get('node_id')
         folder_name = 'duplicate_folder'
         self.cloudspaces_api_client.make_folder(
-            parent_node_id, folder_name)
-        metadata = self.cloudspaces_api_client.make_folder(
-            parent_node_id, folder_name)
+            self.root_node_id, folder_name)
+        folder_metadata = self.cloudspaces_api_client.make_folder(
+            self.root_node_id, folder_name)
         # now do a check the metadata of the dir listing
-        get_metadata = self.cloudspaces_api_client.get_metadata(
-            parent_node_id, list='true')
-        child_nodes = get_metadata.get('contents')
+        root_metadata = self.cloudspaces_api_client.get_metadata(
+            self.root_node_id, list='true')
+        child_nodes = root_metadata.get('contents')
         # check only 1 folder listed and that the metadata matches
         self.assertEqual(len(child_nodes), 1)
-        self.assertEqual(metadata, child_nodes[0])
+        self.assertEqual(folder_metadata, child_nodes[0])
 
     def test_new_file_version(self):
-        # A test to upload new content to a file and check it is updated
-        root_node_id = self._get_root_node_id()
         test_file_name = 'file_version_test.txt'
         content_v1 = 'This is file content version 1'
         content_v2 = 'This is the next file version, 2'
         metadata = self.cloudspaces_api_client.make_file(
-            root_node_id, test_file_name)
+            self.root_node_id, test_file_name)
         file_node_id = metadata.get('node_id')
         # load version 1 of the file
         metadata = self.cloudspaces_api_client.put_file(
@@ -468,7 +448,7 @@
         # check correct version
         self.assertEqual(metadata.get('version'), 2)
         # Assert that the file has just been created.
-        self._assert_datetime_limits(
+        self.assert_datetime_limits(
             parser.parse(metadata.get('server_modified')), self.start_datetime,
             self._get_now_datetime())
         # load version 2 of the file
@@ -477,7 +457,7 @@
         # check correct version
         self.assertEqual(metadata.get('version'), 3)
         # Assert that the file has just been updated.
-        self._assert_datetime_limits(
+        self.assert_datetime_limits(
             parser.parse(metadata.get('server_modified')), self.start_datetime,
             self._get_now_datetime())
         # get the latest version and compare with expected content