示例#1
0
    def test_message(self):
        model = base_models.BaseModel(id='123',
                                      deleted=True,
                                      created_on=self.YEAR_AGO,
                                      last_updated=self.YEAR_AGO)
        error = audit_errors.ModelExpiredError(model)

        self.assertEqual(
            error.message,
            'ModelExpiredError in BaseModel(id=\'123\'): deleted=True when '
            'older than %d days' %
            (feconf.PERIOD_TO_HARD_DELETE_MODELS_MARKED_AS_DELETED.days))
示例#2
0
    def test_process_reports_error_for_old_deleted_model(self):
        expired_model = base_models.BaseModel(id='123',
                                              deleted=True,
                                              created_on=self.YEAR_AGO,
                                              last_updated=self.YEAR_AGO)

        output = (self.pipeline
                  | beam.Create([expired_model])
                  | beam.ParDo(base_model_audits.ValidateDeletedModel()))

        self.assert_pcoll_equal(output, [
            audit_errors.ModelExpiredError(expired_model),
        ])
示例#3
0
    def process(self, input_model):
        """Yields audit errors that are discovered in the input model.

        Args:
            input_model: datastore_services.Model. Entity to validate.

        Yields:
            ModelExpiredError. An error class for expired models.
        """
        model = jobs_utils.clone_model(input_model)

        expiration_date = (
            datetime.datetime.utcnow() -
            feconf.PERIOD_TO_HARD_DELETE_MODELS_MARKED_AS_DELETED)

        if model.last_updated < expiration_date:
            yield audit_errors.ModelExpiredError(model)
示例#4
0
    def test_base_model_audits(self):
        base_model_with_invalid_id = base_models.BaseModel(
            id='123@?!*',
            deleted=False,
            created_on=self.YEAR_AGO,
            last_updated=self.NOW)
        base_model_with_invalid_timestamps = base_models.BaseModel(
            id='124',
            deleted=False,
            created_on=self.NOW,
            last_updated=self.YEAR_LATER)
        base_model_with_inconsistent_timestamps = base_models.BaseModel(
            id='125',
            deleted=False,
            created_on=self.YEAR_LATER,
            last_updated=self.YEAR_AGO)
        expired_base_model = base_models.BaseModel(id='126',
                                                   deleted=True,
                                                   created_on=self.YEAR_AGO,
                                                   last_updated=self.YEAR_AGO)
        valid_base_model = base_models.BaseModel(id='127',
                                                 deleted=False,
                                                 created_on=self.YEAR_AGO,
                                                 last_updated=self.NOW)

        self.model_io_stub.put_multi([
            base_model_with_invalid_id,
            base_model_with_invalid_timestamps,
            base_model_with_inconsistent_timestamps,
            expired_base_model,
            valid_base_model,
        ])

        self.assert_job_output_is([
            audit_errors.ModelIdRegexError(
                base_model_with_invalid_id,
                base_model_audits.BASE_MODEL_ID_PATTERN),
            audit_errors.ModelMutatedDuringJobError(
                base_model_with_invalid_timestamps),
            audit_errors.InconsistentTimestampsError(
                base_model_with_inconsistent_timestamps),
            audit_errors.ModelExpiredError(expired_base_model),
        ])