Merge branch 'master' into fo_vs_create_flavor_test

Author: allmightyspiff

SoftLayer/CLI/order/package_list.py

@@ -7,7 +7,8 @@
 from SoftLayer.CLI import formatting
 from SoftLayer.managers import ordering
 
-COLUMNS = ['name',
+COLUMNS = ['id',
+           'name',
            'keyName',
            'type']
 
@@ -51,6 +52,7 @@ def cli(env, keyword, package_type):
 
     for package in packages:
         table.add_row([
+            package['id'],
             package['name'],
             package['keyName'],
             package['type']['keyName']

SoftLayer/CLI/virt/upgrade.py

@@ -21,15 +21,17 @@
               help="CPU core will be on a dedicated host server.")
 @click.option('--memory', type=virt.MEM_TYPE, help="Memory in megabytes")
 @click.option('--network', type=click.INT, help="Network port speed in Mbps")
+@click.option('--flavor', type=click.STRING, help="Flavor keyName\n"
+                                                  "Do not use --memory, --cpu or --private, if you are using flavors")
 @environment.pass_env
-def cli(env, identifier, cpu, private, memory, network):
+def cli(env, identifier, cpu, private, memory, network, flavor):
     """Upgrade a virtual server."""
 
     vsi = SoftLayer.VSManager(env.client)
 
-    if not any([cpu, memory, network]):
+    if not any([cpu, memory, network, flavor]):
         raise exceptions.ArgumentError(
-            "Must provide [--cpu], [--memory], or [--network] to upgrade")
+            "Must provide [--cpu], [--memory], [--network], or [--flavor] to upgrade")
 
     if private and not cpu:
         raise exceptions.ArgumentError(
@@ -48,5 +50,6 @@ def cli(env, identifier, cpu, private, memory, network):
                        cpus=cpu,
                        memory=memory,
                        nic_speed=network,
-                       public=not private):
+                       public=not private,
+                       preset=flavor):
         raise exceptions.CLIAbort('VS Upgrade Failed')

SoftLayer/fixtures/SoftLayer_Product_Package.py

@@ -1514,3 +1514,31 @@
         }
     }
 ]
+getActivePresets = [
+    {
+        "description": "M1.64x512x25",
+        "id": 799,
+        "isActive": "1",
+        "keyName": "M1_64X512X25",
+        "name": "M1.64x512x25",
+        "packageId": 835
+    },
+    {
+        "description": "M1.56x448x100",
+        "id": 797,
+        "isActive": "1",
+        "keyName": "M1_56X448X100",
+        "name": "M1.56x448x100",
+        "packageId": 835
+    },
+    {
+        "description": "M1.64x512x100",
+        "id": 801,
+        "isActive": "1",
+        "keyName": "M1_64X512X100",
+        "name": "M1.64x512x100",
+        "packageId": 835
+    }
+]
+
+getAccountRestrictedActivePresets = []

SoftLayer/fixtures/SoftLayer_Virtual_Guest.py

@@ -14,6 +14,10 @@
             {'nextInvoiceTotalRecurringAmount': 1},
             {'nextInvoiceTotalRecurringAmount': 1},
         ],
+        'package': {
+            "id": 835,
+            "keyName": "PUBLIC_CLOUD_SERVER"
+        },
         'orderItem': {
             'order': {
                 'userRecord': {

SoftLayer/managers/ticket.py

@@ -40,7 +40,7 @@ def list_tickets(self, open_status=True, closed_status=True):
             else:
                 raise ValueError("open_status and closed_status cannot both be False")
 
-        return self.client.call('Account', call, mask=mask)
+        return self.client.call('Account', call, mask=mask, iter=True)
 
     def list_subjects(self):
         """List all ticket subjects."""

SoftLayer/managers/vs.py

@@ -51,6 +51,7 @@ def __init__(self, client, ordering_manager=None):
         self.client = client
         self.account = client['Account']
         self.guest = client['Virtual_Guest']
+        self.package_svc = client['Product_Package']
         self.resolvers = [self._get_ids_from_ip, self._get_ids_from_hostname]
         if ordering_manager is None:
             self.ordering_manager = ordering.OrderingManager(client)
@@ -209,6 +210,7 @@ def get_instance(self, instance_id, **kwargs):
                 'maxMemory,'
                 'datacenter,'
                 'activeTransaction[id, transactionStatus[friendlyName,name]],'
+                'lastTransaction[transactionStatus],'
                 'lastOperatingSystemReload.id,'
                 'blockDevices,'
                 'blockDeviceTemplateGroup[id, name, globalIdentifier],'
@@ -225,6 +227,7 @@ def get_instance(self, instance_id, **kwargs):
                 'hourlyBillingFlag,'
                 'userData,'
                 '''billingItem[id,nextInvoiceTotalRecurringAmount,
+                               package[id,keyName],
                                children[categoryCode,nextInvoiceTotalRecurringAmount],
                                orderItem[id,
                                          order.userRecord[username],
@@ -803,7 +806,7 @@ def capture(self, instance_id, name, additional_disks=False, notes=None):
             name, disks_to_capture, notes, id=instance_id)
 
     def upgrade(self, instance_id, cpus=None, memory=None,
-                nic_speed=None, public=True):
+                nic_speed=None, public=True, preset=None):
         """Upgrades a VS instance.
 
         Example::
@@ -817,6 +820,7 @@ def upgrade(self, instance_id, cpus=None, memory=None,
         :param int instance_id: Instance id of the VS to be upgraded
         :param int cpus: The number of virtual CPUs to upgrade to
                             of a VS instance.
+        :param string preset: preset assigned to the vsi
         :param int memory: RAM of the VS to be upgraded to.
         :param int nic_speed: The port speed to set
         :param bool public: CPU will be in Private/Public Node.
@@ -826,9 +830,28 @@ def upgrade(self, instance_id, cpus=None, memory=None,
         upgrade_prices = self._get_upgrade_prices(instance_id)
         prices = []
 
-        for option, value in {'cpus': cpus,
-                              'memory': memory,
-                              'nic_speed': nic_speed}.items():
+        data = {'nic_speed': nic_speed}
+
+        if cpus is not None and preset is not None:
+            raise exceptions.SoftLayerError("Do not use cpu, private and memory if you are using flavors")
+        data['cpus'] = cpus
+
+        if memory is not None and preset is not None:
+            raise exceptions.SoftLayerError("Do not use memory, private or cpu if you are using flavors")
+        data['memory'] = memory
+
+        maintenance_window = datetime.datetime.now(utils.UTC())
+        order = {
+            'complexType': 'SoftLayer_Container_Product_Order_Virtual_Guest_'
+                           'Upgrade',
+            'properties': [{
+                'name': 'MAINTENANCE_WINDOW',
+                'value': maintenance_window.strftime("%Y-%m-%d %H:%M:%S%z")
+            }],
+            'virtualGuests': [{'id': int(instance_id)}],
+        }
+
+        for option, value in data.items():
             if not value:
                 continue
             price_id = self._get_price_id_for_upgrade_option(upgrade_prices,
@@ -841,19 +864,13 @@ def upgrade(self, instance_id, cpus=None, memory=None,
                     "Unable to find %s option with value %s" % (option, value))
 
             prices.append({'id': price_id})
+        order['prices'] = prices
 
-        maintenance_window = datetime.datetime.now(utils.UTC())
-        order = {
-            'complexType': 'SoftLayer_Container_Product_Order_Virtual_Guest_'
-                           'Upgrade',
-            'prices': prices,
-            'properties': [{
-                'name': 'MAINTENANCE_WINDOW',
-                'value': maintenance_window.strftime("%Y-%m-%d %H:%M:%S%z")
-            }],
-            'virtualGuests': [{'id': int(instance_id)}],
-        }
-        if prices:
+        if preset is not None:
+            vs_object = self.get_instance(instance_id)['billingItem']['package']
+            order['presetId'] = self.ordering_manager.get_preset_by_key(vs_object['keyName'], preset)['id']
+
+        if prices or preset:
             self.client['Product_Order'].placeOrder(order)
             return True
         return False

setup.cfg

@@ -1,5 +1,8 @@
 [tool:pytest]
 python_files = *_tests.py
+filterwarnings =
+    ignore::DeprecationWarning
+    ignore::PendingDeprecationWarning
 
 [wheel]
 universal=1

tests/CLI/modules/order_tests.py

@@ -47,50 +47,43 @@ def test_item_list(self):
         self.assertEqual(expected_results, json.loads(result.output))
 
     def test_package_list(self):
-        item1 = {'name': 'package1', 'keyName': 'PACKAGE1', 'type': {'keyName': 'BARE_METAL_CPU'}, 'isActive': 1}
-        item2 = {'name': 'package2', 'keyName': 'PACKAGE2', 'type': {'keyName': 'BARE_METAL_CPU'}, 'isActive': 1}
-        item3 = {'name': 'package2', 'keyName': 'PACKAGE2', 'type': {'keyName': 'BARE_METAL_CPU'}, 'isActive': 0}
         p_mock = self.set_mock('SoftLayer_Product_Package', 'getAllObjects')
-        p_mock.return_value = [item1, item2, item3]
+        p_mock.return_value = _get_all_packages()
         _filter = {'type': {'keyName': {'operation': '!= BLUEMIX_SERVICE'}}}
 
         result = self.run_command(['order', 'package-list'])
 
         self.assert_no_fail(result)
         self.assert_called_with('SoftLayer_Product_Package', 'getAllObjects', filter=_filter)
-        expected_results = [{'name': 'package1', 'keyName': 'PACKAGE1', 'type': 'BARE_METAL_CPU'},
-                            {'name': 'package2', 'keyName': 'PACKAGE2', 'type': 'BARE_METAL_CPU'}]
+        expected_results = [{'id': 1, 'name': 'package1', 'keyName': 'PACKAGE1', 'type': 'BARE_METAL_CPU'},
+                            {'id': 2, 'name': 'package2', 'keyName': 'PACKAGE2', 'type': 'BARE_METAL_CPU'}]
         self.assertEqual(expected_results, json.loads(result.output))
 
     def test_package_list_keyword(self):
-        item1 = {'name': 'package1', 'keyName': 'PACKAGE1', 'type': {'keyName': 'BARE_METAL_CPU'}, 'isActive': 1}
-        item2 = {'name': 'package2', 'keyName': 'PACKAGE2', 'type': {'keyName': 'BARE_METAL_CPU'}, 'isActive': 1}
         p_mock = self.set_mock('SoftLayer_Product_Package', 'getAllObjects')
-        p_mock.return_value = [item1, item2]
+        p_mock.return_value = _get_all_packages()
 
         _filter = {'type': {'keyName': {'operation': '!= BLUEMIX_SERVICE'}}}
         _filter['name'] = {'operation': '*= package1'}
         result = self.run_command(['order', 'package-list', '--keyword', 'package1'])
 
         self.assert_no_fail(result)
         self.assert_called_with('SoftLayer_Product_Package', 'getAllObjects', filter=_filter)
-        expected_results = [{'name': 'package1', 'keyName': 'PACKAGE1', 'type': 'BARE_METAL_CPU'},
-                            {'name': 'package2', 'keyName': 'PACKAGE2', 'type': 'BARE_METAL_CPU'}]
+        expected_results = [{'id': 1, 'name': 'package1', 'keyName': 'PACKAGE1', 'type': 'BARE_METAL_CPU'},
+                            {'id': 2, 'name': 'package2', 'keyName': 'PACKAGE2', 'type': 'BARE_METAL_CPU'}]
         self.assertEqual(expected_results, json.loads(result.output))
 
     def test_package_list_type(self):
-        item1 = {'name': 'package1', 'keyName': 'PACKAGE1', 'type': {'keyName': 'BARE_METAL_CPU'}, 'isActive': 1}
-        item2 = {'name': 'package2', 'keyName': 'PACKAGE2', 'type': {'keyName': 'BARE_METAL_CPU'}, 'isActive': 1}
         p_mock = self.set_mock('SoftLayer_Product_Package', 'getAllObjects')
-        p_mock.return_value = [item1, item2]
+        p_mock.return_value = _get_all_packages()
 
         _filter = {'type': {'keyName': {'operation': 'BARE_METAL_CPU'}}}
         result = self.run_command(['order', 'package-list', '--package_type', 'BARE_METAL_CPU'])
 
         self.assert_no_fail(result)
         self.assert_called_with('SoftLayer_Product_Package', 'getAllObjects', filter=_filter)
-        expected_results = [{'name': 'package1', 'keyName': 'PACKAGE1', 'type': 'BARE_METAL_CPU'},
-                            {'name': 'package2', 'keyName': 'PACKAGE2', 'type': 'BARE_METAL_CPU'}]
+        expected_results = [{'id': 1, 'name': 'package1', 'keyName': 'PACKAGE1', 'type': 'BARE_METAL_CPU'},
+                            {'id': 2, 'name': 'package2', 'keyName': 'PACKAGE2', 'type': 'BARE_METAL_CPU'}]
         self.assertEqual(expected_results, json.loads(result.output))
 
     def test_place(self):
@@ -256,3 +249,13 @@ def _get_verified_order_return(self):
         price2 = {'item': item2, 'hourlyRecurringFee': '0.05',
                   'recurringFee': '150'}
         return {'orderContainers': [{'prices': [price1, price2]}]}
+
+
+def _get_all_packages():
+    package_type = {'keyName': 'BARE_METAL_CPU'}
+    all_packages = [
+        {'id': 1, 'name': 'package1', 'keyName': 'PACKAGE1', 'type': package_type, 'isActive': 1},
+        {'id': 2, 'name': 'package2', 'keyName': 'PACKAGE2', 'type': package_type, 'isActive': 1},
+        {'id': 3, 'name': 'package2', 'keyName': 'PACKAGE2', 'type': package_type, 'isActive': 0}
+    ]
+    return all_packages

tests/CLI/modules/vs_tests.py

@@ -912,6 +912,23 @@ def test_upgrade(self, confirm_mock):
         self.assertIn({'id': 1122}, order_container['prices'])
         self.assertEqual(order_container['virtualGuests'], [{'id': 100}])
 
+    @mock.patch('SoftLayer.CLI.formatting.confirm')
+    def test_upgrade_with_flavor(self, confirm_mock):
+        confirm_mock.return_value = True
+        result = self.run_command(['vs', 'upgrade', '100', '--flavor=M1_64X512X100'])
+        self.assert_no_fail(result)
+        self.assert_called_with('SoftLayer_Product_Order', 'placeOrder')
+        call = self.calls('SoftLayer_Product_Order', 'placeOrder')[0]
+        order_container = call.args[0]
+        self.assertEqual(799, order_container['presetId'])
+        self.assertIn({'id': 100}, order_container['virtualGuests'])
+        self.assertEqual(order_container['virtualGuests'], [{'id': 100}])
+
+    def test_upgrade_with_cpu_memory_and_flavor(self):
+        result = self.run_command(['vs', 'upgrade', '100', '--cpu=4',
+                                   '--memory=1024', '--flavor=M1_64X512X100'])
+        self.assertEqual("Do not use cpu, private and memory if you are using flavors", str(result.exception))
+
     def test_edit(self):
         result = self.run_command(['vs', 'edit',
                                    '--domain=example.com',

tests/managers/vs_tests.py

@@ -879,6 +879,22 @@ def test_upgrade_full(self):
         self.assertIn({'id': 1122}, order_container['prices'])
         self.assertEqual(order_container['virtualGuests'], [{'id': 1}])
 
+    def test_upgrade_with_flavor(self):
+        # Testing Upgrade with parameter preset
+        result = self.vs.upgrade(1,
+                                 preset="M1_64X512X100",
+                                 nic_speed=1000,
+                                 public=True)
+
+        self.assertEqual(result, True)
+        self.assert_called_with('SoftLayer_Product_Order', 'placeOrder')
+        call = self.calls('SoftLayer_Product_Order', 'placeOrder')[0]
+        order_container = call.args[0]
+        self.assertEqual(799, order_container['presetId'])
+        self.assertIn({'id': 1}, order_container['virtualGuests'])
+        self.assertIn({'id': 1122}, order_container['prices'])
+        self.assertEqual(order_container['virtualGuests'], [{'id': 1}])
+
     def test_upgrade_dedicated_host_instance(self):
         mock = self.set_mock('SoftLayer_Virtual_Guest', 'getUpgradeItemPrices')
         mock.return_value = fixtures.SoftLayer_Virtual_Guest.DEDICATED_GET_UPGRADE_ITEM_PRICES