ciocore 5.1.1__py2.py3-none-any.whl → 10.0.0b3__py2.py3-none-any.whl

tests/test_package_tree.py

@@ -1,237 +1,113 @@
 """ test package_tree
-
-   isort:skip_file
 """
-import json
+import unittest
 import os
-import random
 import sys
-import unittest
-
+import copy
 from ciocore import package_tree
- 
-JSON_FILENAME = os.path.join(os.path.dirname(__file__) , "fixtures", "sw_packages.json")
-with open(JSON_FILENAME, 'r') as content:
-    packages_json = json.load(content)["data"]
- 
-SRC = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "src")
-if SRC not in sys.path:
-    sys.path.insert(0, SRC)
-
-
-class RemoveUnreachableTest(unittest.TestCase):
-
-    def test_single_valid_tree_unchanged(self):
-        paths = ["a", "a/b", "a/b/c"]
-        results = package_tree.remove_unreachable(paths)
-        self.assertEqual(results, paths)
-
-    def test_many_valid_trees_unchanged(self):
-        paths = ["a", "a/b", "a/b/c", "b", "b/b", "b/b/c", "c", "c/b", "c/b/c"]
-        results = package_tree.remove_unreachable(paths)
-        self.assertEqual(results, paths)
-
-    def test_single_invalid_tree_culled_leaf(self):
-        paths = ["a", "a/b", "b/b/c"]
-        results = package_tree.remove_unreachable(paths)
-        self.assertEqual(results, ["a", "a/b"])
-
-    def test_single_invalid_tree_culled_below(self):
-        paths = ["a", "b/b", "a/b/c"]
-        results = package_tree.remove_unreachable(paths)
-        self.assertEqual(results, ["a"])
-
-    def test_multiple_invalid_tree_culled(self):
-        paths = ["a", "a/b", "a/b/c", "b", "b/b", "b/b/c", "d", "c/b", "c/b/c"]
-        results = package_tree.remove_unreachable(paths)
-        self.assertEqual(
-            results, [
-                "a", "a/b", "a/b/c", "b", "b/b", "b/b/c", "d"])
-
-    def test_random_input_order(self):
-        paths = ["a", "a/b", "a/b/c", "b", "b/b", "b/b/c", "d", "c/b", "c/b/c"]
-        random.shuffle(paths)
-        results = package_tree.remove_unreachable(paths)
-        self.assertEqual(
-            results, [
-                "a", "a/b", "a/b/c", "b", "b/b", "b/b/c", "d"])
+from package_fixtures import *
 
 
 class ToNameTest(unittest.TestCase):
 
-    def test_major_only(self):
-        pkg = {
-            "product": "foo-bar",
-            "major_version": "1",
-            "minor_version": "",
-            "release_version": "",
-            "build_version": ""
-        }
-        expected = "foo-bar 1"
+    def setUp(self):
+        self.packages = copy.deepcopy(BLENDER_DATA)
+
+    def test_major(self):
+        pkg = self.packages[0]
+        expected = "blender 1 linux"
         self.assertEqual(package_tree.to_name(pkg), expected)
 
     def test_major_minor(self):
-        pkg = {
-            "product": "foo-bar",
-            "major_version": "1",
-            "minor_version": "3",
-            "release_version": "",
-            "build_version": ""
-        }
-        expected = "foo-bar 1.3"
+        pkg = self.packages[1]
+        expected = "blender 1.0 linux"
         self.assertEqual(package_tree.to_name(pkg), expected)
 
     def test_major_minor_release(self):
-        pkg = {
-            "product": "foo-bar",
-            "major_version": "1",
-            "minor_version": "3",
-            "release_version": "62",
-            "build_version": ""
-        }
-        expected = "foo-bar 1.3.62"
+        pkg = self.packages[2]
+        expected = "blender 1.0.2 linux"
         self.assertEqual(package_tree.to_name(pkg), expected)
 
     def test_major_minor_release_build(self):
-        pkg = {
-            "product": "foo-bar",
-            "major_version": "1",
-            "minor_version": "3",
-            "release_version": "62",
-            "build_version": "876"
-        }
-        expected = "foo-bar 1.3.62.876"
-        self.assertEqual(package_tree.to_name(pkg), expected)
-
-    def test_platform(self):
-        pkg = {
-            "product": "foo-bar",
-            "major_version": "1",
-            "minor_version": "",
-            "release_version": "",
-            "build_version": "",
-            "platform": "windows"
-        }
-        expected = "foo-bar 1 windows"
+        pkg = self.packages[3]
+        expected = "blender 1.0.2.3 linux"
         self.assertEqual(package_tree.to_name(pkg), expected)
 
+    def test_bad_platform(self):
+        with self.assertRaises(KeyError):
+            pkg = self.packages[0]
+            pkg["platform"] = "bad"
+            package_tree.to_name(pkg)
 
 class SoftwareDataInitTest(unittest.TestCase):
+    def setUp(self):
+        """
+        Pad out with just enough fields to allow link_plugin_packages() to run.
+        """
+        self.packages = copy.deepcopy(SOFTWARE_DATA)
 
     def test_smoke(self):
         pt = package_tree.PackageTree([])
         self.assertIsInstance(pt, package_tree.PackageTree)
 
-    def test_init_with_product(self):
-        pt = package_tree.PackageTree(packages_json, product="houdini")
-        self.assertEqual(len(pt.tree["children"]), 2)
-        pt = package_tree.PackageTree(packages_json, product="maya-io")
-        self.assertEqual(len(pt.tree["children"]), 9)
-
-    def test_init_with_no_product(self):
-        pt = package_tree.PackageTree(packages_json)
-        self.assertEqual(len(pt.tree["children"]), 79)
-
-    def test_init_with_sub_product(self):
-        pt = package_tree.PackageTree(
-            packages_json,
-            product="arnold-houdini")
-        self.assertEqual(len(pt.tree["children"]), 4)
-
-    def test_init_with_windows_product(self):
-        pt = package_tree.PackageTree(
-            packages_json,
-            product="cinema4d")
-        self.assertEqual(len(pt.tree["children"]), 2)
-
-class SoftwareDataTestInitPlatformFilter(unittest.TestCase):
-
-    def test_does_not_filter_by_default(self):
-        pt = package_tree.PackageTree(packages_json, product="cinema4d")
-        self.assertEqual(len(pt.tree["children"]), 2)
-  
-    def test_filter_windows(self):
-        pt = package_tree.PackageTree(packages_json, product="cinema4d", platforms=["windows"])
-        self.assertEqual(len(pt.tree["children"]), 1)
-        self.assertEqual(pt.tree["children"][0]["platform"], "windows")
-        
-    def test_filter_linux(self):
-        pt = package_tree.PackageTree(packages_json, product="cinema4d", platforms=["linux"])
-        self.assertEqual(len(pt.tree["children"]), 1)
-        self.assertEqual(pt.tree["children"][0]["platform"], "linux")
-        
+    def test_init_with_filter_host_products(self):
+        pt = package_tree.PackageTree(self.packages, "maya", "blender")
+        self.assertEqual(len(pt.as_dict()["children"]), len(MAYA_DATA+BLENDER_DATA))
+ 
+    def test_init_with_one_product(self):
+        pt = package_tree.PackageTree(self.packages, product="redshift")
+        self.assertEqual(len(pt.as_dict()["children"]), len(REDSHIFT_DATA))
+ 
+    def test_init_with_all_product(self):
+        pt = package_tree.PackageTree(self.packages)
+        self.assertEqual(len(pt.as_dict()["children"]), len(HOST_DATA))
+
+    def test_filter_platform(self):
+        pt = package_tree.PackageTree(self.packages, platforms=["windows"])
+        expected = [h for h in HOST_DATA if h["platform"] == "windows"]
+        self.assertEqual( len(pt.as_dict()["children"]) , len(expected) )
+
+    def test_filter_platform_and_product(self):
+        pt = package_tree.PackageTree(self.packages, product="c4d", platforms=["linux"])
+        expected = [h for h in C4D_DATA if h["platform"] == "windows"]
+        self.assertEqual(len(pt._tree["children"]),  len(expected))
+
     def test_raise_bad_platform(self):
         with self.assertRaises(KeyError):
-            pt = package_tree.PackageTree(packages_json, product="cinema4d", platforms=["bad"])
- 
+            pt = package_tree.PackageTree(self.packages, platforms=["bad"])
 
-class SoftwareDataFindByKeysTest(unittest.TestCase):
+    def test_nonexistent_product_falsy(self):
+        pt = package_tree.PackageTree(self.packages, product="noexist")
+        self.assertFalse(pt)
 
-    def setUp(self):
-        self.pt = package_tree.PackageTree(packages_json, product="houdini")
-
-    def test_find_host_by_keys(self):
-        keys = {
-            'product': 'houdini',
-            'major_version': '16',
-            'minor_version': '5',
-            'release_version': '323',
-            'build_version': '',
-            'plugin_host_product': '',
-            'plugin_host_version': ''
-        }
-        pkg = self.pt.find_by_keys(**keys)
-        self.assertEqual(pkg["product"], 'houdini')
-        self.assertEqual(pkg["major_version"], '16')
-        self.assertEqual(pkg["minor_version"], '5')
-        self.assertEqual(pkg["release_version"], '323')
-
-    def test_find_leaf_by_keys(self):
-        keys = {
-            'product': 'al-shaders',
-            'major_version': '1',
-            'minor_version': '1',
-            'release_version': '',
-            'build_version': '',
-            'plugin_host_product': '',
-            'plugin_host_version': ''
-        }
-        pkg = self.pt.find_by_keys(**keys)
-        self.assertEqual(pkg["product"], 'al-shaders')
-        self.assertEqual(pkg["major_version"], '1')
-        self.assertEqual(pkg["minor_version"], '1')
-
-    def test_find_nonexistent_package_returns_none(self):
-        keys = {
-            'product': 'arnold-houdini',
-            'major_version': '7',
-            'minor_version': '1',
-            'release_version': '',
-            'build_version': '',
-            'plugin_host_product': '',
-            'plugin_host_version': ''
-        }
-        pkg = self.pt.find_by_keys(**keys)
-        self.assertEqual(pkg, None)
+    def test_good_product_truthy(self):
+        pt = package_tree.PackageTree(self.packages, product="redshift")
+        self.assertTrue(pt)
 
+    def test_as_dict_returns_underlying_tree(self):
+        pt = package_tree.PackageTree(self.packages)
+        self.assertEqual(pt.as_dict(), pt._tree)
+        self.assertIsInstance(pt.as_dict(), dict)
 
-class SoftwareDataFindByPathTest(unittest.TestCase):
 
-    def setUp(self):
-        self.pt = package_tree.PackageTree(packages_json, product="houdini")
+class SoftwareDataFindersTest(unittest.TestCase):
 
+    def setUp(self):
+        self.packages = copy.deepcopy(SOFTWARE_DATA)
+        self.pt = package_tree.PackageTree(self.packages, product="maya")
+ 
     def test_find_root_path(self):
-        path = "houdini 16.0.736 linux"
+        path = "maya 1.1 linux"
         pkg = self.pt.find_by_path(path)
         self.assertEqual(package_tree.to_name(pkg), path)
 
     def test_find_leaf_path(self):
-        path = "houdini 16.0.736 linux/arnold-houdini 2.0.2.2 linux/al-shaders 1.0 linux"
+        path = "maya 1.1 linux/redshift 1 linux"
         pkg = self.pt.find_by_path(path)
-        self.assertEqual(package_tree.to_name(pkg), "al-shaders 1.0 linux")
+        self.assertEqual(package_tree.to_name(pkg), "redshift 1 linux")
 
     def test_find_nonexistent_path_return_none(self):
-        path = "houdini 16.0.736 linux/arnold-houdini 9.0.2.2 linux"
+        path = "maya 1.1 linux/redshift 3 linux"
         pkg = self.pt.find_by_path(path)
         self.assertEqual(pkg, None)
 
@@ -240,149 +116,73 @@ class SoftwareDataFindByPathTest(unittest.TestCase):
         pkg = self.pt.find_by_path(path)
         self.assertEqual(pkg, None)
 
-    def test_find_none_path_return_none(self):
-        path = None
-        pkg = self.pt.find_by_path(path)
-        self.assertEqual(pkg, None)
-
-class FindByNameTest(unittest.TestCase):
-    def setUp(self):
-        self.pt = package_tree.PackageTree(packages_json, product="houdini")
-
     def test_find_root(self):
-        name = 'houdini 16.5.323 linux'
+        name = 'maya 1.1 linux'
         result = self.pt.find_by_name(name)
         self.assertEqual(package_tree.to_name(result), name)
 
     def test_find_root_when_limit_1(self):
-        name = 'houdini 16.5.323 linux'
+        name = 'maya 1.1 linux'
         result = self.pt.find_by_name(name, 1)
         self.assertEqual(package_tree.to_name(result), name)
 
     def test_find_plugin_level(self):
-        name = "arnold-houdini 2.0.2.2 linux"
+        name = "redshift 1 linux"
         result = self.pt.find_by_name(name)
         self.assertEqual(package_tree.to_name(result), name)
 
-    def test_find_plugin_level_high_limit(self):
-        name = "arnold-houdini 2.0.2.2 linux"
-        result = self.pt.find_by_name(name, 2)
-        self.assertEqual(package_tree.to_name(result), name)
-
     def test_dont_find_plugin_level_when_limited(self):
-        name = "arnold-houdini 2.0.2.2 linux"
+        name = "redshift 1 linux"
         result = self.pt.find_by_name(name, 1)
         self.assertEqual(result, None)
 
-
-class SoftwareDataGetAllPathsTest(unittest.TestCase):
-
-    def setUp(self):
-        self.pt = package_tree.PackageTree(packages_json, product="houdini")
-
-    def test_get_all_paths_to_root(self):
-
-        keys = {
-            'product': 'houdini',
-            'major_version': '16',
-            'minor_version': '5',
-            'release_version': '323',
-            'build_version': '',
-            'plugin_host_product': '',
-            'plugin_host_version': '',
-            'platform': 'linux',
-            
-        }
-        paths = self.pt.get_all_paths_to(**keys)
-        self.assertTrue(
-            'houdini 16.5.323 linux' in paths)
-        self.assertEqual(len(paths), 1)
-
-    def test_get_all_paths_to_leaf(self):
-
-        keys = {
-            'product': 'al-shaders',
-            'major_version': '1',
-            'minor_version': '0',
-            'release_version': '',
-            'build_version': '',
-            'plugin_host_product': '',
-            'plugin_host_version': '',
-            "platform": "linux"
-        }
-        paths = self.pt.get_all_paths_to(**keys)
-        self.assertTrue(
-            'houdini 16.0.736 linux/arnold-houdini 2.0.1 linux/al-shaders 1.0 linux' in paths)
-        self.assertEqual(len(paths), 2)
-
-    def test_get_all_paths_to_nonexistent(self):
-
-        keys = {
-            'product': 'foo',
-            'major_version': '1',
-            'minor_version': '0',
-            'release_version': '',
-            'build_version': '',
-            'plugin_host_product': '',
-            'plugin_host_version': '',
-            "platform": "linux"
-        }
-        paths = self.pt.get_all_paths_to(**keys)
-        self.assertEqual(paths, [])
-
-
 class SoftwarePlatformsSetTest(unittest.TestCase):
     # There are Windows packages in c4d but not Maya.
+    def setUp(self):
+        self.packages = copy.deepcopy(SOFTWARE_DATA)
+   
     def test_only_linux(self):
-        pt = package_tree.PackageTree(packages_json, product="maya-io")
+        pt = package_tree.PackageTree(self.packages, product="maya")
         self.assertEqual({"linux"}, pt.platforms())
-        
+
     def test_linux_and_windows(self):
-        pt = package_tree.PackageTree(packages_json, product="cinema4d")
+        pt = package_tree.PackageTree(self.packages, product="c4d")
         self.assertEqual({"windows", "linux"}, pt.platforms())
-        
+
 
 class SupportedHostNamesTest(unittest.TestCase):
     def setUp(self):
-        self.pt = package_tree.PackageTree(packages_json, product="maya-io")
-        self.one_hostname = 'maya-io 2018.SP2 linux'
+        self.packages = copy.deepcopy(SOFTWARE_DATA)
 
     def test_supported_host_names(self):
-
+        self.pt = package_tree.PackageTree(self.packages, product="maya")
         host_names = self.pt.supported_host_names()
-
-        self.assertEqual(len(host_names), 9)
-        self.assertIn(self.one_hostname, host_names)
+        self.assertEqual(len(host_names), 3)
+        self.assertIn('maya 1.1 linux', host_names)
 
     def test_supported_host_names_windows(self):
-        self.pt = package_tree.PackageTree(packages_json, product="cinema4d")
+        self.pt = package_tree.PackageTree(self.packages, product="c4d", platforms=["windows"])
         host_names = self.pt.supported_host_names()
         self.assertEqual(len(host_names), 2)
-        self.assertIn('cinema4d 25.117.RB316423 windows', host_names)
+        self.assertIn('c4d 1.0 windows', host_names)
 
 
 class SupportedPluginsTest(unittest.TestCase):
     def setUp(self):
-        self.pt = package_tree.PackageTree(packages_json, product="maya-io")
-        self.one_hostname = 'maya-io 2018.SP2 linux'
-
-    def test_supported_plugins_count(self):
-        plugins = self.pt.supported_plugins(self.one_hostname)
-        self.assertEqual(len(plugins), 4)
+        self.packages = copy.deepcopy(SOFTWARE_DATA)
+        self.pt = package_tree.PackageTree(self.packages, product="maya")
+        self.one_hostname = 'maya 1.0 linux'
 
-    
     def test_supported_plugins_keys(self):
         plugins = self.pt.supported_plugins(self.one_hostname)
         self.assertIsInstance(plugins[0], dict)
         self.assertIn("plugin",plugins[0])
         self.assertIn("versions",plugins[0])
 
-    def test_supported_plugins_version_count(self):
+    def test_supported_plugins_and_versions_count(self):
         plugins = self.pt.supported_plugins(self.one_hostname)
-        self.assertEqual(len(plugins[0]["versions"]), 8)
-
-# TODO Test PackageTree#get_environment()
-
+        self.assertEqual(len(plugins), 1)
+        self.assertEqual(plugins[0]["versions"], ["1", "2"])
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

tests/test_submit.py

@@ -4,8 +4,9 @@
 """
 
 import unittest
-from mock import patch
-from mock import MagicMock
+
+from unittest.mock import MagicMock, patch
+
 
 def get_required_args():
     return {
@@ -23,7 +24,9 @@ class InitTest(unittest.TestCase):
         self.kSubmit = Submit
         self.required_args = get_required_args()
 
-        getuser_patcher = patch("getpass.getuser", return_value="joe.bloggs@example.com")
+        getuser_patcher = patch(
+            "getpass.getuser", return_value="joe.bloggs@example.com"
+        )
         self.mock_getuser = getuser_patcher.start()
         self.addCleanup(getuser_patcher.stop)
 
@@ -65,42 +68,48 @@ class SendTest(unittest.TestCase):
         self.kSubmit = Submit
         self.required_args = get_required_args()
 
-        getuser_patcher = patch("getpass.getuser", return_value="joe.bloggs@example.com")
+        getuser_patcher = patch(
+            "getpass.getuser", return_value="joe.bloggs@example.com"
+        )
         self.mock_getuser = getuser_patcher.start()
         self.addCleanup(getuser_patcher.stop)
 
         file_utils_process_patcher = patch(
-            "ciocore.file_utils.process_upload_filepaths", 
-            return_value=[]
+            "ciocore.file_utils.process_upload_filepaths", return_value=[]
         )
         self.mock_file_utils_process = file_utils_process_patcher.start()
         self.addCleanup(file_utils_process_patcher.stop)
 
         make_request_patcher = patch(
             "ciocore.api_client.ApiClient.make_request",
-            return_value=('{}', 201),
+            return_value=("{}", 201),
         )
         self.mock_make_request = make_request_patcher.start()
         self.addCleanup(make_request_patcher.stop)
 
-
-    def test_send_calls_handle_local_upload_by_default(self):
+    def test_send_calls_handle_local_upload_by_default_when_upload_paths_present(self):
         args = self.required_args
+        args["upload_paths"] = ["/a/b"]
+
         submission = self.kSubmit(args)
         submission._handle_local_upload = MagicMock()
         submission.main()
         submission._handle_local_upload.assert_called_with({})
 
-
-    def test_send_calls_enforce_md5s_if_local_upload_off_and_enforced_md5s(self):
-        args = {"local_upload": False, "enforced_md5s": {"a":"1"}}
+    def test_send_calls_enforce_md5s_if_local_upload_off_and_enforced_md5s_when_upload_paths_present(
+        self,
+    ):
+        args = {"local_upload": False, "enforced_md5s": {"a": "1"}}
+        args["upload_paths"] = ["/a/b"]
         args.update(self.required_args)
         submission = self.kSubmit(args)
         submission._enforce_md5s = MagicMock()
         submission.main()
         submission._enforce_md5s.assert_called_with({})
 
-    def test_send_doesnt_call_enforce_md5s_if_local_upload_off_and_no_enforced_md5s(self):
+    def test_send_doesnt_call_enforce_md5s_if_local_upload_off_and_no_enforced_md5s(
+        self,
+    ):
         args = {"local_upload": False}
         args.update(self.required_args)
         submission = self.kSubmit(args)
@@ -108,14 +117,30 @@ class SendTest(unittest.TestCase):
         submission.main()
         self.assertEqual(submission._enforce_md5s.call_count, 0)
 
+    def test_send_doesnt_call_any_upload_methods_if_no_upload_paths(self):
+        args = self.required_args
+        submission = self.kSubmit(args)
+        submission._handle_local_upload = MagicMock()
+        submission._enforce_md5s = MagicMock()
+        submission.main()
+        self.assertEqual(submission._handle_local_upload.call_count, 0)
+        self.assertEqual(submission._enforce_md5s.call_count, 0)
+
+    def test_send_switches_local_upload_true_if_no_upload_paths_and_local_upload_false(
+        self,
+    ):
+        args = {"local_upload": False}
+        args.update(self.required_args)
+        submission = self.kSubmit(args)
+        self.assertEqual(submission.payload["local_upload"], True)
 
     def test_send_raise_if_bad_response_code(self):
         make_request_patcher = patch(
             "ciocore.api_client.ApiClient.make_request",
-            return_value=('{}', 404),
+            return_value=("{}", 404),
         )
         self.mock_make_request = make_request_patcher.start()
- 
+
         with self.assertRaises(Exception):
             submission = self.kSubmit(self.required_args)
             submission._handle_daemon_upload = MagicMock()
@@ -124,11 +149,12 @@ class SendTest(unittest.TestCase):
         make_request_patcher.stop()
 
 
-class uploaderTest():
+class uploaderTest:
 
     def test_smoke(self):
 
         from ciocore import uploader
+
         uploader_args = {
             "location": "here",
             "database_filepath": "/path/to/db",
@@ -137,5 +163,5 @@ class uploaderTest():
         }
         up = uploader.Uploader(uploader_args)
         manager = up.create_manager("some_project")
-        filemap = {"/a/b1": None,"/a/b2": None}
-        self.assertTrue(True)
+        filemap = {"/a/b1": None, "/a/b2": None}
+        # self.assertEqual(uploader_args["thread_count"], 4)

tests/test_uploader.py

@@ -1,10 +1,7 @@
 import unittest
 import sys
 
-try:
-    from unittest import mock
-except ImportError:
-    import mock
+from unittest import mock
 
 PY3 = sys.version_info >= (3, 0)
 BUILTIN_OPEN = "builtins.open" if PY3 else "__builtin__.open"

ciocore/__about__.py

@@ -1,10 +0,0 @@
-import os
-
-__all__ = ["__version__"]
-
-try:
-    with open(os.path.join(os.path.abspath(os.path.dirname(__file__)), 'VERSION')) as version_file:
-        __version__ = version_file.read().strip()
-        
-except IOError:
-    __version__ = 'dev'