← Back to branch summary

~offspring-committers/offspring/linaro-privacy

« back to all changes in this revision

Viewing changes to lib/offspring/web/queuemanager/tests/test_models.py

  • Committer: Kevin McDermott
  • Date: 2012-01-31 15:42:46 UTC
  • mfrom: (96.7.6 fix-bug-914743)
  • Revision ID: kevin@canonical.com-20120131154246-oknzq3d916k5c4ny
Merge fix-bug-914743 Change the average utilisation to use Django.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/offspring/web/queuemanager/tests/test_models.py
1
1
# Copyright 2010 Canonical Ltd.  This software is licensed under the
2
2
# GNU Affero General Public License version 3 (see the file LICENSE).
3
 
from datetime import datetime, timedelta
 
3
from datetime import datetime, timedelta, date
4
4
 
5
5
from operator import attrgetter
6
6
 
296
296
            project=project, durations=[25, 25],
297
297
            result=ProjectBuildStates.SUCCESS)
298
298
 
 
299
        started_at = datetime.now() - timedelta(minutes=10)
299
300
        build_result = factory.make_build_result(
300
 
            project=project, result=ProjectBuildStates.PENDING)
301
 
        started_at = datetime.now() - timedelta(minutes=10)
302
 
        build_result.started_at = started_at
303
 
        build_result.save()
304
 
 
305
 
        builder = Lexbuilder.objects.create(current_job=build_result)
 
301
            project=project, result=ProjectBuildStates.PENDING,
 
302
            started_at=started_at)
 
303
        builder = factory.make_lexbuilder(current_job=build_result)
306
304
 
307
305
        datetime_mock = self.mocker.replace(datetime)
308
306
        datetime_mock.now()
322
320
        """
323
321
        project = factory.make_project()
324
322
 
 
323
        started_at = datetime.now() - timedelta(minutes=10)
325
324
        build_result = factory.make_build_result(
326
 
            project=project, result=ProjectBuildStates.PENDING)
327
 
        started_at = datetime.now() - timedelta(minutes=10)
328
 
        build_result.started_at = started_at
329
 
        build_result.save()
 
325
            project=project, result=ProjectBuildStates.PENDING,
 
326
            started_at=started_at)
330
327
 
331
 
        builder = Lexbuilder.objects.create(current_job=build_result)
 
328
        builder = factory.make_lexbuilder(current_job=build_result)
332
329
 
333
330
        self.assertEqual("Unknown", builder.estimated_completion)
334
331
 
335
332
    def test_estimated_completion_with_no_current_build(self):
336
333
        """
337
 
        If the average cannot be determined because there are no builds, we
338
 
        should get "Unknown" as the estimated completion time.
 
334
        If there is no current build, then we should get "No build in
 
335
        progress" for the estimated completion time.
339
336
        """
340
 
        builder = Lexbuilder.objects.create()
 
337
        builder = factory.make_lexbuilder(current_job=None)
341
338
        self.assertEqual("No build in progress", builder.estimated_completion)
342
339
 
343
340
    def test_estimated_completion_negative_time(self):
357
354
        build_result.started_at = started_at
358
355
        build_result.save()
359
356
 
360
 
        builder = Lexbuilder.objects.create(current_job=build_result)
 
357
        builder = factory.make_lexbuilder(current_job=build_result)
361
358
 
362
359
        datetime_mock = self.mocker.replace(datetime)
363
360
        datetime_mock.now()
368
365
        # Started 10 minutes ago (started_at + timedelta(minutes=10))
369
366
        self.assertEqual("ASAP", builder.estimated_completion)
370
367
 
 
368
    def test_average_load(self):
 
369
        """
 
370
        Lexbuilder.average_load should calculate the total time used by builds
 
371
        as a percentage of the time available.
 
372
        """
 
373
        builder = factory.make_lexbuilder()
 
374
        project = factory.make_project()
 
375
        create_build_results_with_durations(
 
376
            project, [50, 50], result=ProjectBuildStates.SUCCESS,
 
377
            build_date=date.today() - timedelta(days=2),
 
378
            builder=builder)
 
379
        # 50 minutes * 60 seconds + 50 minutes * 60 seconds / (24 * 60 * 60)
 
380
        # = 0.0694 = 6.94%
 
381
        self.assertEqual(6.94, round(builder.average_load, 2))
 
382
 
 
383
    def test_average_load_buildresults_today(self):
 
384
        """
 
385
        Lexbuilder.average_load should ignore buildresults from today.
 
386
        """
 
387
        builder = factory.make_lexbuilder()
 
388
        project = factory.make_project()
 
389
        # Cheat build_date to tomorrow, because it sets the start_date to
 
390
        # build_date - 10 minutes.
 
391
        create_build_results_with_durations(
 
392
            project, [50, 50], build_date=date.today() + timedelta(days=1),
 
393
            result=ProjectBuildStates.SUCCESS, builder=builder)
 
394
        self.assertEqual(None, builder.average_load)
 
395
 
371
396
    def test_lexbuilder_without_current_job(self):
372
397
        """
373
398
        A Lexbuilder with no current_job is not considered private and thus
374
399
        is visible to anyone.
375
400
        """
376
 
        builder = factory.make_lexbuilder()
377
 
        # Must manually set current_job to None because the above call will
378
 
        # create an arbitrary BuildResult and assign it to the newly created
379
 
        # builder's current_job.
380
 
        builder.current_job = None
381
 
        builder.save()
 
401
        builder = factory.make_lexbuilder(current_job=None)
382
402
        user = factory.make_user()
383
403
        self.assertEqual(False, builder.is_private)
384
404
        self.assertEqual(True, builder.is_visible_to(user))