Python utils.decimal_utc函数代码示例

    def test_process_delete_with_only_deleted_at(self, stackdb_mock):
        # 1. Creating test values
        delete_time = datetime.datetime.utcnow()
        launch_time = delete_time-datetime.timedelta(days=1)
        launch_decimal = utils.decimal_utc(launch_time)
        delete_decimal = utils.decimal_utc(delete_time)
        notification = MagicMock()
        notification.instance = INSTANCE_ID_1
        notification.deleted_at = str(delete_time)
        notification.terminated_at = ''
        notification.launched_at = str(launch_time)

        raw = MagicMock()
        delete = MagicMock()
        delete.instance = INSTANCE_ID_1
        delete.launched_at = launch_decimal
        # Since there is no terminated_at arg present, the deleted_at arg will be used as the deleted_at value.
        delete.deleted_at = delete_decimal
        # 2. Mocking methods
        stack_db_obj = MagicMock()
        stackdb_mock.get_or_create_instance_delete.return_value = (stack_db_obj, False)
        from stacktach import views
        views._process_delete(raw, notification)
        # 3. Assert statements
        stackdb_mock.get_or_create_instance_delete.assert_called_with(instance=delete.instance,
                                                                      deleted_at=delete.deleted_at,
                                                                      launched_at=delete.launched_at)
        stackdb_mock.save.assert_called_with(stack_db_obj)

    def test_process_delete(self, stackdb_mock):
        delete_time = datetime.datetime.utcnow()
        terminated_time = delete_time-datetime.timedelta(seconds=1)
        launch_time = delete_time-datetime.timedelta(days=1)
        launch_decimal = utils.decimal_utc(launch_time)
        terminated_decimal = utils.decimal_utc(terminated_time)
        notification = MagicMock()
        notification.instance = INSTANCE_ID_1
        notification.deleted_at = str(delete_time)
        notification.terminated_at = str(terminated_time)
        notification.launched_at = str(launch_time)
        raw = MagicMock()
        delete = MagicMock()
        delete.instance = INSTANCE_ID_1
        delete.launched_at = launch_decimal
        # Since there is a terminated_at arg present, it will be used as the deleted_at value.
        delete.deleted_at = terminated_decimal

        stack_db_obj = MagicMock()
        stackdb_mock.get_or_create_instance_delete.return_value = (stack_db_obj, False)
        from stacktach import views
        views._process_delete(raw, notification)

        stackdb_mock.get_or_create_instance_delete.assert_called_with(instance=delete.instance,
                                                                      deleted_at=delete.deleted_at,
                                                                      launched_at=delete.launched_at)
        stackdb_mock.save.assert_called_with(stack_db_obj)

    def test_process_usage_for_updates_finish_resize_end_later_update(self):
        notification = self._create_mock_notification()
        raw = self.mox.CreateMockAnything()
        raw.event = 'compute.instance.finish_resize.end'

        usage = self.mox.CreateMockAnything()
        usage.launched_at = utils.decimal_utc(LATER_DUMMY_TIME)
        usage.instance_type_id = INSTANCE_TYPE_ID_2
        usage.instance_flavor_id = INSTANCE_FLAVOR_ID_2
        views.STACKDB.get_or_create_instance_usage(instance=INSTANCE_ID_1,
                                                   request_id=REQUEST_ID_1) \
            .AndReturn((usage, True))
        views.STACKDB.save(usage)
        self.mox.ReplayAll()

        views._process_usage_for_updates(raw, notification)

        self.assertEqual(usage.instance_type_id, INSTANCE_TYPE_ID_1)
        self.assertEqual(usage.instance_flavor_id, INSTANCE_FLAVOR_ID_1)
        self.assertEqual(usage.launched_at, utils.decimal_utc(LATER_DUMMY_TIME))
        self.assertEquals(usage.tenant, TENANT_ID_1)
        self.assertEquals(usage.os_architecture, OS_ARCH_1)
        self.assertEquals(usage.os_version, OS_VERSION_1)
        self.assertEquals(usage.os_distro, OS_DISTRO_1)
        self.assertEquals(usage.rax_options, RAX_OPTIONS_1)

        self.mox.VerifyAll()

 def test_process_exists_with_deleted_at(self):
     launch_time = datetime.datetime.utcnow()-datetime.timedelta(hours=23)
     launch_decimal = utils.decimal_utc(launch_time)
     deleted_time = datetime.datetime.utcnow()-datetime.timedelta(hours=12)
     deleted_decimal = utils.decimal_utc(deleted_time)
     current_time = datetime.datetime.utcnow()
     current_decimal = utils.decimal_utc(current_time)
     notif = utils.create_nova_notif(launched=str(launch_time),
                                     deleted=str(deleted_time))
     json_str = json.dumps(notif)
     event = 'compute.instance.exists'
     raw = utils.create_raw(self.mox, current_decimal, event=event,
                            json_str=json_str)
     usage = self.mox.CreateMockAnything()
     views.STACKDB.get_instance_usage(instance=INSTANCE_ID_1,
                                      launched_at=launch_decimal)\
                  .AndReturn(usage)
     exists_values = {
         'message_id': MESSAGE_ID_1,
         'instance': INSTANCE_ID_1,
         'launched_at': launch_decimal,
         'deleted_at': deleted_decimal,
         'instance_type_id': '1',
         'usage': usage,
         'raw': raw,
     }
     exists = self.mox.CreateMockAnything()
     views.STACKDB.create_instance_exists(**exists_values).AndReturn(exists)
     views.STACKDB.save(exists)
     self.mox.ReplayAll()
     views._process_exists(raw)
     self.mox.VerifyAll()

    def test_process_delete(self):
        delete_time = datetime.datetime.utcnow()
        launch_time = delete_time-datetime.timedelta(days=1)
        launch_decimal = utils.decimal_utc(launch_time)
        delete_decimal = utils.decimal_utc(delete_time)
        notif = utils.create_nova_notif(request_id=REQUEST_ID_1,
                                        launched=str(launch_time),
                                        deleted=str(delete_time))
        json_str = json.dumps(notif)
        event = 'compute.instance.delete.end'
        raw = utils.create_raw(self.mox, delete_decimal, event=event,
                               json_str=json_str)
        delete = self.mox.CreateMockAnything()
        delete.instance = INSTANCE_ID_1
        delete.launched_at = launch_decimal
        delete.deleted_at = delete_decimal
        views.STACKDB.create_instance_delete(instance=INSTANCE_ID_1,
                                             launched_at=launch_decimal,
                                             deleted_at=delete_decimal,
                                             raw=raw)\
                     .AndReturn(delete)
        views.STACKDB.save(delete)
        self.mox.ReplayAll()

        views._process_delete(raw, notif[1])
        self.assertEqual(delete.instance, INSTANCE_ID_1)
        self.assertEqual(delete.launched_at, launch_decimal)
        self.assertEqual(delete.deleted_at, delete_decimal)
        self.mox.VerifyAll()

    def test_process_delete_with_neither(self):
        delete_time = datetime.datetime.utcnow()
        launch_time = delete_time-datetime.timedelta(days=1)
        launch_decimal = utils.decimal_utc(launch_time)
        delete_decimal = utils.decimal_utc(delete_time)
        notification = self.mox.CreateMockAnything()
        notification.instance = INSTANCE_ID_1
        notification.deleted_at = ''
        notification.terminated_at = str(delete_time)
        notification.launched_at = str(launch_time)

        raw = self.mox.CreateMockAnything()
        delete = self.mox.CreateMockAnything()
        delete.instance = INSTANCE_ID_1
        delete.launched_at = launch_decimal
        delete.deleted_at = delete_decimal
        views.STACKDB.get_or_create_instance_delete(
            instance=INSTANCE_ID_1, deleted_at=delete_decimal,
            launched_at=launch_decimal)\
            .AndReturn((delete, True))
        views.STACKDB.save(delete)
        self.mox.ReplayAll()

        views._process_delete(raw, notification)

        self.assertEqual(delete.instance, INSTANCE_ID_1)
        self.assertEqual(delete.launched_at, launch_decimal)
        self.assertEqual(delete.deleted_at, delete_decimal)
        self.mox.VerifyAll()

    def test_process_exists_with_deleted_at(self):
        notification = self.mox.CreateMockAnything()
        current_time = datetime.datetime.utcnow()
        launch_time = current_time - datetime.timedelta(hours=23)
        launch_decimal = utils.decimal_utc(launch_time)
        delete_time = datetime.datetime.utcnow()
        deleted_decimal = utils.decimal_utc(delete_time)
        audit_beginning = current_time - datetime.timedelta(hours=20)
        audit_beginning_decimal = utils.decimal_utc(audit_beginning)
        audit_ending_decimal = utils.decimal_utc(current_time)

        notification.launched_at = str(launch_time)
        notification.audit_period_beginning = str(audit_beginning)
        notification.audit_period_ending = str(current_time)
        notification.tenant = TENANT_ID_1
        notification.os_architecture = OS_ARCH_1
        notification.os_version = OS_VERSION_1
        notification.os_distro = OS_DISTRO_1
        notification.rax_options = RAX_OPTIONS_1
        notification.instance = INSTANCE_ID_1
        notification.instance_type_id = INSTANCE_TYPE_ID_1
        notification.message_id = MESSAGE_ID_1
        notification.deleted_at = str(delete_time)
        notification.bandwidth_public_out = BANDWIDTH_PUBLIC_OUTBOUND
        raw = self.mox.CreateMockAnything()
        usage = self.mox.CreateMockAnything()
        launched_range = (launch_decimal, launch_decimal+1)
        views.STACKDB.get_instance_usage(instance=INSTANCE_ID_1,
                                         launched_at__range=launched_range)\
                     .AndReturn(usage)
        delete = self.mox.CreateMockAnything()
        views.STACKDB.get_instance_delete(instance=INSTANCE_ID_1,
                                          launched_at__range=launched_range)\
             .AndReturn(delete)
        exists_values = {
            'message_id': MESSAGE_ID_1,
            'instance': INSTANCE_ID_1,
            'launched_at': launch_decimal,
            'deleted_at': deleted_decimal,
            'audit_period_beginning': audit_beginning_decimal,
            'audit_period_ending': audit_ending_decimal,
            'instance_type_id': INSTANCE_TYPE_ID_1,
            'usage': usage,
            'delete': delete,
            'raw': raw,
            'tenant': TENANT_ID_1,
            'rax_options': RAX_OPTIONS_1,
            'os_architecture': OS_ARCH_1,
            'os_version': OS_VERSION_1,
            'os_distro': OS_DISTRO_1,
            'bandwidth_public_out': BANDWIDTH_PUBLIC_OUTBOUND
        }
        exists = self.mox.CreateMockAnything()
        views.STACKDB.create_instance_exists(**exists_values).AndReturn(exists)
        views.STACKDB.save(exists)
        self.mox.ReplayAll()
        views._process_exists(raw, notification)
        self.mox.VerifyAll()

 def test_process_exists_with_deleted_at(self):
     current_time = datetime.datetime.utcnow()
     launch_time = current_time - datetime.timedelta(hours=23)
     launch_decimal = utils.decimal_utc(launch_time)
     deleted_time = current_time - datetime.timedelta(hours=12)
     deleted_decimal = utils.decimal_utc(deleted_time)
     current_decimal = utils.decimal_utc(current_time)
     audit_beginning = current_time - datetime.timedelta(hours=20)
     audit_beginning_decimal = utils.decimal_utc(audit_beginning)
     audit_ending_decimal = utils.decimal_utc(current_time)
     notif = utils.create_nova_notif(launched=str(launch_time),
                                     deleted=str(deleted_time),
                                     audit_period_beginning=str(audit_beginning),
                                     audit_period_ending=str(current_time),
                                     tenant_id=TENANT_ID_1,
                                     os_architecture=OS_ARCH_1,
                                     os_version=OS_VERSION_1,
                                     os_distro=OS_DISTRO_1,
                                     rax_options=RAX_OPTIONS_1)
     json_str = json.dumps(notif)
     event = 'compute.instance.exists'
     raw = utils.create_raw(self.mox, current_decimal, event=event,
                            json_str=json_str)
     usage = self.mox.CreateMockAnything()
     launched_range = (launch_decimal, launch_decimal+1)
     views.STACKDB.get_instance_usage(instance=INSTANCE_ID_1,
                                      launched_at__range=launched_range)\
                  .AndReturn(usage)
     delete = self.mox.CreateMockAnything()
     views.STACKDB.get_instance_delete(instance=INSTANCE_ID_1,
                                       launched_at__range=launched_range)\
          .AndReturn(delete)
     exists_values = {
         'message_id': MESSAGE_ID_1,
         'instance': INSTANCE_ID_1,
         'launched_at': launch_decimal,
         'deleted_at': deleted_decimal,
         'audit_period_beginning': audit_beginning_decimal,
         'audit_period_ending': audit_ending_decimal,
         'instance_type_id': '1',
         'usage': usage,
         'delete': delete,
         'raw': raw,
         'tenant': TENANT_ID_1,
         'rax_options': RAX_OPTIONS_1,
         'os_architecture': OS_ARCH_1,
         'os_version': OS_VERSION_1,
         'os_distro': OS_DISTRO_1
     }
     exists = self.mox.CreateMockAnything()
     views.STACKDB.create_instance_exists(**exists_values).AndReturn(exists)
     views.STACKDB.save(exists)
     self.mox.ReplayAll()
     views._process_exists(raw, notif[1])
     self.mox.VerifyAll()

    def test_do_list_usage_exists_with_instance(self):
        fake_request = self.mox.CreateMockAnything()
        fake_request.GET = {"instance": INSTANCE_ID_1}
        results = self.mox.CreateMockAnything()
        models.InstanceExists.objects.filter(instance=INSTANCE_ID_1).AndReturn(results)
        usage = self.mox.CreateMockAnything()
        usage.instance = INSTANCE_ID_1
        usage.launched_at = utils.decimal_utc()
        usage.deleted_at = usage.launched_at + 10
        usage.instance_type_id = 1
        usage.message_id = "someid"
        usage.status = "pending"
        results.__iter__().AndReturn([usage].__iter__())
        self.mox.ReplayAll()

        resp = stacky_server.do_list_usage_exists(fake_request)
        self.assertEqual(resp.status_code, 200)
        resp_json = json.loads(resp.content)
        self.assertEqual(len(resp_json), 2)
        self.assertEqual(
            resp_json[0], ["UUID", "Launched At", "Deleted At", "Instance Type Id", "Message ID", "Status"]
        )
        self.assertEqual(resp_json[1][0], INSTANCE_ID_1)
        launch_time_str = dt.dt_from_decimal(usage.launched_at)
        self.assertEqual(resp_json[1][1], str(launch_time_str))
        delete_time_str = dt.dt_from_decimal(usage.deleted_at)
        self.assertEqual(resp_json[1][2], str(delete_time_str))
        self.mox.VerifyAll()

    def test_process_usage_for_updates_revert_end(self):
        when_time = datetime.datetime.utcnow()
        when_decimal = utils.decimal_utc(when_time)
        notif = utils.create_nova_notif(request_id=REQUEST_ID_1,
                                        launched=str(when_time))
        json_str = json.dumps(notif)
        event = 'compute.instance.resize.revert.end'
        raw = utils.create_raw(self.mox, when_decimal, event=event,
                               json_str=json_str)
        usage = self.mox.CreateMockAnything()
        usage.instance = INSTANCE_ID_1
        usage.request_id = REQUEST_ID_1
        usage.instance_type_id = '1'
        views.STACKDB.get_or_create_instance_usage(instance=INSTANCE_ID_1,
                                                   request_id=REQUEST_ID_1)\
                     .AndReturn((usage, True))
        views.STACKDB.save(usage)
        self.mox.ReplayAll()

        views._process_usage_for_updates(raw, notif[1])
        self.assertEqual(usage.instance, INSTANCE_ID_1)
        self.assertEqual(usage.request_id, REQUEST_ID_1)
        self.assertEqual(usage.instance_type_id, '1')
        self.assertEqual(usage.launched_at, when_decimal)
        self.mox.VerifyAll()

    def test_process_usage_for_new_launch_rescue_start_when_launched_at_in_db(self):
        notification = self.mox.CreateMockAnything()
        notification.launched_at = str(DUMMY_TIME)
        notification.tenant = TENANT_ID_1
        notification.rax_options = RAX_OPTIONS_1
        notification.os_architecture = OS_ARCH_1
        notification.os_version = OS_VERSION_1
        notification.os_distro = OS_DISTRO_1
        notification.instance = INSTANCE_ID_1
        notification.request_id = REQUEST_ID_1
        notification.instance_type_id = INSTANCE_TYPE_ID_1

        raw = self.mox.CreateMockAnything()
        raw.event = 'compute.instance.rescue.start'

        orig_launched_at = utils.decimal_utc(DUMMY_TIME - datetime.timedelta(days=1))
        usage = self.mox.CreateMockAnything()
        usage.launched_at = orig_launched_at
        views.STACKDB.get_or_create_instance_usage(instance=INSTANCE_ID_1,
                                                   request_id=REQUEST_ID_1) \
            .AndReturn((usage, True))
        views.STACKDB.save(usage)
        self.mox.ReplayAll()

        views._process_usage_for_new_launch(raw, notification)

        self.assertEqual(usage.launched_at, orig_launched_at)
        self.assertEqual(usage.tenant, TENANT_ID_1)
        self.assertEquals(usage.os_architecture, OS_ARCH_1)
        self.assertEquals(usage.os_version, OS_VERSION_1)
        self.assertEquals(usage.os_distro, OS_DISTRO_1)
        self.assertEquals(usage.rax_options, RAX_OPTIONS_1)

        self.mox.VerifyAll()

    def test_process_raw_data_old_timestamp(self):
        deployment = self.mox.CreateMockAnything()
        when = '2013-1-25T13:38:23.123'
        dict = {
            '_context_timestamp': when,
            }
        args = ('monitor.info', dict)
        json_args = json.dumps(args[1])
        raw_values = {
            'deployment': deployment,
            'when': utils.decimal_utc(datetime.datetime.strptime(when, '%Y-%m-%dT%H:%M:%S.%f')),
            'host': 'api',
            'routing_key': 'monitor.info',
            'json': json_args
        }
        old_info_handler = views.NOTIFICATIONS['monitor.info']
        mock_notification = self.mox.CreateMockAnything()
        mock_notification.rawdata_kwargs(deployment, 'monitor.info', json_args).AndReturn(raw_values)
        views.NOTIFICATIONS['monitor.info'] = lambda message_body: mock_notification

        views.STACKDB.create_rawdata(**raw_values)
        self.mox.ReplayAll()
        views.process_raw_data(deployment, args, json_args)
        self.mox.VerifyAll()

        views.NOTIFICATIONS['monitor.info'] = old_info_handler

 def test_process_raw_data_old_timestamp(self):
     deployment = self.mox.CreateMockAnything()
     when = '2013-1-25T13:38:23.123'
     dict = {
         '_context_timestamp': when,
         }
     args = ('monitor.info', dict)
     json_args = json.dumps(args)
     old_info_handler = views.HANDLERS['monitor.info']
     views.HANDLERS['monitor.info'] = lambda key, mess: {'host': 'api'}
     raw_values = {
         'deployment': deployment,
         'when': utils.decimal_utc(datetime.datetime.strptime(when, "%Y-%m-%dT%H:%M:%S.%f")),
         'host': 'api',
         'routing_key': 'monitor.info',
         'json': json_args
     }
     raw = self.mox.CreateMockAnything()
     views.STACKDB.create_rawdata(**raw_values).AndReturn(raw)
     views.STACKDB.save(raw)
     self.mox.StubOutWithMock(views, "aggregate_lifecycle")
     views.aggregate_lifecycle(raw)
     self.mox.StubOutWithMock(views, "aggregate_usage")
     views.aggregate_usage(raw, dict)
     self.mox.ReplayAll()
     views.process_raw_data(deployment, args, json_args)
     self.mox.VerifyAll()
     views.HANDLERS['monitor.info'] = old_info_handler

    def test_do_list_usage_launches_with_instance(self):
        fake_request = self.mox.CreateMockAnything()
        fake_request.GET = {'instance': INSTANCE_ID_1}
        results = self.mox.CreateMockAnything()
        models.InstanceUsage.objects.filter(instance=INSTANCE_ID_1)\
                                    .AndReturn(results)
        usage = self.mox.CreateMockAnything()
        usage.instance = INSTANCE_ID_1
        usage.launched_at = utils.decimal_utc()
        usage.instance_type_id = 1
        results.__iter__().AndReturn([usage].__iter__())
        self.mox.ReplayAll()

        resp = stacky_server.do_list_usage_launches(fake_request)
        self.assertEqual(resp.status_code, 200)
        resp_json = json.loads(resp.content)
        self.assertEqual(len(resp_json), 2)
        self.assertEqual(resp_json[0], ["UUID", "Launched At",
                                        "Instance Type Id"])
        self.assertEqual(resp_json[1][0], INSTANCE_ID_1)
        time_str = dt.dt_from_decimal(usage.launched_at)
        self.assertEqual(resp_json[1][1], str(time_str))
        self.assertEqual(resp_json[1][2], 1)

        self.mox.VerifyAll()

    def test_process_usage_for_new_launch_resize_prep_start_when_no_launched_at_in_db(self):
        notification = self._create_mock_notification()
        raw = self.mox.CreateMockAnything()
        raw.event = 'compute.instance.resize.prep.start'

        usage = self.mox.CreateMockAnything()
        usage.launched_at = None
        views.STACKDB.get_or_create_instance_usage(instance=INSTANCE_ID_1,
                                                   request_id=REQUEST_ID_1) \
            .AndReturn((usage, True))
        views.STACKDB.save(usage)
        self.mox.ReplayAll()

        usage.launched_at = None

        views._process_usage_for_new_launch(raw, notification)

        self.assertEqual(usage.launched_at, utils.decimal_utc(DUMMY_TIME))
        self.assertEquals(usage.tenant, TENANT_ID_1)
        self.assertEquals(usage.os_architecture, OS_ARCH_1)
        self.assertEquals(usage.os_version, OS_VERSION_1)
        self.assertEquals(usage.os_distro, OS_DISTRO_1)
        self.assertEquals(usage.rax_options, RAX_OPTIONS_1)

        self.mox.VerifyAll()