def run(self, worklogentry_id, serialized_right_boundary):
logger = self.get_logger()
step = self.model.step
right_boundary = parse_datetime(serialized_right_boundary)
left_boundary = right_boundary - step
if right_boundary != floor_to_base(right_boundary, step):
raise ValueError('Right boundary is not a multiple of %s.' % step)
try:
with transaction.atomic():
aggregates_to_create = self.aggregate(left_boundary,
right_boundary)
if aggregates_to_create:
for instance_name, group in groupby(
aggregates_to_create, lambda o: o.instance_name):
self.notify_about_aggregate(instance_name, list(group))
self.model.objects.bulk_create(aggregates_to_create)
WorkLogEntry.objects.filter(pk=worklogentry_id).update(
status=WorkLogEntry.STATUS_CHOICES.DONE)
interval_aggregated.send(sender=self,
left_boundary=left_boundary,
right_boundary=right_boundary)
except Exception:
WorkLogEntry.objects.filter(pk=worklogentry_id).update(
status=WorkLogEntry.STATUS_CHOICES.FAILED)
logger.exception('Unexpected error when aggregating %s - %s.' %
(left_boundary, right_boundary))
def test_filtering_by_date(self):
now = floor_to_base(timezone.now(), self.model.step)
aggregate1 = G(self.model, admin=self.admin, timestamp=now, value=100)
aggregate2 = G(self.model,
admin=self.admin,
timestamp=now - timedelta(days=1),
value=150)
if self.as_date:
now = now.date()
response = self.client.get(self.url, {'start': now})
self.assertEqual(len(response.data['objects']), 1)
self.assertEqual(response.data['objects'][0]['value'],
aggregate1.value)
response = self.client.get(self.url, {'end': now - timedelta(days=1)})
self.assertEqual(len(response.data['objects']), 1)
self.assertEqual(response.data['objects'][0]['value'],
aggregate2.value)
response = self.client.get(self.url, {
'start': now + timedelta(days=1),
'end': now + timedelta(days=2)
})
self.assertEqual(len(response.data['objects']), 0)
from datetime import timedelta
from unittest import mock
from django.test import TestCase
from django.utils.timezone import now
from django_dynamic_fixture import G
from apps.metrics.helpers import floor_to_base
from apps.metrics.models import WorkLogEntry
from apps.metrics.tasks import AggregateHourTask
last_full_hour = floor_to_base(now(), base=timedelta(hours=1))
class ChargingTestCase(TestCase):
@mock.patch('apps.billing.tasks.ChargeOneHour.run')
def test_one_hour_is_charged_when_metrics_finish_calculating(
self, mock_func):
worklog = G(WorkLogEntry)
AggregateHourTask.delay(worklog.id, (last_full_hour +
timedelta(hours=1)).isoformat())
mock_func.assert_called_with(last_full_hour.isoformat())
def create_worklog(self, step):
right_boundary = floor_to_base(now() - step, base=step)
return G(WorkLogEntry,
left_boundary=right_boundary - step,
right_boundary=right_boundary,
seconds=step.total_seconds())
def create_boundary(self, base, precision):
right_boundary = floor_to_base(now(), base)
left_boundary = right_boundary - precision
return left_boundary, right_boundary