Merge "Rename Attributes to Parameters to match Tuskar API"

tuskarclient/tests/v2/test_plans_shell.py

@@ -19,7 +19,7 @@ from tuskarclient.v2 import plans_shell
 
 def empty_args():
     args = mock.Mock(spec=[])
-    for attr in ['uuid', 'name', 'description', 'attributes']:
+    for attr in ['uuid', 'name', 'description', 'parameters']:
         setattr(args, attr, None)
     return args
 
@@ -161,13 +161,13 @@ class PlansShellTest(BasePlansShellTest):
         args.role_name = 'compute-1'
         args.count = '9'
 
-        attributes = [{'name': 'compute-1::count', 'value': '9'}]
+        parameters = [{'name': 'compute-1::count', 'value': '9'}]
 
         self.shell.do_plan_scale(self.tuskar, args, outfile=self.outfile)
         self.tuskar.plans.patch.assert_called_once()
         self.assertEqual('plan_uuid', self.tuskar.plans.patch.call_args[0][0])
         self.assertEqual(
-            sorted(attributes, key=lambda k: k['name']),
+            sorted(parameters, key=lambda k: k['name']),
             sorted(self.tuskar.plans.patch.call_args[0][1],
                    key=lambda k: k['name']))
 
@@ -184,13 +184,13 @@ class PlansShellTest(BasePlansShellTest):
         args.role_name = 'compute-1'
         args.flavor = 'baremetalssd'
 
-        attributes = [{'name': 'compute-1::Flavor', 'value': 'baremetalssd'}]
+        parameters = [{'name': 'compute-1::Flavor', 'value': 'baremetalssd'}]
 
         self.shell.do_plan_flavor(self.tuskar, args, outfile=self.outfile)
         self.tuskar.plans.patch.assert_called_once()
         self.assertEqual('plan_uuid', self.tuskar.plans.patch.call_args[0][0])
         self.assertEqual(
-            sorted(attributes, key=lambda k: k['name']),
+            sorted(parameters, key=lambda k: k['name']),
             sorted(self.tuskar.plans.patch.call_args[0][1],
                    key=lambda k: k['name']))
 
@@ -198,16 +198,36 @@ class PlansShellTest(BasePlansShellTest):
     def test_plan_patch(self, mock_print_summary):
         args = empty_args()
         args.plan_uuid = 'plan_uuid'
-        args.attributes = ['foo_name=foo_value',
+        args.parameters = ['foo_name=foo_value',
                            'bar_name=bar_value']
-        attributes = [{'name': 'foo_name', 'value': 'foo_value'},
+        args.attributes = None
+        parameters = [{'name': 'foo_name', 'value': 'foo_value'},
                       {'name': 'bar_name', 'value': 'bar_value'}]
         self.shell.do_plan_patch(self.tuskar, args, outfile=self.outfile)
         self.tuskar.plans.patch.assert_called_once()
         self.assertEqual('plan_uuid',
                          self.tuskar.plans.patch.call_args[0][0])
         self.assertEqual(
-            sorted(attributes, key=lambda k: k['name']),
+            sorted(parameters, key=lambda k: k['name']),
+            sorted(self.tuskar.plans.patch.call_args[0][1],
+                   key=lambda k: k['name']))
+
+    @mock.patch('tuskarclient.v2.plans_shell.print_plan_summary')
+    def test_plan_patch_deprecated(self, mock_print_summary):
+        """Test plan_patch with the deprecated --attribute flag."""
+        args = empty_args()
+        args.plan_uuid = 'plan_uuid'
+        args.attributes = ['foo_name=foo_value',
+                           'bar_name=bar_value']
+        args.parameters = None
+        parameters = [{'name': 'foo_name', 'value': 'foo_value'},
+                      {'name': 'bar_name', 'value': 'bar_value'}]
+        self.shell.do_plan_patch(self.tuskar, args, outfile=self.outfile)
+        self.tuskar.plans.patch.assert_called_once()
+        self.assertEqual('plan_uuid',
+                         self.tuskar.plans.patch.call_args[0][0])
+        self.assertEqual(
+            sorted(parameters, key=lambda k: k['name']),
             sorted(self.tuskar.plans.patch.call_args[0][1],
                    key=lambda k: k['name']))
 
@@ -215,16 +235,17 @@ class PlansShellTest(BasePlansShellTest):
     def test_plan_update(self, mock_print_detail):
         args = empty_args()
         args.plan_uuid = 'plan_uuid'
-        args.attributes = ['foo_name=foo_value',
+        args.parameters = ['foo_name=foo_value',
                            'bar_name=bar_value']
-        attributes = [{'name': 'foo_name', 'value': 'foo_value'},
+        parameters = [{'name': 'foo_name', 'value': 'foo_value'},
                       {'name': 'bar_name', 'value': 'bar_value'}]
+        args.attributes = None
         self.shell.do_plan_update(self.tuskar, args, outfile=self.outfile)
         self.tuskar.plans.patch.assert_called_once()
         self.assertEqual('plan_uuid',
                          self.tuskar.plans.patch.call_args[0][0])
         self.assertEqual(
-            sorted(attributes, key=lambda k: k['name']),
+            sorted(parameters, key=lambda k: k['name']),
             sorted(self.tuskar.plans.patch.call_args[0][1],
                    key=lambda k: k['name']))
 

tuskarclient/v2/plans.py

@@ -96,21 +96,21 @@ class PlanManager(base.BaseManager):
         """
         return self._post(self._path(), fields)
 
-    def patch(self, plan_uuid, attribute_list):
+    def patch(self, plan_uuid, parameter_list):
         """Patch an existing Plan.
 
         :param plan_uuid: UUID of the Plan.
         :type plan_uuid: string
 
-        :param attribute_list: a list of attribute name/value dicts
+        :param parameter_list: a list of parameter name/value dicts
              Example: [{'name': <attr_name>, 'value': <attr_value>}]
-        :type attribute_list: list
+        :type parameter_list: list
 
         :return: A Plan instance or None if its not found.
         :rtype: tuskarclient.v2.plans.Plan or None
         """
         return self._patch(self._path(plan_uuid),
-                           attribute_list)
+                           parameter_list)
 
     def delete(self, plan_uuid):
         """Delete a Plan.

tuskarclient/v2/plans_shell.py

@@ -149,13 +149,13 @@ def do_plan_scale(tuskar, args, outfile=sys.stdout):
     """Scale plan by changing count of roles."""
     roles = tuskar.roles.list()
     plan = utils.find_resource(tuskar.plans, args.plan_uuid)
-    attributes = []
+    parameters = []
 
     for role in roles:
         versioned_name = "{name}-{v}".format(name=role.name, v=role.version)
         if versioned_name == args.role_name:
             role_name_key = versioned_name + "::count"
-            attributes.append({'name': role_name_key,
+            parameters.append({'name': role_name_key,
                                'value': args.count})
             old_val = [p['value'] for p in plan.parameters
                        if p['name'] == role_name_key][0]
@@ -169,8 +169,8 @@ def do_plan_scale(tuskar, args, outfile=sys.stdout):
                       role=args.role_name, count=old_val), file=outfile)
                 return
 
-    if attributes:
+    if parameters:
-        return tuskar.plans.patch(args.plan_uuid, attributes)
+        return tuskar.plans.patch(args.plan_uuid, parameters)
     else:
         print("ERROR: no roles were found in the Plan with the name {0}".
               format(args.role_name), file=sys.stderr)
@@ -184,13 +184,13 @@ def do_plan_flavor(tuskar, args, outfile=sys.stdout):
     """Change flavor of role in the plan."""
     roles = tuskar.roles.list()
     plan = utils.find_resource(tuskar.plans, args.plan_uuid)
-    attributes = []
+    parameters = []
 
     for role in roles:
         versioned_name = "{name}-{v}".format(name=role.name, v=role.version)
         if versioned_name == args.role_name:
             role_name_key = versioned_name + "::Flavor"
-            attributes.append({'name': role_name_key,
+            parameters.append({'name': role_name_key,
                                'value': args.flavor})
             old_val = [p['value'] for p in plan.parameters
                        if p['name'] == role_name_key][0]
@@ -204,8 +204,8 @@ def do_plan_flavor(tuskar, args, outfile=sys.stdout):
                       role=args.role_name, flavor=old_val), file=outfile)
                 return
 
-    if attributes:
+    if parameters:
-        return tuskar.plans.patch(args.plan_uuid, attributes)
+        return tuskar.plans.patch(args.plan_uuid, parameters)
     else:
         print("ERROR: no roles were found in the Plan with the name {0}".
               format(args.role_name), file=sys.stderr)
@@ -213,14 +213,27 @@ def do_plan_flavor(tuskar, args, outfile=sys.stdout):
 
 @utils.arg('plan_uuid', help="UUID of the Plan to modify.")
 @utils.arg('-A', '--attribute', dest='attributes', metavar='<KEY1=VALUE1>',
+           help=('This can be specified multiple times. This argument is '
+                 'deprecated, use -P and --parameter instead.'),
+           action='append')
+@utils.arg('-P', '--parameter', dest='parameters', metavar='<KEY1=VALUE1>',
            help='This can be specified multiple times.',
            action='append')
 def do_plan_update(tuskar, args, outfile=sys.stdout):
     """Change an existing plan."""
-    attributes = [{'name': pair[0], 'value': pair[1]}
+
+    parameters = args.parameters
+
+    if args.attributes:
+        print("WARNING: The attribute flags -A and --attribute are"
+              " deprecated and will be removed in a later release."
+              " Use -P and --parameter instead.", file=sys.stderr)
+        parameters = args.attributes
+
+    parameters = [{'name': pair[0], 'value': pair[1]}
                   for pair
-                  in utils.format_attributes(args.attributes).items()]
+                  in utils.format_attributes(parameters).items()]
-    return tuskar.plans.patch(args.plan_uuid, attributes)
+    return tuskar.plans.patch(args.plan_uuid, parameters)
 
 
 @utils.arg('plan_uuid', help="UUID of the Plan to modify.")