Covered all RESTful API resources by tests, changed Report() api

    - 100% coverage of all the resources provided by the tastypie API
    - changed ReportResource() to only accept GET requests. Reports
      are generated automatically.
    - fixed some typos

Author: a8

codespeed/api.py

@@ -54,7 +54,8 @@
 
 
 class UserResource(ModelResource):
-    """Ressource for Django User()"""
+    """Resource for Django User()"""
+
     class Meta:
         queryset = User.objects.filter(is_active=True)
         resource_name = 'user'
@@ -68,15 +69,15 @@ class Meta:
 
 
 class ProjectResource(ModelResource):
-    """Ressource for Project()"""
+    """Resource for Project()"""
 
     class Meta:
         queryset = Project.objects.all()
         authorization= Authorization()
 
 
 class BranchResource(ModelResource):
-    """Ressource for Branch()"""
+    """Resource for Branch()"""
 
     project = fields.ToOneField(ProjectResource, 'project')
 
@@ -86,7 +87,7 @@ class Meta:
 
 
 class RevisionResource(ModelResource):
-    """Ressource for Revision()"""
+    """Resource for Revision()"""
 
     project = fields.ToOneField(ProjectResource, 'project')
     branch = fields.ToOneField(BranchResource, 'branch')
@@ -97,7 +98,7 @@ class Meta:
 
 
 class ExecutableResource(ModelResource):
-    """Ressource for Executable()"""
+    """Resource for Executable()"""
 
     project = fields.ToOneField(ProjectResource, 'project')
 
@@ -107,15 +108,15 @@ class Meta:
 
 
 class BenchmarkResource(ModelResource):
-    """Ressource for Benchmark()"""
+    """Resource for Benchmark()"""
 
     class Meta:
         queryset = Benchmark.objects.all()
         authorization= Authorization()
 
 
 class EnvironmentResource(ModelResource):
-    """Ressource for Enviroment()"""
+    """Resource for Enviroment()"""
 
     class Meta:
         queryset = Environment.objects.all()
@@ -124,18 +125,23 @@ class Meta:
 
 
 class ResultResource(ModelResource):
-    """Ressource for Result()"""
+    """Resource for Result()"""
 
     class Meta:
         queryset = Result.objects.all()
         authorization= Authorization()
 
 
 class ReportResource(ModelResource):
-    """Ressource for Report()"""
+    """Resource for Report()"""
+
+    revision = fields.ToOneField(RevisionResource, 'revision')
+    environment = fields.ToOneField(EnvironmentResource, 'environment')
+    executable = fields.ToOneField(ExecutableResource, 'executable')
 
     class Meta:
         queryset = Report.objects.all()
+        allowed_methods = ['get']
         authorization= Authorization()
 
 
@@ -331,7 +337,7 @@ def save(self):
 
 
 class ResultBundleResource(Resource):
-    """Ressource for all the data of a benchmark result.
+    """Resource for all the data of a benchmark result.
 
        Primarily used to submit benchmark results
 

codespeed/tests/tests_api.py

@@ -372,7 +372,7 @@ def setUp(self):
         super(RevisionTest, self).setUp()
 
     def test_get_revision(self):
-        """Should get an existing branch"""
+        """Should get an existing revision"""
         response = self.client.get('/api/v1/revision/1/')
         self.assertEquals(response.status_code, 200)
         self.assertEqual(json.loads(response.content)['commitid'], "1")
@@ -411,7 +411,7 @@ def test_post(self):
         self.assertEquals(response.status_code, 204)
 
     def test_put(self):
-        """Should modify an existing environment"""
+        """Should modify an existing revision"""
         modified_data = copy.deepcopy(self.revision2_data)
         modified_data['tag'] = "v0.9.1"
         response = self.client.put('/api/v1/revision/1/',
@@ -437,7 +437,7 @@ def test_delete(self):
 
 
 class ExecutableTest(FixtureTestCase):
-    """Test Branch() API"""
+    """Test Executable() API"""
 
     def setUp(self):
         self.executable1 = Executable.objects.get(pk=1)
@@ -514,13 +514,157 @@ def test_delete(self):
 
 
 class BenchmarkTest(FixtureTestCase):
-    """Test Branch() API"""
-    pass
+    """Test Benchmark() API"""
+
+    def setUp(self):
+        self.benchmark1 = Benchmark.objects.get(pk=1)
+        self.benchmark2_data = dict(
+            name="sleep",
+            benchmark_type = 'C',
+            description = 'fast faster fastest',
+            units_title = 'Time',
+            units = 'seconds',
+            lessisbetter = True,
+            default_on_comparison = True,
+            )
+        self.benchmark2 = Benchmark(**self.benchmark2_data)
+        self.benchmark2.save()
+        self.client = Client()
+        super(BenchmarkTest, self).setUp()
+
+    def test_get_benchmark(self):
+        """Should get an existing benchmark"""
+        response = self.client.get('/api/v1/benchmark/1/')
+        self.assertEquals(response.status_code, 200)
+        self.assertEqual(json.loads(response.content)['name'],
+                         'float')
+        self.assertEqual(json.loads(response.content)['units'],
+                         "seconds")
+
+    def test_get_benchmark_all_fields(self):
+        """Should get all fields for an benchmark"""
+        response = self.client.get('/api/v1/benchmark/{0}/'.format(
+            self.benchmark2.id,))
+        self.assertEquals(response.status_code, 200)
+        for k, v in self.benchmark2_data.items():
+            self.assertEqual(json.loads(response.content)[k], v)
+
+    def test_post(self):
+        """Should save a new benchmark"""
+        modified_data = copy.deepcopy(self.benchmark2_data)
+        modified_data['name'] = 'wake'
+        response = self.client.post('/api/v1/benchmark/',
+                                    data=json.dumps(modified_data),
+                                    content_type='application/json')
+        self.assertEquals(response.status_code, 201)
+        id = response['Location'].rsplit('/', 2)[-2]
+        response = self.client.get('/api/v1/benchmark/{0}/'.format(id))
+        for k, v in modified_data.items():
+            self.assertEqual(
+                json.loads(response.content)[k], v)
+        response = self.client.delete('/api/v1/benchmark/{0}/'.format(id),
+                                      content_type='application/json')
+        self.assertEquals(response.status_code, 204)
+
+    def test_put(self):
+        """Should modify an existing benchmark"""
+        modified_data = copy.deepcopy(self.benchmark2_data)
+        modified_data['name'] = "django"
+        response = self.client.put('/api/v1/benchmark/1/',
+                                   data=json.dumps(modified_data),
+                                   content_type='application/json')
+        self.assertEquals(response.status_code, 204)
+        response = self.client.get('/api/v1/benchmark/1/')
+        for k, v in modified_data.items():
+            self.assertEqual(
+                json.loads(response.content)[k], v)
+
+    def test_delete(self):
+        """Should delete a benchmark"""
+        response = self.client.get('/api/v1/benchmark/1/')
+        self.assertEquals(response.status_code, 200)
+        # from fixture
+        response = self.client.delete('/api/v1/benchmark/1/',
+                                      content_type='application/json')
+        self.assertEquals(response.status_code, 204)
+
+        response = self.client.get('/api/v1/benchmark/1/')
+        self.assertEquals(response.status_code, 404)
 
 
 class ReportTest(FixtureTestCase):
-    """Test Branch() API"""
-    pass
+    """Test Report() API"""
+
+    def setUp(self):
+        self.report1 = Report.objects.get(pk=1)
+        self.revision1 = Revision.objects.get(pk=1)
+        self.executable1 = Executable.objects.get(pk=1)
+        self.environment1 = Environment.objects.get(pk=1)
+        self.executable2_data = dict(
+            name="Fibo",
+            description="Fibonacci the Lame",
+            )
+        self.project=Project.objects.get(pk=1)
+        self.executable2 = Executable(project=self.project,
+                                      **self.executable2_data)
+        self.executable2.save()
+        self.report2_data = dict(
+            revision=self.revision1,
+            environment=self.environment1,
+            executable=self.executable2,
+            )
+        self.report2 = Report(**self.report2_data)
+        self.report2.save()
+        self.report2_data = dict(
+            revision='/api/v1/revision/{0}/'.format(self.revision1.id),
+            environment='/api/v1/environment/{0}/'.format(self.environment1.id),
+            executable='/api/v1/executable/{0}/'.format(self.executable2.id),
+            )
+        self.client = Client()
+        super(ReportTest, self).setUp()
+
+    def test_get_report(self):
+        """Should get an existing report"""
+        response = self.client.get('/api/v1/report/1/')
+        self.assertEquals(response.status_code, 200)
+        self.assertEqual(json.loads(response.content)['summary'],
+                         'float -50.0%')
+        self.assertEqual(json.loads(response.content)['colorcode'],
+                         "green")
+
+    def test_get_report_all_fields(self):
+        """Should get all fields for an report"""
+        response = self.client.get('/api/v1/report/{0}/'.format(
+            self.report2.id,))
+        self.assertEquals(response.status_code, 200)
+        for k, v in self.report2_data.items():
+            self.assertEqual(json.loads(response.content)[k], v)
+
+    def test_post(self):
+        """Should save a new report"""
+        modified_data = copy.deepcopy(self.report2_data)
+        response = self.client.post('/api/v1/report/',
+                                    data=json.dumps(modified_data),
+                                    content_type='application/json')
+        # next has to be 405, otherwise would raise IntegrityError
+        self.assertEquals(response.status_code, 405)
+
+    def test_put(self):
+        """Should modify an existing report"""
+        modified_data = copy.deepcopy(self.report2_data)
+        response = self.client.put('/api/v1/report/1/',
+                                   data=json.dumps(modified_data),
+                                   content_type='application/json')
+        self.assertEquals(response.status_code, 405)
+
+    def test_delete(self):
+        """Should delete a report"""
+        response = self.client.get('/api/v1/report/1/')
+        self.assertEquals(response.status_code, 200)
+        # from fixture
+        response = self.client.delete('/api/v1/report/1/',
+                                      content_type='application/json')
+        self.assertEquals(response.status_code, 405)
 
 
 class UserTest(FixtureTestCase):

codespeed/urls.py

@@ -5,7 +5,7 @@
 from tastypie.api import Api
 from codespeed.feeds import LatestEntries
 from codespeed.api import (UserResource, EnvironmentResource,
-                           ProjectResource, ExecutableResource,
+                           ProjectResource, ExecutableResource, ReportResource,
                            BenchmarkResource, ResultResource, BranchResource,
                            RevisionResource, ResultBundleResource)
 
@@ -20,6 +20,7 @@
 rest_api.register(ResultResource())
 rest_api.register(BranchResource())
 rest_api.register(RevisionResource())
+rest_api.register(ReportResource())
 rest_api.register(ResultBundleResource())
 
 urlpatterns = patterns('',