Example #1
0
 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_sanitized_executable_name_for_timeline_view(self):
        executable = Executable(name='a' * 22)
        name = get_sanitized_executable_name_for_timeline_view(executable)
        self.assertEqual(name, 'a' * 22)

        executable = Executable(name='a' * 25)
        name = get_sanitized_executable_name_for_timeline_view(executable)
        self.assertEqual(name, 'a' * 22 + '...')
    def test_get_sanitized_executable_name_for_comparison_view(self):
        executable = Executable(name='b' * 20)
        name = get_sanitized_executable_name_for_comparison_view(executable)
        self.assertEqual(name, 'b' * 20)

        executable = Executable(name='b' * 25)
        name = get_sanitized_executable_name_for_comparison_view(executable)
        self.assertEqual(name, 'b' * 20 + '...')
Example #4
0
 def setUp(self):
     self.data = dict(
         name="Fibo",
         description="Fibonacci the Lame",
     )
     # project is a ForeignKey and is not added automatically by tastypie
     self.project = Project.objects.get(pk=1)
     self.executable = Executable(project=self.project, **self.data)
     self.executable.save()
     self.client = Client()
     super(ExecutableTest, self).setUp()
Example #5
0
 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()
Example #6
0
 def setUp(self):
     self.data = dict(
         name="Fibo",
         description="Fibonacci the Lame",
         )
     # project is a ForeignKey and is not added automatically by tastypie
     self.project=Project.objects.get(pk=1)
     self.executable = Executable(project=self.project, **self.data)
     self.executable.save()
     self.client = Client()
     super(ExecutableTest, self).setUp()
Example #7
0
    def setUp(self):
        self.days = 0
        self.starttime = datetime.now() + timedelta(days=-100)

        Project(repo_type='G', name='pro',
                repo_path='/home/foo/codespeed').save()
        self.pro = Project.objects.get(name='pro')

        Branch(project=self.pro, name='branch').save()
        self.b = Branch.objects.get(name='branch')

        Environment(name='Walden Pond').save()
        Executable(name='walden', project=self.pro).save()
        Benchmark(name='TestBench').save()

        self.env = Environment.objects.get(name='Walden Pond')
        self.exe = Executable.objects.get(name='walden')
        self.bench = Benchmark.objects.get(name='TestBench')
Example #8
0
class ReportTest(FixtureTestCase):
    """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)
Example #9
0
class ExecutableTest(FixtureTestCase):
    """Test Executable() API"""
    def setUp(self):
        self.data = dict(
            name="Fibo",
            description="Fibonacci the Lame",
        )
        # project is a ForeignKey and is not added automatically by tastypie
        self.project = Project.objects.get(pk=1)
        self.executable = Executable(project=self.project, **self.data)
        self.executable.save()
        self.client = Client()
        super(ExecutableTest, self).setUp()

    def test_get_executable(self):
        """Should get an existing executable"""
        response = self.client.get('/api/v1/executable/{0}/'.format(
            self.executable.id, ))
        self.assertEquals(response.status_code, 200)
        self.assertEqual(
            json.loads(response.content)['name'],
            "{0}".format(self.data['name']))

    def test_get_executable_all_fields(self):
        """Should get all fields for an executable"""
        response = self.client.get('/api/v1/executable/%s/' %
                                   (self.executable.id, ))
        self.assertEquals(response.status_code, 200)
        for k in self.data.keys():
            self.assertEqual(json.loads(response.content)[k], self.data[k])

    def test_post(self):
        """Should save a new executable"""
        modified_data = copy.deepcopy(self.data)
        modified_data['name'] = 'nbody'
        modified_data['project'] = '/api/v1/project/{0}/'.format(
            self.project.pk)
        response = self.client.post('/api/v1/executable/',
                                    data=json.dumps(modified_data),
                                    content_type='application/json')
        self.assertEquals(response.status_code, 201)
        response = self.client.get('/api/v1/executable/{0}/'.format(
            self.executable.id))
        response_data = json.loads(response.content)
        for k, v in self.data.items():
            self.assertEqual(response_data[k], v)
        executable = Executable.objects.get(pk=int(response_data['id']))
        self.assertEquals(executable.project, self.project)

    def test_delete(self):
        """Should delete an project"""
        response = self.client.delete('/api/v1/executable/{0}/'.format(
            self.executable.id, ),
                                      content_type='application/json')
        self.assertEquals(response.status_code, 204)

        response = self.client.get('/api/v1/executable/{0}/'.format(
            self.executable.id, ))

    def test_nonexistent(self):
        """Requesting an environment that doesn't exist should return a 404"""
        response = self.client.get('/api/v1/environment/3333333/')
        self.assertEquals(response.status_code, 404)
Example #10
0
class ReportTest(FixtureTestCase):
    """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)
Example #11
0
class ExecutableTest(FixtureTestCase):
    """Test Executable() API"""

    def setUp(self):
        self.data = dict(
            name="Fibo",
            description="Fibonacci the Lame",
            )
        # project is a ForeignKey and is not added automatically by tastypie
        self.project=Project.objects.get(pk=1)
        self.executable = Executable(project=self.project, **self.data)
        self.executable.save()
        self.client = Client()
        super(ExecutableTest, self).setUp()

    def test_get_executable(self):
        """Should get an existing executable"""
        response = self.client.get('/api/v1/executable/{0}/'.format(
            self.executable.id,))
        self.assertEquals(response.status_code, 200)
        self.assertEqual(json.loads(response.content)['name'], "{0}".format(
            self.data['name']))

    def test_get_executable_all_fields(self):
        """Should get all fields for an executable"""
        response = self.client.get('/api/v1/executable/%s/' % (
            self.executable.id,))
        self.assertEquals(response.status_code, 200)
        for k in self.data.keys():
            self.assertEqual(
                json.loads(response.content)[k], self.data[k])

    def test_post(self):
        """Should save a new executable"""
        modified_data = copy.deepcopy(self.data)
        modified_data['name'] = 'nbody'
        modified_data['project'] = '/api/v1/project/{0}/'.format(self.project.pk)
        response = self.client.post('/api/v1/executable/',
                                    data=json.dumps(modified_data),
                                    content_type='application/json')
        self.assertEquals(response.status_code, 201)
        response = self.client.get('/api/v1/executable/{0}/'.format(
            self.executable.id))
        response_data = json.loads(response.content)
        for k, v in self.data.items():
            self.assertEqual(response_data[k], v)
        executable = Executable.objects.get(pk=int(response_data['id']))
        self.assertEquals(executable.project, self.project)

    def test_delete(self):
        """Should delete an project"""
        response = self.client.delete('/api/v1/executable/{0}/'.format(
            self.executable.id,), content_type='application/json')
        self.assertEquals(response.status_code, 204)

        response = self.client.get('/api/v1/executable/{0}/'.format(
            self.executable.id,))

    def test_nonexistent(self):
        """Requesting an environment that doesn't exist should return a 404"""
        response = self.client.get('/api/v1/environment/3333333/')
        self.assertEquals(response.status_code, 404)