supported-hardware: removed support for hardware revision

This update simplifies drastically SupportedHardwareManager removing
all complexity needed to support hardware revisions.

This change also adds support for 'any' value for supported-hardware
schema property when any hardware is supported.

Finally, tests were refactored to remove duplication.

Signed-off-by: Pablo Palácios <ppalacios992@gmail.com>

tests/cli/test_hardware.py

@@ -16,67 +16,27 @@ def setUp(self):
         self.pkg = Package(InstallationSetMode.Single)
         self.pkg.dump(self.pkg_fn)
 
-    def test_can_add_supported_hardware_without_revisions(self):
-        result = self.runner.invoke(add_supported_hardware, args=['PowerX'])
+    def test_can_add_supported_hardware_identifier(self):
+        hardware = 'PowerX'
+        result = self.runner.invoke(add_supported_hardware, args=[hardware])
         self.assertEqual(result.exit_code, 0)
         pkg = Package.from_file(self.pkg_fn)
-        hardware = pkg.hardwares.get('PowerX')
-        self.assertIsNotNone(hardware)
-        self.assertEqual(hardware['name'], 'PowerX')
-        self.assertEqual(len(hardware['revisions']), 0)
+        self.assertEqual(len(pkg.supported_hardware), 1)
+        self.assertIn(hardware, pkg.supported_hardware)
 
-    def test_can_add_supported_hardware_with_revisions(self):
-        result = self.runner.invoke(
-            add_supported_hardware,
-            args=['PowerX', '--revision', '3', '-r', '2', '-r', '1'])
-        self.assertEqual(result.exit_code, 0)
-        pkg = Package.from_file(self.pkg_fn)
-        self.assertEqual(pkg.hardwares.count(), 1)
-        hardware = pkg.hardwares.get('PowerX')
-        self.assertEqual(hardware['name'], 'PowerX')
-        self.assertEqual(hardware['revisions'], ['1', '2', '3'])
-
-    def test_can_add_supported_hardware_revision(self):
-        self.pkg.hardwares.add('PowerX', revisions=['2'])
-        self.pkg.dump(self.pkg_fn)
-        result = self.runner.invoke(
-            add_supported_hardware, args=['PowerX', '--revision', '1'])
-        self.assertEqual(result.exit_code, 0)
-        pkg = Package.from_file(self.pkg_fn)
-        self.assertEqual(pkg.hardwares.count(), 1)
-        hardware = pkg.hardwares.get('PowerX')
-        self.assertEqual(len(hardware['revisions']), 2)
-        self.assertEqual(hardware['revisions'], ['1', '2'])
-
-    def test_remove_supported_hardware_returns_2_if_hardware_is_invalid(self):
-        self.pkg.hardwares.add('PowerX', revisions=['exists'])
-        self.pkg.dump(self.pkg_fn)
-        result = self.runner.invoke(
-            remove_supported_hardware, args=['PowerX', '-r', 'no-exists'])
-        self.assertEqual(result.exit_code, 2)
-
-    def test_remove_supported_hardware_returns_2_if_revision_is_invalid(self):
-        result = self.runner.invoke(remove_supported_hardware, args=['PowerX'])
-        self.assertEqual(result.exit_code, 2)
-
-    def test_can_remove_supported_hardware(self):
-        self.pkg.hardwares.add('PowerX')
+    def test_can_remove_supported_hardware_identifier(self):
+        hardware = 'PowerX'
+        self.pkg.supported_hardware.add(hardware)
         self.pkg.dump(self.pkg_fn)
         pkg = Package.from_file(self.pkg_fn)
-        self.assertEqual(pkg.hardwares.count(), 1)
-        result = self.runner.invoke(remove_supported_hardware, args=['PowerX'])
+        self.assertEqual(len(pkg.supported_hardware), 1)
+        result = self.runner.invoke(remove_supported_hardware, args=[hardware])
         self.assertEqual(result.exit_code, 0)
         pkg = Package.from_file(self.pkg_fn)
-        self.assertEqual(pkg.hardwares.count(), 0)
+        self.assertEqual(len(pkg.supported_hardware), 0)
 
-    def test_can_remove_supported_hardware_revision(self):
-        self.pkg.hardwares.add('PowerX', revisions=['3', '2', '1'])
+    def test_remove_supported_hardware_returns_2_if_invalid_identifier(self):
+        self.pkg.supported_hardware.add('PowerX')
         self.pkg.dump(self.pkg_fn)
-        self.runner.invoke(
-            remove_supported_hardware, args=['PowerX', '-r', '2'])
-        pkg = Package.from_file(self.pkg_fn)
-        self.assertEqual(pkg.hardwares.count(), 1)
-        hardware = pkg.hardwares.get('PowerX')
-        self.assertEqual(len(hardware['revisions']), 2)
-        self.assertNotIn('2', hardware['revisions'])
-        self.assertEqual(hardware['revisions'], ['1', '3'])
+        result = self.runner.invoke(remove_supported_hardware, args=['PowerY'])
+        self.assertEqual(result.exit_code, 2)

tests/cli/test_package.py

@@ -281,7 +281,7 @@ def test_can_export_package_file(self):
         expected = {
             'product': None,
             'version': None,
-            'supported-hardware': {},
+            'supported-hardware': 'any',
             'objects': [
                 [
                     {

tests/hardware/fixtures/string_any.txt

@@ -0,0 +1 @@
+Supported hardware: any

tests/hardware/fixtures/string_some.txt

@@ -0,0 +1 @@
+Supported hardware: PowerX, PowerY, PowerZ

tests/hardware/test_manager.py

@@ -3,131 +3,128 @@
 
 import unittest
 
-from uhu.core.hardware import HardwareManager
-
-
-class HardwareManagerTestCase(unittest.TestCase):
-
-    def test_can_add_hardware(self):
-        manager = HardwareManager()
-        self.assertEqual(manager.count(), 0)
-        manager.add(name='PowerX', revisions=['PX230'])
-        self.assertEqual(manager.count(), 1)
-        hardware = manager.get('PowerX')
-        self.assertEqual(hardware['name'], 'PowerX')
-        self.assertEqual(hardware['revisions'], ['PX230'])
-
-    def test_can_remove_hardware(self):
-        manager = HardwareManager()
-        manager.add(name='PowerX')
-        manager.add(name='PowerY')
-        self.assertEqual(manager.count(), 2)
-        manager.remove('PowerX')
-        self.assertEqual(manager.count(), 1)
-        manager.remove('PowerY')
-        self.assertEqual(manager.count(), 0)
-
-    def test_remove_hardware_raises_error_if_invalid_hardware(self):
-        manager = HardwareManager()
-        with self.assertRaises(ValueError):
-            manager.remove('dosnt-exist')
-
-    def test_can_add_hardware_revision(self):
-        manager = HardwareManager()
-        manager.add(name='PowerX', revisions=['PX230'])
-        manager.add_revision('PowerX', 'PX240')
-        revisions = manager.get('PowerX')['revisions']
-        self.assertEqual(revisions, ['PX230', 'PX240'])
-
-    def test_add_hardware_revision_raises_error_if_invalid_hardware(self):
-        manager = HardwareManager()
-        with self.assertRaises(ValueError):
-            manager.add_revision('dosnt-exist', 'revision')
-
-    def test_can_remove_hardware_revision(self):
-        manager = HardwareManager()
-        manager.add(name='PowerX', revisions=['PX240'])
-        self.assertEqual(len(manager.get('PowerX')['revisions']), 1)
-        manager.remove_revision('PowerX', 'PX240')
-        self.assertEqual(len(manager.get('PowerX')['revisions']), 0)
-
-    def test_remove_hardware_revision_raises_error_if_invalid_hardware(self):
-        manager = HardwareManager()
-        with self.assertRaises(ValueError):
-            manager.remove_revision('bad-hardware', 'revision')
-
-    def test_remove_hardware_revision_raises_error_if_invalid_revision(self):
-        manager = HardwareManager()
+from uhu.core.hardware import (
+    SupportedHardwareManager, ANY, SUPPORTED_HARDWARE_ERROR)
+
+
+class SupportedHardwareConstructors(unittest.TestCase):
+
+    def test_can_construct_from_file_dump_when_any(self):
+        manager = SupportedHardwareManager.from_file({
+            'supported-hardware': ANY,
+        })
+        self.assertEqual(len(manager), 0)
+
+    def test_can_construct_from_file_dump_when_some(self):
+        manager = SupportedHardwareManager.from_file({
+            'supported-hardware': ['h1', 'h2'],
+        })
+        self.assertEqual(len(manager), 2)
+        self.assertIn('h1', manager)
+        self.assertIn('h2', manager)
+
+    def test_construct_from_file_raises_error_when_invalid(self):
+        invalid_values = [{}, {'supported-hardware': None}]
+        for value in invalid_values:
+            with self.assertRaises(ValueError, msg=SUPPORTED_HARDWARE_ERROR):
+                SupportedHardwareManager.from_file(value)
+
+    def test_can_construct_from_metadata_dump_when_any(self):
+        manager = SupportedHardwareManager.from_metadata({
+            'supported-hardware': ANY,
+        })
+        self.assertEqual(len(manager), 0)
+
+    def test_can_construct_from_metadata_dump_when_some(self):
+        manager = SupportedHardwareManager.from_metadata({
+            'supported-hardware': ['h1', 'h2'],
+        })
+        self.assertEqual(len(manager), 2)
+        self.assertIn('h1', manager)
+        self.assertIn('h2', manager)
+
+    def test_construct_from_metadata_raises_error_when_invalid(self):
+        invalid_values = [{}, {'supported-hardware': None}]
+        for value in invalid_values:
+            with self.assertRaises(ValueError, msg=SUPPORTED_HARDWARE_ERROR):
+                SupportedHardwareManager.from_metadata(value)
+
+
+class SupportedHardwareSerialization(unittest.TestCase):
+
+    def test_can_serialize_as_template_when_some(self):
+        manager = SupportedHardwareManager()
+        manager.add('PowerX')
+        expected = {'supported-hardware': ['PowerX']}
+        observed = manager.to_template()
+        self.assertEqual(expected, observed)
+
+    def test_can_serialize_as_template_when_any(self):
+        manager = SupportedHardwareManager()
+        expected = {'supported-hardware': 'any'}
+        observed = manager.to_template()
+        self.assertEqual(expected, observed)
+
+    def test_can_serialize_as_metadata_when_some(self):
+        manager = SupportedHardwareManager()
+        manager.add('PowerZ')
+        manager.add('PowerY')
         manager.add('PowerX')
-        with self.assertRaises(ValueError):
-            manager.remove_revision('PowerX', 'bad-revision')
-
-    def test_hardware_revisions_are_alphanumeric_sorted(self):
-        manager = HardwareManager()
-        manager.add(name='PowerX', revisions=['PX240'])
-        manager.add_revision('PowerX', 'PX250')
-        manager.add_revision('PowerX', 'PX230')
-        expected = ['PX230', 'PX240', 'PX250']
-        observed = manager.get('PowerX')['revisions']
+        expected = {'supported-hardware': ['PowerX', 'PowerY', 'PowerZ']}
+        observed = manager.to_metadata()
         self.assertEqual(observed, expected)
 
-    def test_entries_are_not_duplicated_when_adding_same_hardware_twice(self):
-        manager = HardwareManager()
-        manager.add(name='PowerX', revisions=['PX230'])
-        manager.add(name='PowerX', revisions=['PX230'])
-        self.assertEqual(manager.count(), 1)
-        self.assertEqual(len(manager.get('PowerX')['revisions']), 1)
-
-    def test_can_serialize_manager_as_template(self):
-        manager = HardwareManager()
-        manager.add(name='PowerX', revisions=['PX230'])
-        template = manager.template()
-        self.assertEqual(len(template), 1)
-        self.assertEqual(template['PowerX']['name'], 'PowerX')
-        self.assertEqual(template['PowerX']['revisions'], ['PX230'])
-
-    def test_can_serialize_as_metadata(self):
-        manager = HardwareManager()
-        manager.add(name='PowerX')
-        manager.add(name='PowerY', revisions=['PY250', 'PY240', 'PY230'])
-        manager.add(name='PowerZ', revisions=['PZ230'])
-        expected = [
-            {
-                'hardware': 'PowerX'
-            },
-            {
-                'hardware': 'PowerY',
-                'hardware-rev': 'PY230'
-            },
-            {
-                'hardware': 'PowerY',
-                'hardware-rev': 'PY240'
-            },
-            {
-                'hardware': 'PowerY',
-                'hardware-rev': 'PY250'
-            },
-            {
-                'hardware': 'PowerZ',
-                'hardware-rev': 'PZ230'
-            },
-        ]
-        observed = manager.metadata()
+    def test_can_serialize_as_metadata_when_any(self):
+        manager = SupportedHardwareManager()
+        expected = {'supported-hardware': 'any'}
+        observed = manager.to_metadata()
         self.assertEqual(observed, expected)
 
-    def test_can_serialize_manager_as_string(self):
-        manager = HardwareManager()
-        manager.add(name='PowerX')
-        manager.add(name='PowerY', revisions=['PY230'])
-        manager.add(name='PowerZ', revisions=['PZ250', 'PZ240', 'PZ230'])
-        with open('tests/fixtures/hardware/manager.txt') as fp:
-            expected = fp.read()
+    def test_can_serialize_manager_as_string_when_some(self):
+        manager = SupportedHardwareManager()
+        manager.add('PowerX')
+        manager.add('PowerY')
+        manager.add('PowerZ')
+        with open('tests/hardware/fixtures/string_some.txt') as fp:
+            expected = fp.read().strip()
         observed = str(manager)
         self.assertEqual(observed, expected)
 
-    def test_can_serialize_empty_manager_as_string(self):
-        manager = HardwareManager()
-        with open('tests/fixtures/hardware/manager_empty.txt') as fp:
+    def test_can_serialize_manager_as_string_when_any(self):
+        manager = SupportedHardwareManager()
+        with open('tests/hardware/fixtures/string_any.txt') as fp:
             expected = fp.read().strip()
         observed = str(manager)
         self.assertEqual(observed, expected)
+
+
+class SupportedHardwareManagement(unittest.TestCase):
+
+    def test_can_add_hardware_identifier(self):
+        manager = SupportedHardwareManager()
+        hardware = 'PowerX'
+        self.assertEqual(len(manager), 0)
+        manager.add(hardware)
+        self.assertEqual(len(manager), 1)
+        self.assertIn(hardware, manager)
+
+    def test_cant_add_same_hardware_identifier_twice(self):
+        manager = SupportedHardwareManager()
+        manager.add('PowerX')
+        manager.add('PowerX')
+        self.assertEqual(len(manager), 1)
+
+    def test_can_remove_hardware_identifier(self):
+        manager = SupportedHardwareManager()
+        manager.add('PowerX')
+        manager.add('PowerY')
+        self.assertEqual(len(manager), 2)
+        manager.remove('PowerX')
+        self.assertEqual(len(manager), 1)
+        manager.remove('PowerY')
+        self.assertEqual(len(manager), 0)
+
+    def test_cant_remove_unknown_hardware_identifier(self):
+        manager = SupportedHardwareManager()
+        with self.assertRaises(KeyError):
+            manager.remove('unknown-hardware')

tests/modes/base.py

@@ -122,6 +122,7 @@ def test_can_load_from_metadata(self):
         metadata = {
             'product': None,
             'version': None,
+            'supported-hardware': 'any',
             'objects': [objects_metadata]
         }
         pkg = Package.from_metadata(metadata)

tests/package/__init__.py

@@ -13,13 +13,7 @@ def setUp(self):
         self.version = '2.0'
         self.product = '1234'
         self.hardware = 'PowerX'
-        self.hardware_revision = ['PX230']
-        self.supported_hardware = {
-            self.hardware: {
-                'name': self.hardware,
-                'revisions': self.hardware_revision,
-            }
-        }
+        self.supported_hardware = [self.hardware]
         self.pkg_uid = 'pkg-uid'
         self.obj_content = b'spam'
         self.obj_fn = self.create_file(self.obj_content)

tests/fixtures/package/package_empty.txt → tests/package/fixtures/package_empty.txt

@@ -1,4 +1,4 @@
 Product: None
 Version: None
-Supported hardware: all
+Supported hardware: any
 Objects: None

tests/fixtures/package/package_full.txt → tests/package/fixtures/package_full.txt

@@ -1,6 +1,6 @@
 Product: e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
 Version: 2.0
-Supported hardware: all
+Supported hardware: any
 Objects:
 
     0# Installation Set: