def setUp(self):
     super(TestBackupController, self).setUp()
     self.uuid = "d6338c9c-3cc8-4313-b98f-13cc0684cf15"
     self.invalid_uuid = "ead-edsa-e23-sdf-23"
     self.controller = BackupController()
     self.context = context.TroveContext(project_id=str(uuid.uuid4()))
     util.init_db()
 def test_validate_create_complete(self):
     body = {"backup": {"instance": "d6338c9c-3cc8-4313-b98f-13cc0684cf15",
                        "name": "testback-backup"}}
     controller = BackupController()
     schema = controller.get_schema('create', body)
     validator = jsonschema.Draft4Validator(schema)
     self.assertTrue(validator.is_valid(body))
Example #3
0
class TestBackupController(TestCase):
    def setUp(self):
        super(TestBackupController, self).setUp()
        self.uuid = "d6338c9c-3cc8-4313-b98f-13cc0684cf15"
        self.invalid_uuid = "ead-edsa-e23-sdf-23"
        self.controller = BackupController()

    def test_validate_create_complete(self):
        body = {"backup": {"instance": self.uuid, "name": "testback-backup"}}
        schema = self.controller.get_schema('create', body)
        validator = jsonschema.Draft4Validator(schema)
        self.assertTrue(validator.is_valid(body))

    def test_validate_create_invalid_uuid(self):
        body = {
            "backup": {
                "instance": self.invalid_uuid,
                "name": "testback-backup"
            }
        }
        schema = self.controller.get_schema('create', body)
        validator = jsonschema.Draft4Validator(schema)
        self.assertFalse(validator.is_valid(body))
        errors = sorted(validator.iter_errors(body), key=lambda e: e.path)
        self.assertThat(
            errors[0].message,
            Equals("'%s' does not match '%s'" %
                   (self.invalid_uuid, apischema.uuid['pattern'])))

    def test_validate_create_incremental(self):
        body = {
            "backup": {
                "instance": self.uuid,
                "name": "testback-backup",
                "parent_id": self.uuid
            }
        }
        schema = self.controller.get_schema('create', body)
        validator = jsonschema.Draft4Validator(schema)
        self.assertTrue(validator.is_valid(body))

    def test_invalid_parent_id(self):
        body = {
            "backup": {
                "instance": self.uuid,
                "name": "testback-backup",
                "parent_id": self.invalid_uuid
            }
        }
        schema = self.controller.get_schema('create', body)
        validator = jsonschema.Draft4Validator(schema)
        self.assertFalse(validator.is_valid(body))
        errors = sorted(validator.iter_errors(body), key=lambda e: e.path)
        self.assertThat(
            errors[0].message,
            Equals("'%s' does not match '%s'" %
                   (self.invalid_uuid, apischema.uuid['pattern'])))
Example #4
0
 def test_validate_create_complete(self):
     body = {
         "backup": {
             "instance": "d6338c9c-3cc8-4313-b98f-13cc0684cf15",
             "name": "testback-backup"
         }
     }
     controller = BackupController()
     schema = controller.get_schema('create', body)
     validator = jsonschema.Draft4Validator(schema)
     self.assertTrue(validator.is_valid(body))
 def test_validate_create_invalid_uuid(self):
     invalid_uuid = "ead-edsa-e23-sdf-23"
     body = {"backup": {"instance": invalid_uuid,
                        "name": "testback-backup"}}
     controller = BackupController()
     schema = controller.get_schema('create', body)
     validator = jsonschema.Draft4Validator(schema)
     self.assertFalse(validator.is_valid(body))
     errors = sorted(validator.iter_errors(body), key=lambda e: e.path)
     self.assertThat(errors[0].message,
                     Equals("'%s' does not match '%s'" %
                            (invalid_uuid, apischema.uuid['pattern'])))
Example #6
0
 def _backups_router(self, mapper):
     backups_resource = BackupController().create_resource()
     path = "/{tenant_id}/backups"
     mapper.resource("backups",
                     path,
                     controller=backups_resource,
                     member={'action': 'POST'})
Example #7
0
 def test_validate_create_invalid_uuid(self):
     invalid_uuid = "ead-edsa-e23-sdf-23"
     body = {
         "backup": {
             "instance": invalid_uuid,
             "name": "testback-backup"
         }
     }
     controller = BackupController()
     schema = controller.get_schema('create', body)
     validator = jsonschema.Draft4Validator(schema)
     self.assertFalse(validator.is_valid(body))
     errors = sorted(validator.iter_errors(body), key=lambda e: e.path)
     self.assertThat(
         errors[0].message,
         Equals("'%s' does not match '%s'" %
                (invalid_uuid, apischema.uuid['pattern'])))
Example #8
0
 def _backups_router(self, mapper):
     backups_resource = BackupController().create_resource()
     mapper.connect("/{tenant_id}/backups",
                    controller=backups_resource,
                    action="index",
                    conditions={'method': ['GET']})
     mapper.connect("/{tenant_id}/backups",
                    controller=backups_resource,
                    action="create",
                    conditions={'method': ['POST']})
     mapper.connect("/{tenant_id}/backups/{id}",
                    controller=backups_resource,
                    action="show",
                    conditions={'method': ['GET']})
     mapper.connect("/{tenant_id}/backups/{id}",
                    controller=backups_resource,
                    action="delete",
                    conditions={'method': ['DELETE']})
Example #9
0
 def setUp(self):
     super(TestBackupController, self).setUp()
     self.uuid = "d6338c9c-3cc8-4313-b98f-13cc0684cf15"
     self.invalid_uuid = "ead-edsa-e23-sdf-23"
     self.controller = BackupController()
 def setUp(self):
     super(TestBackupController, self).setUp()
     self.uuid = "d6338c9c-3cc8-4313-b98f-13cc0684cf15"
     self.invalid_uuid = "ead-edsa-e23-sdf-23"
     self.controller = BackupController()
class TestBackupController(TestCase):

    def setUp(self):
        super(TestBackupController, self).setUp()
        self.uuid = "d6338c9c-3cc8-4313-b98f-13cc0684cf15"
        self.invalid_uuid = "ead-edsa-e23-sdf-23"
        self.controller = BackupController()

    def test_validate_create_complete(self):
        body = {"backup": {"instance": self.uuid,
                           "name": "testback-backup"}}
        schema = self.controller.get_schema('create', body)
        validator = jsonschema.Draft4Validator(schema)
        self.assertTrue(validator.is_valid(body))

    def test_validate_create_with_blankname(self):
        body = {"backup": {"instance": self.uuid,
                           "name": ' '}}
        schema = self.controller.get_schema('create', body)
        validator = jsonschema.Draft4Validator(schema)
        self.assertFalse(validator.is_valid(body))
        errors = sorted(validator.iter_errors(body), key=lambda e: e.path)
        self.assertEqual(1, len(errors))
        self.assertIn("' ' does not match '^.*[0-9a-zA-Z]+.*$'",
                      errors[0].message)

    def test_validate_create_with_invalidname(self):
        body = {"backup": {"instance": self.uuid,
                           "name": '$#@&?'}}
        schema = self.controller.get_schema('create', body)
        validator = jsonschema.Draft4Validator(schema)
        self.assertFalse(validator.is_valid(body))
        errors = sorted(validator.iter_errors(body), key=lambda e: e.path)
        self.assertEqual(1, len(errors))
        self.assertIn("'$#@&?' does not match '^.*[0-9a-zA-Z]+.*$'",
                      errors[0].message)

    def test_validate_create_invalid_uuid(self):
        body = {"backup": {"instance": self.invalid_uuid,
                           "name": "testback-backup"}}
        schema = self.controller.get_schema('create', body)
        validator = jsonschema.Draft4Validator(schema)
        self.assertFalse(validator.is_valid(body))
        errors = sorted(validator.iter_errors(body), key=lambda e: e.path)
        self.assertThat(errors[0].message,
                        Equals("'%s' does not match '%s'" %
                               (self.invalid_uuid, apischema.uuid['pattern'])))

    def test_validate_create_incremental(self):
        body = {"backup": {"instance": self.uuid,
                           "name": "testback-backup",
                           "parent_id": self.uuid}}
        schema = self.controller.get_schema('create', body)
        validator = jsonschema.Draft4Validator(schema)
        self.assertTrue(validator.is_valid(body))

    def test_invalid_parent_id(self):
        body = {"backup": {"instance": self.uuid,
                           "name": "testback-backup",
                           "parent_id": self.invalid_uuid}}
        schema = self.controller.get_schema('create', body)
        validator = jsonschema.Draft4Validator(schema)
        self.assertFalse(validator.is_valid(body))
        errors = sorted(validator.iter_errors(body), key=lambda e: e.path)
        self.assertThat(errors[0].message,
                        Equals("'%s' does not match '%s'" %
                               (self.invalid_uuid, apischema.uuid['pattern'])))
Example #12
0
class TestBackupController(trove_testtools.TestCase):
    def setUp(self):
        super(TestBackupController, self).setUp()
        self.uuid = "d6338c9c-3cc8-4313-b98f-13cc0684cf15"
        self.invalid_uuid = "ead-edsa-e23-sdf-23"
        self.controller = BackupController()
        self.context = context.TroveContext(project_id=str(uuid.uuid4()))
        util.init_db()

    def tearDown(self):
        super(TestBackupController, self).tearDown()
        backups = models.DBBackup.find_all(tenant_id=self.context.project_id)
        for backup in backups:
            backup.delete()

    def test_validate_create_complete(self):
        body = {"backup": {"instance": self.uuid, "name": "testback-backup"}}
        schema = self.controller.get_schema('create', body)
        validator = jsonschema.Draft4Validator(schema)
        self.assertTrue(validator.is_valid(body))

    def test_validate_create_with_blankname(self):
        body = {"backup": {"instance": self.uuid, "name": ' '}}
        schema = self.controller.get_schema('create', body)
        validator = jsonschema.Draft4Validator(schema)
        self.assertFalse(validator.is_valid(body))
        errors = sorted(validator.iter_errors(body), key=lambda e: e.path)
        self.assertEqual(1, len(errors))
        self.assertIn("' ' does not match '^.*[0-9a-zA-Z]+.*$'",
                      errors[0].message)

    def test_validate_create_with_invalidname(self):
        body = {"backup": {"instance": self.uuid, "name": '$#@&?'}}
        schema = self.controller.get_schema('create', body)
        validator = jsonschema.Draft4Validator(schema)
        self.assertFalse(validator.is_valid(body))
        errors = sorted(validator.iter_errors(body), key=lambda e: e.path)
        self.assertEqual(1, len(errors))
        self.assertIn("'$#@&?' does not match '^.*[0-9a-zA-Z]+.*$'",
                      errors[0].message)

    def test_validate_create_invalid_uuid(self):
        body = {
            "backup": {
                "instance": self.invalid_uuid,
                "name": "testback-backup"
            }
        }
        schema = self.controller.get_schema('create', body)
        validator = jsonschema.Draft4Validator(schema)
        self.assertFalse(validator.is_valid(body))
        errors = sorted(validator.iter_errors(body), key=lambda e: e.path)
        self.assertThat(
            errors[0].message,
            Equals("'%s' does not match '%s'" %
                   (self.invalid_uuid, apischema.uuid['pattern'])))

    def test_validate_create_incremental(self):
        body = {
            "backup": {
                "instance": self.uuid,
                "name": "testback-backup",
                "parent_id": self.uuid
            }
        }
        schema = self.controller.get_schema('create', body)
        validator = jsonschema.Draft4Validator(schema)
        self.assertTrue(validator.is_valid(body))

    def test_invalid_parent_id(self):
        body = {
            "backup": {
                "instance": self.uuid,
                "name": "testback-backup",
                "parent_id": self.invalid_uuid
            }
        }
        schema = self.controller.get_schema('create', body)
        validator = jsonschema.Draft4Validator(schema)
        self.assertFalse(validator.is_valid(body))
        errors = sorted(validator.iter_errors(body), key=lambda e: e.path)
        self.assertThat(
            errors[0].message,
            Equals("'%s' does not match '%s'" %
                   (self.invalid_uuid, apischema.uuid['pattern'])))

    def test_list_by_project(self):
        req = mock.MagicMock(GET={'project_id': self.context.project_id},
                             environ={wsgi.CONTEXT_KEY: self.context},
                             url='http://localhost')
        instance_id = str(uuid.uuid4())
        backup_name = str(uuid.uuid4())
        location = 'https://object-storage.com/tenant/database_backups/backup'
        models.DBBackup.create(tenant_id=self.context.project_id,
                               name=backup_name,
                               state=state.BackupState.NEW,
                               instance_id=instance_id,
                               deleted=False,
                               size=2.0,
                               location=location)

        res = self.controller.index(req, 'fake_tenant_id')

        self.assertEqual(200, res.status)
        backups = res.data(None)['backups']
        self.assertGreaterEqual(len(backups), 1)
        our_backup = None
        for backup in backups:
            if backup['name'] == backup_name:
                our_backup = backup
                break
        self.assertIsNotNone(our_backup)
        expected = {
            'name': backup_name,
            'locationRef': location,
            'instance_id': instance_id,
            'size': 2.0,
            'status': 'NEW',
        }
        self.assertTrue(
            set(expected.items()).issubset(set(our_backup.items())))

        # Get backups of unknown project
        req = mock.MagicMock(GET={'project_id': str(uuid.uuid4())},
                             environ={wsgi.CONTEXT_KEY: self.context},
                             url='http://localhost')

        res = self.controller.index(req, 'fake_tenant_id')

        self.assertEqual(200, res.status)
        backups = res.data(None)['backups']
        self.assertEqual(0, len(backups))