Merge pull request softlayer#659 from sudorandom/call-api-filters-python-example

sudorandom · sudorandom · commit bbaf562fb765 · 2016-02-29T14:23:58.000-06:00
Adjusts how filters work with call-api. Adds --output-python option
diff --git a/SoftLayer/CLI/call_api.py b/SoftLayer/CLI/call_api.py
@@ -1,36 +1,66 @@
 """Call arbitrary API endpoints."""
-import json
-
 import click
 
 from SoftLayer.CLI import environment
 from SoftLayer.CLI import formatting
+from SoftLayer.CLI import helpers
+from SoftLayer import utils
+
+
+def _build_filters(_filters):
+    """Builds filters using the filter options passed into the CLI.
+
+    This only supports the equals keyword at the moment.
+    """
+    root = utils.NestedDict({})
+    for _filter in _filters:
+        # split "some.key=value" into ["some.key", "value"]
+        key, value = _filter.split('=', 1)
+
+        current = root
+        # split "some.key" into ["some", "key"]
+        parts = [part.strip() for part in key.split('.')]
 
-# pylint: disable=unused-argument
+        # Actually drill down and add the filter
+        for part in parts[:-1]:
+            current = current[part]
+        current[parts[-1]] = utils.query_filter(value.strip())
 
+    return root.to_dict()
 
-def validate_filter(ctx, param, value):
-    """Try to parse the given filter as a JSON string."""
-    try:
-        if value:
-            return json.loads(value)
-    except ValueError:
-        raise click.BadParameter('filters need to be in JSON format')
+
+def _build_python_example(args, kwargs):
+    sorted_kwargs = sorted(kwargs.items())
+
+    call_str = 'import SoftLayer\n\n'
+    call_str += 'client = SoftLayer.create_client_from_env()\n'
+    call_str += 'result = client.call('
+    arg_list = [repr(arg) for arg in args]
+    arg_list += [key + '=' + repr(value)
+                 for key, value in sorted_kwargs if value]
+    call_str += ',\n                     '.join(arg_list)
+    call_str += ')'
+
+    return call_str
 
 
 @click.command('call', short_help="Call arbitrary API endpoints.")
 @click.argument('service')
 @click.argument('method')
 @click.argument('parameters', nargs=-1)
 @click.option('--id', '_id', help="Init parameter")
-@click.option('--filter', '_filter',
-              callback=validate_filter,
-              help="Object filter in a JSON string")
+@helpers.multi_option('--filter', '-f', '_filters',
+                      help="Object filters. This should be of the form: "
+                      "'property=value' or 'nested.property=value'. Complex "
+                      "filters like betweenDate are not currently supported.")
 @click.option('--mask', help="String-based object mask")
 @click.option('--limit', type=click.INT, help="Result limit")
 @click.option('--offset', type=click.INT, help="Result offset")
+@click.option('--output-python / --no-output-python',
+              help="Show python example code instead of executing the call")
 @environment.pass_env
-def cli(env, service, method, parameters, _id, _filter, mask, limit, offset):
+def cli(env, service, method, parameters, _id, _filters, mask, limit, offset,
+        output_python=False):
     """Call arbitrary API endpoints with the given SERVICE and METHOD.
 
     \b
@@ -40,11 +70,23 @@ def cli(env, service, method, parameters, _id, _filter, mask, limit, offset):
     slcli call-api Virtual_Guest getObject --id=12345
     slcli call-api Metric_Tracking_Object getBandwidthData --id=1234 \\
         "2015-01-01 00:00:00" "2015-01-1 12:00:00" public
+    slcli call-api Account getVirtualGuests \\
+        -f 'virtualGuests.datacenter.name=dal05' \\
+        -f 'virtualGuests.maxCpu=4' \\
+        --mask=id,hostname,datacenter.name,maxCpu
     """
-    result = env.client.call(service, method, *parameters,
-                             id=_id,
-                             filter=_filter,
-                             mask=mask,
-                             limit=limit,
-                             offset=offset)
-    env.fout(formatting.iter_to_table(result))
+
+    args = [service, method] + list(parameters)
+    kwargs = {
+        'id': _id,
+        'filter': _build_filters(_filters),
+        'mask': mask,
+        'limit': limit,
+        'offset': offset,
+    }
+
+    if output_python:
+        env.out(_build_python_example(args, kwargs))
+    else:
+        result = env.client.call(*args, **kwargs)
+        env.fout(formatting.iter_to_table(result))
diff --git a/tests/CLI/modules/call_api_tests.py b/tests/CLI/modules/call_api_tests.py
@@ -4,13 +4,62 @@
 
     :license: MIT, see LICENSE for more details.
 """
+import json
+
+from SoftLayer.CLI import call_api
 from SoftLayer import testing
 
-import json
+
+class BuildFilterTests(testing.TestCase):
+
+    def test_empty(self):
+        assert call_api._build_filters([]) == {}
+
+    def test_basic(self):
+        result = call_api._build_filters(['property=value'])
+        assert result == {'property': {'operation': '_= value'}}
+
+    def test_nested(self):
+        result = call_api._build_filters(['nested.property=value'])
+        assert result == {'nested': {'property': {'operation': '_= value'}}}
+
+    def test_multi(self):
+        result = call_api._build_filters(['prop1=value1', 'prop2=prop2'])
+        assert result == {
+            'prop1': {'operation': '_= value1'},
+            'prop2': {'operation': '_= prop2'},
+        }
 
 
 class CallCliTests(testing.TestCase):
 
+    def test_python_output(self):
+        result = self.run_command(['call-api', 'Service', 'method',
+                                   '--mask=some.mask',
+                                   '--limit=20',
+                                   '--offset=40',
+                                   '--id=100',
+                                   '-f nested.property=5432',
+                                   '--output-python'])
+
+        self.assertEqual(result.exit_code, 0)
+        # NOTE(kmcdonald): Python 3 no longer inserts 'u' before unicode
+        # string literals but python 2 does. These are stripped out to make
+        # this test pass on both python versions.
+        stripped_output = result.output.replace("u'", "'")
+        self.assertIsNotNone(stripped_output, """import SoftLayer
+
+client = SoftLayer.create_client_from_env()
+result = client.call(u'Service',
+                     u'method',
+                     filter={u'nested': {u'property': {'operation': 5432}}},
+                     id=u'100',
+                     limit=20,
+                     mask=u'some.mask',
+                     offset=40)
+""")
+        self.assertEqual(self.calls(), [], "no API calls were made")
+
     def test_options(self):
         mock = self.set_mock('SoftLayer_Service', 'method')
         mock.return_value = 'test'
@@ -19,15 +68,21 @@ def test_options(self):
                                    '--mask=some.mask',
                                    '--limit=20',
                                    '--offset=40',
-                                   '--id=100'])
+                                   '--id=100',
+                                   '-f property=1234',
+                                   '-f nested.property=5432'])
 
         self.assertEqual(result.exit_code, 0)
         self.assertEqual(json.loads(result.output), 'test')
         self.assert_called_with('SoftLayer_Service', 'method',
                                 mask='mask[some.mask]',
                                 limit=20,
                                 offset=40,
-                                identifier='100')
+                                identifier='100',
+                                filter={
+                                    'property': {'operation': 1234},
+                                    'nested': {'property': {'operation': 5432}}
+                                })
 
     def test_object(self):
         mock = self.set_mock('SoftLayer_Service', 'method')
diff --git a/tests/conftest.py b/tests/conftest.py
@@ -0,0 +1,3 @@
+import logging
+
+logging.basicConfig(level=logging.DEBUG)

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+import logging`
	`2`	`+`
	`3`	`+logging.basicConfig(level=logging.DEBUG)`