Merge lp:~soren/surveilr/extend-client into lp:surveilr

[Soren Hansen]

Extend client to deal with Services and Metrics, and expose get() and delete() methods.

=== modified file 'surveilr/admin.py'
--- surveilr/admin.py	2012-01-28 21:09:53 +0000
+++ surveilr/admin.py	2012-01-29 23:36:23 +0000
@@ -96,14 +96,63 @@
         print '--user %s --api_key %s' % (user.user_id, user.key)
 
 
+class ShowUser(Command):
+    def __call__(self):
+        user = self.client.get_user(self.args[0])
+
+        print 'User:'
+        print 'ID:', user.user_id
+        print 'Admin:', user.admin
+
+
+class DeleteUser(Command):
+    def __call__(self):
+        self.client.delete_user(self.args[0])
+        print 'User deleted'
+
+
+class ShowService(Command):
+    def __call__(self):
+        service = self.client.get_service(self.args[0])
+
+        print 'Service:'
+        print 'ID:', service.id
+        print 'Name:', service.name
+        print 'Plugins:', service.plugins
+
+
+class DeleteService(Command):
+    def __call__(self):
+        self.client.delete_service(self.args[0])
+        print 'Service deleted'
+
+
+class CreateService(Command):
+    def get_optparser(self):
+        optparser = super(CreateService, self).get_optparser()
+        optparser.add_option('-p', action='append', dest='plugins',
+                             help='Make the new user an admin')
+        return optparser
+
+    def __call__(self):
+        service = self.client.new_service(self.args[0],
+                                          self.options.plugins)
+        print 'Service:'
+        print 'ID:', service.id
+
+
+def usage():
+    for cmd_name in commands:
+        cmd = commands[cmd_name]()
+        print cmd.optparser.get_usage().strip()
+
+
 def main(argv=None):
     if argv is None:  # pragma: nocover
         argv = sys.argv[1:]
 
     if not len(argv):
-        for cmd_name in commands:
-            cmd = commands[cmd_name]()
-            print cmd.optparser.get_usage().strip()
+        usage()
         return False
 
     if argv[0] in commands:
@@ -114,6 +163,9 @@
         except surveilr.api.client.UnauthorizedError:
             print 'Action not permitted'
             return False
+    else:
+        usage()
+        return False
 
 
 if __name__ == '__main__':  # pragma: nocover
 
=== modified file 'surveilr/api/client.py'
--- surveilr/api/client.py	2012-01-28 21:09:53 +0000
+++ surveilr/api/client.py	2012-01-29 23:36:23 +0000
@@ -34,8 +34,22 @@
         self.auth = auth
 
     def new_user(self, *args, **kwargs):
-        user = User.new(self, *args, **kwargs)
-        return user
+        return User.new(self, *args, **kwargs)
+
+    def get_user(self, *args, **kwargs):
+        return User.get(self, *args, **kwargs)
+
+    def delete_user(self, *args, **kwargs):
+        return User.delete(self, *args, **kwargs)
+
+    def new_service(self, *args, **kwargs):
+        return Service.new(self, *args, **kwargs)
+
+    def get_service(self, *args, **kwargs):
+        return Service.get(self, *args, **kwargs)
+
+    def delete_service(self, *args, **kwargs):
+        return Service.delete(self, *args, **kwargs)
 
     def send_req(self, url_tail, method, body):
         http = httplib2.Http()
@@ -49,13 +63,6 @@
             raise UnauthorizedError(resp.reason)
         return contents
 
-    def req(self, obj_type, action, data):
-        if action == 'create':
-            method = 'POST'
-            url_tail = '/%ss' % (obj_type.url_part)
-
-        return self.send_req(url_tail, method=method, body=json.dumps(data))
-
 
 class SurveilrDirectClient(SurveilrClient):
     def __init__(self, *args, **kwargs):
@@ -73,27 +80,104 @@
 
 
 class APIObject(object):
-    def __init__(self, client):
+    keys = []
+
+    def __init__(self, client, **kwargs):
         self.client = client
-
-    def req(self, action, data):
-        return self.client.req(type(self), action, data)
+        for key in self.keys:
+            setattr(self, key, kwargs[key])
+
+    @classmethod
+    def req(cls, client, action, data, parent=None):
+        if action == 'create':
+            kwargs = {'method': 'POST', 'body': json.dumps(data)}
+            url_tail = '/%ss' % (cls.url_part)
+        elif action == 'get':
+            kwargs = {'method': 'GET'}
+            url_tail = '/%ss/%s' % (cls.url_part, data)
+        elif action == 'delete':
+            kwargs = {'method': 'DELETE'}
+            url_tail = '/%ss/%s' % (cls.url_part, data)
+
+        if parent is not None:
+            url_tail = parent.instance_url_tail() + url_tail
+
+        return client.send_req(url_tail, **kwargs)
+
+    def instance_url_tail(self):
+        return '/%ss/%s' % (self.url_part, self.id)
+
+    @classmethod
+    def delete(cls, client, id):
+        return cls.req(client, 'delete', id)
+
+    @classmethod
+    def get(cls, client, id):
+        return cls.json_deserialise(client, cls.req(client, 'get', id))
+
+    def __repr__(self):
+        return ('<%s object%s>' %
+                (self.__class__.__name__,
+                 ''.join([', %s=%r' %
+                         (key, getattr(self, key)) for key in self.keys])))
 
 
 class User(APIObject):
     url_part = 'user'
+    keys = ['id', 'key', 'admin']
 
-    def __init__(self, client, obj_data=None):
-        self.client = client
-        obj_data = json.loads(obj_data)
-        self.user_id = obj_data['id']
-        self.key = obj_data['key']
-        self.admin = obj_data['admin']
+    @classmethod
+    def json_deserialise(cls, client, s):
+        d = json.loads(s)
+        return cls(client, id=d.get('id'),
+                           key=d.get('key'),
+                           admin=d.get('admin', False))
 
     @classmethod
     def new(cls, client, admin=False):
-        return cls(client, client.req(cls, 'create', {'admin': admin}))
-
-    def __repr__(self):
-        return ('<User object, user_id=%r, key=%r, admin=%r>' %
-                (self.user_id, self.key, self.admin))
+        return cls.json_deserialise(client,
+                                    cls.req(client,
+                                            'create',
+                                            {'admin': admin}))
+
+
+class Service(APIObject):
+    url_part = 'service'
+    keys = ['id', 'name', 'plugins']
+
+    @classmethod
+    def json_deserialise(cls, client, s):
+        d = json.loads(s)
+        return cls(client, id=d.get('id'),
+                           name=d.get('name'),
+                           plugins=d.get('plugins', []))
+
+    @classmethod
+    def new(cls, client, name, plugins=None):
+        return cls.json_deserialise(client,
+                                    cls.req(client, 'create',
+                                            {'name': name,
+                                             'plugins': plugins}))
+
+    def new_metric(self, *args, **kwargs):
+        return Metric.new(self.client, self, *args, **kwargs)
+
+
+class Metric(APIObject):
+    url_part = 'metric'
+    keys = ['id', 'service', 'timestamp', 'metrics']
+
+    @classmethod
+    def json_deserialise(cls, client, s):
+        d = json.loads(s)
+        return cls(client, id=d.get('id'),
+                           service=d.get('service'),
+                           timestamp=d.get('timestamp'),
+                           metrics=d.get('metrics'))
+
+    @classmethod
+    def new(cls, client, service, metrics):
+        return cls.json_deserialise(client,
+                                    cls.req(client, 'create',
+                                            {'metrics': metrics},
+                                             parent=service))
 
=== modified file 'surveilr/tests/api/test_client.py'
--- surveilr/tests/api/test_client.py	2012-01-28 21:09:53 +0000
+++ surveilr/tests/api/test_client.py	2012-01-29 23:36:23 +0000
@@ -5,7 +5,7 @@
 from surveilr.api import client
 
 
-class APIClientTests(tests.TestCase):
+class SurveilrClientTests(tests.TestCase):
     test_url = 'http://somewhere:1234/else'
     test_auth = ('foo', 'bar')
 
@@ -16,19 +16,31 @@
             auth = self.test_auth
         return client.SurveilrClient(self.test_url, self.test_auth)
 
-    @mock.patch('surveilr.api.client.User')
-    def test_new_user(self, User):
-        test_args = ('foo', 'bar', 'baz')
-        test_kwargs = {'foo': 'bar',
-                       'baz': 'wibble'}
-
-        api_client = self._get_client()
-        user = api_client.new_user(*test_args, **test_kwargs)
-        User.new.assert_called_with(api_client, *test_args, **test_kwargs)
-        self.assertEquals(user, User.new.return_value)
+    def test_client_class_actions(self):
+        """client.{new,get,delete}_{user,service} proxied to class methods"""
+
+        for op in ['delete', 'new', 'get']:
+            for t in ['User', 'Service']:
+                @mock.patch('surveilr.api.client.%s' % t)
+                def test_action(cls):
+                    test_args = ('foo', 'bar', 'baz')
+                    test_kwargs = {'foo': 'bar',
+                                   'baz': 'wibble'}
+                    api_client = self._get_client()
+                    client_obj_func = getattr(api_client,
+                                              '%s_%s' % (op, t.lower()))
+
+                    user = client_obj_func(*test_args, **test_kwargs)
+
+                    cls_func = getattr(cls, op)
+                    cls_func.assert_called_with(api_client, *test_args,
+                                                **test_kwargs)
+                    self.assertEquals(user, cls_func.return_value)
+                test_action()
 
     @mock.patch('surveilr.api.client.httplib2')
     def test_send_req(self, httplib2):
+        # Setup
         api_client = self._get_client()
 
         class FakeResponse(object):
@@ -37,16 +49,24 @@
 
         http = httplib2.Http.return_value
         http.request.return_value = (FakeResponse(200), 'resp')
+
+        # Exercise
         client_response = api_client.send_req('tail', 'METHOD', 'body')
+
+        # Verify that the credentials are passed
         http.add_credentials.assert_called_with(*self.test_auth)
+        # Verify that the given method is used, the body is passed correctly,
+        # and that the url is constructed correctlyi
         http.request.assert_called_with(self.test_url + '/tail',
                                         method='METHOD',
                                         body='body')
 
+        # Verify that the response comes back intact
         self.assertEquals(client_response, 'resp')
 
     @mock.patch('surveilr.api.client.httplib2')
     def test_send_req_403_reraises_unauthorized_error(self, httplib2):
+        # Setup
         api_client = self._get_client()
 
         class FakeResponse(object):
@@ -57,58 +77,190 @@
 
         http = httplib2.Http.return_value
         http.request.return_value = (FakeResponse(403), 'resp')
+
+        # Exercise and verify
         self.assertRaises(client.UnauthorizedError,
                           api_client.send_req, 'tail', 'METHOD', 'body')
 
-    def test_req(self):
-        api_client = self._get_client()
-
-        test_data = {'foo': ['bar', 'baz', 2]}
-
-        class FakeObjType(object):
-            url_part = 'stuff'
-
-        with mock.patch_object(api_client, 'send_req') as send_req:
-            api_client.req(FakeObjType(), 'create', test_data)
+    def test_req_create_with_parend(self):
+        api_client = self._get_client()
+
+        test_data = {'foo': ['bar', 'baz', 2]}
+
+        class FakeObjType(client.APIObject):
+            url_part = 'stuff'
+
+        parent = FakeObjType(api_client)
+        parent.id = 7
+        with mock.patch_object(api_client, 'send_req') as send_req:
+            FakeObjType(api_client).req(api_client, 'create', test_data,
+                                        parent=parent)
+            self.assertEquals(send_req.call_args[0][0], '/stuffs/7/stuffs')
+            self.assertEquals(send_req.call_args[1]['method'], 'POST')
+            self.assertEquals(json.loads(send_req.call_args[1]['body']),
+                              test_data)
+
+    def test_req_create(self):
+        api_client = self._get_client()
+
+        test_data = {'foo': ['bar', 'baz', 2]}
+
+        class FakeObjType(client.APIObject):
+            url_part = 'stuff'
+
+        with mock.patch_object(api_client, 'send_req') as send_req:
+            FakeObjType(api_client).req(api_client, 'create', test_data)
             self.assertEquals(send_req.call_args[0][0], '/stuffs')
             self.assertEquals(send_req.call_args[1]['method'], 'POST')
             self.assertEquals(json.loads(send_req.call_args[1]['body']),
                               test_data)
 
-    def test_apiobject(self):
+    def test_req_get(self):
+        api_client = self._get_client()
+
+        class FakeObjType(client.APIObject):
+            url_part = 'stuff'
+
+        with mock.patch_object(api_client, 'send_req') as send_req:
+            FakeObjType(api_client).req(api_client, 'get', 'someid')
+            self.assertEquals(send_req.call_args[0][0], '/stuffs/someid')
+            self.assertEquals(send_req.call_args[1]['method'], 'GET')
+
+    def test_req_delete(self):
+        api_client = self._get_client()
+
+        class FakeObjType(client.APIObject):
+            url_part = 'stuff'
+
+        with mock.patch_object(api_client, 'send_req') as send_req:
+            FakeObjType(api_client).req(api_client, 'delete', 'someid')
+            self.assertEquals(send_req.call_args[0][0], '/stuffs/someid')
+            self.assertEquals(send_req.call_args[1]['method'], 'DELETE')
+
+
+class APIObjectTests(tests.TestCase):
+    def _test_req(self):
         client_obj = mock.Mock()
         data = mock.Sentinel()
 
         class TestObject(client.APIObject):
-            pass
+            url_part = 'test'
 
         obj = TestObject(client_obj)
         obj.req('ACTION', data)
 
         client_obj.req.assert_called_with(TestObject, 'ACTION', data)
 
-
-class APITypeTests(tests.TestCase):
-    def _test_user_new(self, admin):
-        client_obj = mock.Mock()
-        client_obj.req.return_value = json.dumps({'id': 'testid',
+    def _test_get_or_delete(self, op, req_return=None):
+        client_obj = mock.Mock()
+
+        class TestObject(client.APIObject):
+            url_part = 'test'
+
+            @classmethod
+            def json_deserialise(inner_self, client, s):
+                self.assertEquals(s, 'lots of json')
+
+            req = mock.Mock()
+
+        TestObject.req.return_value = req_return
+
+        getattr(TestObject, op)(client_obj, 'testid')
+        TestObject.req.assert_called_with(client_obj, op, 'testid')
+
+    def test_delete(self):
+        self._test_get_or_delete('delete')
+
+    def test_get(self):
+        self._test_get_or_delete('get', 'lots of json')
+
+
+class UserTests(tests.TestCase):
+    def _test_new(self, admin):
+        # Setup
+        client_obj = mock.Mock()
+        with mock.patch_object(client.User, 'req') as client_req:
+            client_req.return_value = json.dumps({'id': 'testid',
                                                   'key': 'testkey',
                                                   'admin': admin})
-        user = client.User.new(client_obj)
-        client_obj.req.assert_called_with(client.User, 'create',
+
+            # Exercise
+            user = client.User.new(client_obj)
+
+            # Verify
+            client_req.assert_called_with(client_obj, 'create',
                                           {'admin': False})
 
-        self.assertEquals(user.user_id, 'testid')
-        self.assertEquals(user.key, 'testkey')
-        self.assertEquals(user.admin, admin)
-        self.assertEquals(repr(user), "<User object, user_id=u'testid', "
-                                      "key=u'testkey', admin=%r>" % user.admin)
+            self.assertEquals(user.id, 'testid')
+            self.assertEquals(user.key, 'testkey')
+            self.assertEquals(user.admin, admin)
+            self.assertEquals(repr(user), "<User object, id=u'testid', "
+                                          "key=u'testkey', admin=%r>" %
+                                          user.admin)
 
     def test_user_new_admin(self):
-        self._test_user_new(True)
+        self._test_new(True)
 
     def test_user_new_not_admin(self):
-        self._test_user_new(False)
+        self._test_new(False)
+
+
+class ServiceTests(tests.TestCase):
+    def test_new(self):
+        # Setup
+        test_plugins = ['http://h:1/p']
+        client_obj = mock.Mock()
+        with mock.patch_object(client.Service, 'req') as service_req:
+            service_req.return_value = json.dumps({'id': 'testid',
+                                                  'name': 'testname',
+                                                  'plugins': test_plugins})
+
+            # Exercise
+            service = client.Service.new(client_obj, 'testname',
+                                         plugins=test_plugins)
+
+            # Verify
+            service_req.assert_called_with(client_obj, 'create',
+                                           {'name': 'testname',
+                                            'plugins': test_plugins})
+
+            self.assertEquals(service.id, 'testid')
+            self.assertEquals(service.name, 'testname')
+            self.assertEquals(service.plugins, test_plugins)
+            self.assertEquals(repr(service), "<Service object, id=u'testid', "
+                                              "name=u'testname', "
+                                              "plugins=[u'http://h:1/p']>")
+
+
+class MetricTests(tests.TestCase):
+    def test_service_metric_new(self):
+        # Setup
+        client_obj = mock.Mock()
+        service_obj = client.Service(client_obj, id='testid',
+                                     name='testname', plugins=[])
+
+        with mock.patch_object(client, 'Metric') as Metric:
+            service_obj.new_metric({'foo': 1234})
+
+            Metric.new.assert_called_with(client_obj, service_obj,
+                                          {'foo': 1234})
+
+
+    def test_new(self):
+        # Setup
+        client_obj = mock.Mock()
+        service_obj = mock.Sentinel()
+        with mock.patch_object(client.Metric, 'req') as metric_req:
+            metric_req.return_value = json.dumps({})
+
+            # Exercise
+            client.Metric.new(client_obj, service_obj, {'something': 1234})
+
+            # Verify
+            metric_req.assert_called_with(client_obj,
+                                          'create',
+                                          {'metrics': {'something': 1234}},
+                                          parent=service_obj)
 
 
 class DirectClientTests(tests.TestCase):
@@ -122,18 +274,18 @@
         from webob import Request
 
         api_client = client.SurveilrDirectClient({})
-        api_client.app = mock.Mock()
-        response = mock.Mock()
-        response.body = 'response'
-        api_client.app.return_value = response
-
-        client_response = api_client.send_req('tail', 'METHOD', 'body')
-
-        args = api_client.app.call_args[0]
-        self.assertEquals(type(args[0]), Request)
-
-        req = args[0]
-        self.assertEquals(req.path, 'tail')
-        self.assertEquals(req.method, 'METHOD')
-        self.assertEquals(req.body, 'body')
-        self.assertEquals(client_response, 'response')
+        with mock.patch_object(api_client, 'app') as app:
+            response = mock.Mock()
+            response.body = 'response'
+            app.return_value = response
+
+            client_response = api_client.send_req('tail', 'METHOD', 'body')
+
+            args = app.call_args[0]
+            self.assertEquals(type(args[0]), Request)
+
+            req = args[0]
+            self.assertEquals(req.path, 'tail')
+            self.assertEquals(req.method, 'METHOD')
+            self.assertEquals(req.body, 'body')
+            self.assertEquals(client_response, 'response')
 
=== modified file 'surveilr/tests/test_admin.py'
--- surveilr/tests/test_admin.py	2012-01-28 21:09:53 +0000
+++ surveilr/tests/test_admin.py	2012-01-29 23:36:23 +0000
@@ -126,24 +126,6 @@
 
         self.assertIsNone(auth)
 
-    def test_CreateUser_admin(self):
-        create_user = admin.CreateUser()
-
-        create_user.init(['--admin'])
-        create_user.client = mock.Mock()
-        create_user()
-
-        create_user.client.new_user.assert_called_with(admin=True)
-
-    def test_CreateUser_non_admin(self):
-        create_user = admin.CreateUser()
-
-        create_user.init([])
-        create_user.client = mock.Mock()
-        create_user()
-
-        create_user.client.new_user.assert_called_with(admin=False)
-
     def _replace_stdout_with_stringio(self):
         saved_stdout = sys.stdout
 
@@ -163,12 +145,23 @@
         self.assertEquals(sys.stdout.getvalue(),
                           'Action not permitted\n')
 
-    def test_cmd_list(self):
+    def test_cmd_list_if_no_command_given(self):
         self._replace_stdout_with_stringio()
         ret = admin.main([])
 
         self.assertEquals(ret, False)
         stdout = sys.stdout.getvalue()
+        self._check_cmd_list(stdout)
+
+    def test_cmd_list_if_invalid_command_given(self):
+        self._replace_stdout_with_stringio()
+        ret = admin.main(['this is not a valid command'])
+
+        self.assertEquals(ret, False)
+        stdout = sys.stdout.getvalue()
+        self._check_cmd_list(stdout)
+
+    def _check_cmd_list(self, stdout):
         self.assertEquals(len(stdout.split('\n')) - 1, len(admin.commands))
 
         expected_commands = set(admin.commands.keys())
@@ -180,3 +173,72 @@
             found_commands.add(cmd)
 
         self.assertEquals(expected_commands, found_commands)
+
+    def test_CreateUser_admin(self):
+        create_user = admin.CreateUser()
+
+        create_user.init(['--admin'])
+        create_user.client = mock.Mock()
+        create_user()
+
+        create_user.client.new_user.assert_called_with(admin=True)
+
+    def test_CreateUser_non_admin(self):
+        create_user = admin.CreateUser()
+
+        create_user.init([])
+        create_user.client = mock.Mock()
+        create_user()
+
+        create_user.client.new_user.assert_called_with(admin=False)
+
+    def test_CreateService_no_plugins(self):
+        create_service = admin.CreateService()
+
+        create_service.init(['servicename'])
+        create_service.client = mock.Mock()
+        create_service()
+
+        create_service.client.new_service.assert_called_with('servicename',
+                                                             None)
+
+    def test_CreateService_with_plugins(self):
+        create_service = admin.CreateService()
+
+        plugins = ['http://foo/bar', 'http://baz/wibble']
+
+        args = ['servicename']
+        for plugin in plugins:
+            args += ['-p', plugin]
+
+        create_service.init(args)
+        create_service.client = mock.Mock()
+        create_service()
+
+        create_service.client.new_service.assert_called_with('servicename',
+                                                             plugins)
+
+    def test_ShowUser(self):
+        self._test_Show_or_Delete('show', 'user')
+
+    def test_ShowService(self):
+        self._test_Show_or_Delete('show', 'service')
+
+    def test_DeleteUser(self):
+        self._test_Show_or_Delete('delete', 'user')
+
+    def test_DeleteService(self):
+        self._test_Show_or_Delete('delete', 'service')
+
+    def _test_Show_or_Delete(self, show_or_delete, type_name):
+        cmd = getattr(admin, '%s%s' % (show_or_delete.capitalize(),
+                                            type_name.capitalize()))()
+
+        cmd.init(['testid'])
+        cmd.client = mock.Mock()
+        cmd()
+
+        method_prefix = show_or_delete == 'show' and 'get' or 'delete'
+        method_name = '%s_%s' % (method_prefix, type_name)
+        method = getattr(cmd.client, method_name)
+        method.assert_called_with('testid')