Merge "Add get_count() method to project resource repositories"

barbican/api/controllers/consumers.py

@@ -144,6 +144,7 @@ class ContainerConsumersController(controllers.ACLMixin):
         self.quota_enforcer.enforce(project)
 
         new_consumer = models.ContainerConsumerMetadatum(self.container_id,
+                                                         project.id,
                                                          data)
         new_consumer.project_id = project.id
         self.consumer_repo.create_or_update_from(new_consumer, container)

barbican/model/migration/alembic_migrations/versions/156cd9933643_add_project_column_to_consumer_table.py

@@ -0,0 +1,33 @@
+"""Add project column to consumer table
+
+Revision ID: 156cd9933643
+Revises: 46b98cde536
+Create Date: 2015-08-28 20:53:23.205128
+
+"""
+
+# revision identifiers, used by Alembic.
+revision = '156cd9933643'
+down_revision = '46b98cde536'
+
+from alembic import op
+import sqlalchemy as sa
+
+
+def upgrade():
+    op.add_column(
+        'container_consumer_metadata',
+        sa.Column('project_id',
+        sa.String(length=36),
+        nullable=True))
+    op.create_index(
+        op.f('ix_container_consumer_metadata_project_id'),
+        'container_consumer_metadata',
+        ['project_id'],
+        unique=False)
+    op.create_foreign_key(
+        None,
+        'container_consumer_metadata',
+        'projects',
+        ['project_id'],
+        ['id'])

barbican/model/models.py

@@ -745,6 +745,8 @@ class ContainerConsumerMetadatum(BASE, SoftDeleteMixIn, ModelBase):
 
     container_id = sa.Column(sa.String(36), sa.ForeignKey('containers.id'),
                              index=True, nullable=False)
+    project_id = sa.Column(sa.String(36), sa.ForeignKey('projects.id'),
+                           index=True, nullable=True)
     name = sa.Column(sa.String(36))
     URL = sa.Column(sa.String(500))
     data_hash = sa.Column(sa.CHAR(64))
@@ -755,7 +757,7 @@ class ContainerConsumerMetadatum(BASE, SoftDeleteMixIn, ModelBase):
         sa.Index('values_index', 'container_id', 'name', 'URL')
     )
 
-    def __init__(self, container_id, parsed_request):
+    def __init__(self, container_id, project_id, parsed_request):
         """Registers a Consumer to a Container."""
         super(ContainerConsumerMetadatum, self).__init__()
 
@@ -763,6 +765,7 @@ class ContainerConsumerMetadatum(BASE, SoftDeleteMixIn, ModelBase):
         # data_hash attribute.
         if container_id and parsed_request:
             self.container_id = container_id
+            self.project_id = project_id
             self.name = parsed_request.get('name')
             self.URL = parsed_request.get('URL')
             hash_text = ''.join((self.container_id, self.name, self.URL))

barbican/model/repositories.py

@@ -494,6 +494,24 @@ class BaseRepo(object):
         else:
             return []
 
+    def get_count(self, project_id, session=None):
+        """Gets count of entities associated with a given project
+
+        :param project_id: id of barbican project entity
+        :param session: existing db session reference. If None, gets session.
+        :return: an number 0 or greater
+
+        Sub-class should implement `_build_get_project_entities_query` function
+        to delete related entities otherwise it would raise NotImplementedError
+        on its usage.
+        """
+        session = self.get_session(session)
+        query = self._build_get_project_entities_query(project_id, session)
+        if query:
+            return query.count()
+        else:
+            return 0
+
     def delete_project_entities(self, project_id,
                                 suppress_exception=False,
                                 session=None):
@@ -1272,6 +1290,19 @@ class ContainerConsumerRepo(BaseRepo):
         """Sub-class hook: validate values."""
         pass
 
+    def _build_get_project_entities_query(self, project_id, session):
+        """Builds query for retrieving consumers associated with given project
+
+        :param project_id: id of barbican project entity
+        :param session: existing db session reference.
+        """
+        query = session.query(
+            models.ContainerConsumerMetadatum).filter_by(deleted=False)
+        query = query.filter(
+            models.ContainerConsumerMetadatum.project_id == project_id)
+
+        return query
+
 
 class TransportKeyRepo(BaseRepo):
     """Repository for the TransportKey entity

barbican/tests/api/test_resources.py

@@ -114,13 +114,15 @@ def create_container(id_ref, project_id=None, external_project_id=None):
     return container
 
 
-def create_consumer(container_id, id_ref):
+def create_consumer(container_id, project_id, id_ref):
     """Generate a ContainerConsumerMetadatum entity instance."""
     data = {
         'name': 'test name',
         'URL': 'http://test/url'
     }
-    consumer = models.ContainerConsumerMetadatum(container_id, data)
+    consumer = models.ContainerConsumerMetadatum(container_id,
+                                                 project_id,
+                                                 data)
     consumer.id = id_ref
     return consumer
 
@@ -880,8 +882,12 @@ class WhenGettingOrDeletingConsumersUsingConsumerResource(FunctionalTest):
             external_project_id=self.external_project_id)
 
         # Set up mocked consumers
-        self.consumer = create_consumer(self.container.id, id_ref='id2')
-        self.consumer2 = create_consumer(self.container.id, id_ref='id3')
+        self.consumer = create_consumer(self.container.id,
+                                        self.project_internal_id,
+                                        id_ref='id2')
+        self.consumer2 = create_consumer(self.container.id,
+                                         self.project_internal_id,
+                                         id_ref='id3')
 
         self.consumer_ref = {
             'name': self.consumer.name,
@@ -1085,8 +1091,12 @@ class WhenPerformingUnallowedOperationsOnConsumers(FunctionalTest):
             external_project_id=self.external_project_id)
 
         # Set up mocked container consumers
-        self.consumer = create_consumer(self.container.id, id_ref='id2')
-        self.consumer2 = create_consumer(self.container.id, id_ref='id3')
+        self.consumer = create_consumer(self.container.id,
+                                        self.project_internal_id,
+                                        id_ref='id2')
+        self.consumer2 = create_consumer(self.container.id,
+                                         self.project_internal_id,
+                                         id_ref='id3')
 
         self.consumer_ref = {
             'name': self.consumer.name,

barbican/tests/model/repositories/test_repositories.py

@@ -347,3 +347,34 @@ class WhenTestingMigrations(utils.BaseTestCase):
 
         if failed_revisions:
             self.fail('Migrations %s have downgrade' % failed_revisions)
+
+
+class DummyRepo(repositories.BaseRepo):
+    """Repository for the increasing code coverage of unit tests."""
+    def get_session(self, session=None):
+        return None
+
+    def _do_entity_name(self):
+        return "Dummy"
+
+    def _do_build_get_query(self, entity_id, external_project_id, session):
+        return None
+
+    def _do_validate(self, values):
+        pass
+
+    def _build_get_project_entities_query(self, project_id, session):
+        return None
+
+
+class WhenIncreasingRepositoryTestCoverage(utils.BaseTestCase):
+
+    def test_get_count_should_return_zero(self):
+        dummy_repo = DummyRepo()
+        count = dummy_repo.get_count('dummy_project_id')
+        self.assertEqual(0, count)
+
+    def test_get_project_entities_should_return_empty(self):
+        dummy_repo = DummyRepo()
+        count = dummy_repo.get_project_entities('dummy_project_id')
+        self.assertEqual([], count)

barbican/tests/model/repositories/test_repositories_consumers.py

@@ -36,7 +36,7 @@ class WhenTestingContainerConsumerRepository(utils.RepositoryTestCase):
 
         # Create a consumer.
         consumer = models.ContainerConsumerMetadatum(
-            container.id, {'name': 'name', 'URL': 'www.foo.com'})
+            container.id, project.id, {'name': 'name', 'URL': 'www.foo.com'})
         consumer.save(session=session)
 
         # Commit things so far, because the 'create_or_update_from' call below
@@ -48,7 +48,7 @@ class WhenTestingContainerConsumerRepository(utils.RepositoryTestCase):
         # Try to create a consumer on the container...should re-use the
         # one added above.
         consumer2 = models.ContainerConsumerMetadatum(
-            container.id, {'name': 'name', 'URL': 'www.foo.com'})
+            container.id, project.id, {'name': 'name', 'URL': 'www.foo.com'})
         self.repo.create_or_update_from(consumer2, container, session=session)
 
         container2 = self.repo_container.get(
@@ -68,7 +68,7 @@ class WhenTestingContainerConsumerRepository(utils.RepositoryTestCase):
 
         # Create a consumer.
         consumer = models.ContainerConsumerMetadatum(
-            container.id, {'name': 'name', 'URL': 'www.foo.com'})
+            container.id, project.id, {'name': 'name', 'URL': 'www.foo.com'})
         consumer.save(session=session)
 
         # Commit things so far, because the 'create_from' call below will
@@ -79,7 +79,7 @@ class WhenTestingContainerConsumerRepository(utils.RepositoryTestCase):
 
         # Create a new entity with the same composite key as the first one.
         consumer2 = models.ContainerConsumerMetadatum(
-            container.id, {'name': 'name', 'URL': 'www.foo.com'})
+            container.id, project.id, {'name': 'name', 'URL': 'www.foo.com'})
 
         exception_result = self.assertRaises(
             exception.Duplicate,
@@ -125,3 +125,64 @@ class WhenTestingContainerConsumerRepository(utils.RepositoryTestCase):
             session=session,
             suppress_exception=False,
             show_deleted=True)
+
+    def test_should_get_count_zero(self):
+        session = self.repo.get_session()
+
+        project = models.Project()
+        project.external_id = "my keystone id"
+        project.save(session=session)
+
+        session.commit()
+        count = self.repo.get_count(project.id, session=session)
+
+        self.assertEqual(count, 0)
+
+    def test_should_get_count_one(self):
+        session = self.repo.get_session()
+
+        project = models.Project()
+        project.external_id = "my keystone id"
+        project.save(session=session)
+
+        container = models.Container()
+        container.project_id = project.id
+        container.save(session=session)
+
+        consumer = models.ContainerConsumerMetadatum(
+            container.id, project.id, {'name': 'name', 'URL': 'www.foo.com'})
+        consumer.save(session=session)
+        session.commit()
+
+        count = self.repo.get_count(project.id, session=session)
+        self.assertEqual(count, 1)
+
+    def test_should_get_count_one_after_delete(self):
+        session = self.repo.get_session()
+
+        project = models.Project()
+        project.external_id = "my keystone id"
+        project.save(session=session)
+
+        container = models.Container()
+        container.project_id = project.id
+        container.save(session=session)
+
+        consumer = models.ContainerConsumerMetadatum(
+            container.id, project.id, {'name': 'name1', 'URL': 'www.foo.com'})
+        consumer.save(session=session)
+
+        consumer = models.ContainerConsumerMetadatum(
+            container.id, project.id, {'name': 'name2', 'URL': 'www.foo.com'})
+        consumer.save(session=session)
+        session.commit()
+
+        count = self.repo.get_count(project.id, session=session)
+        self.assertEqual(count, 2)
+
+        self.repo.delete_entity_by_id(consumer.id, "my keystone id",
+                                      session=session)
+        session.commit()
+
+        count = self.repo.get_count(project.id, session=session)
+        self.assertEqual(count, 1)

barbican/tests/model/repositories/test_repositories_containers.py

@@ -55,3 +55,57 @@ class WhenTestingContainerRepository(database_utils.RepositoryTestCase):
     def test_should_suppress_notfound_exception(self):
         self.assertIsNone(self.repo.get_container_by_id(
             "invalid_id", suppress_exception=True))
+
+    def test_should_get_count_zero(self):
+        session = self.repo.get_session()
+
+        project = models.Project()
+        project.external_id = "my keystone id"
+        project.save(session=session)
+
+        session.commit()
+        count = self.repo.get_count(project.id, session=session)
+
+        self.assertEqual(count, 0)
+
+    def test_should_get_count_one(self):
+        session = self.repo.get_session()
+
+        project = models.Project()
+        project.external_id = "my keystone id"
+        project.save(session=session)
+
+        container_model = models.Container()
+        container_model.project_id = project.id
+        self.repo.create_from(container_model, session=session)
+
+        session.commit()
+        count = self.repo.get_count(project.id, session=session)
+
+        self.assertEqual(count, 1)
+
+    def test_should_get_count_one_after_delete(self):
+        session = self.repo.get_session()
+
+        project = models.Project()
+        project.external_id = "my keystone id"
+        project.save(session=session)
+
+        container_model = models.Container()
+        container_model.project_id = project.id
+        self.repo.create_from(container_model, session=session)
+
+        container_model = models.Container()
+        container_model.project_id = project.id
+        self.repo.create_from(container_model, session=session)
+
+        session.commit()
+        count = self.repo.get_count(project.id, session=session)
+        self.assertEqual(count, 2)
+
+        self.repo.delete_entity_by_id(container_model.id, "my keystone id",
+                                      session=session)
+        session.commit()
+
+        count = self.repo.get_count(project.id, session=session)
+        self.assertEqual(count, 1)

barbican/tests/model/repositories/test_repositories_orders.py

@@ -66,3 +66,57 @@ class WhenTestingOrderRepository(database_utils.RepositoryTestCase):
         )
 
         self.assertEqual(order.id, order_from_get.id)
+
+    def test_should_get_count_zero(self):
+        session = self.repo.get_session()
+
+        project = models.Project()
+        project.external_id = "my keystone id"
+        project.save(session=session)
+
+        session.commit()
+        count = self.repo.get_count(project.id, session=session)
+
+        self.assertEqual(count, 0)
+
+    def test_should_get_count_one(self):
+        session = self.repo.get_session()
+
+        project = models.Project()
+        project.external_id = "my keystone id"
+        project.save(session=session)
+
+        order_model = models.Order()
+        order_model.project_id = project.id
+        self.repo.create_from(order_model, session=session)
+
+        session.commit()
+        count = self.repo.get_count(project.id, session=session)
+
+        self.assertEqual(count, 1)
+
+    def test_should_get_count_one_after_delete(self):
+        session = self.repo.get_session()
+
+        project = models.Project()
+        project.external_id = "my keystone id"
+        project.save(session=session)
+
+        order_model = models.Order()
+        order_model.project_id = project.id
+        self.repo.create_from(order_model, session=session)
+
+        order_model = models.Order()
+        order_model.project_id = project.id
+        self.repo.create_from(order_model, session=session)
+
+        session.commit()
+        count = self.repo.get_count(project.id, session=session)
+        self.assertEqual(count, 2)
+
+        self.repo.delete_entity_by_id(order_model.id, "my keystone id",
+                                      session=session)
+        session.commit()
+
+        count = self.repo.get_count(project.id, session=session)
+        self.assertEqual(count, 1)

barbican/tests/model/repositories/test_repositories_secrets.py

@@ -160,3 +160,57 @@ class WhenTestingSecretRepository(database_utils.RepositoryTestCase):
             "my keystone id",
             session=session,
             suppress_exception=False)
+
+    def test_should_get_count_zero(self):
+        session = self.repo.get_session()
+
+        project = models.Project()
+        project.external_id = "my keystone id"
+        project.save(session=session)
+
+        session.commit()
+        count = self.repo.get_count(project.id, session=session)
+
+        self.assertEqual(count, 0)
+
+    def test_should_get_count_one(self):
+        session = self.repo.get_session()
+
+        project = models.Project()
+        project.external_id = "my keystone id"
+        project.save(session=session)
+
+        secret_model = models.Secret()
+        secret_model.project_id = project.id
+        self.repo.create_from(secret_model, session=session)
+
+        session.commit()
+        count = self.repo.get_count(project.id, session=session)
+
+        self.assertEqual(count, 1)
+
+    def test_should_get_count_one_after_delete(self):
+        session = self.repo.get_session()
+
+        project = models.Project()
+        project.external_id = "my keystone id"
+        project.save(session=session)
+
+        secret_model = models.Secret()
+        secret_model.project_id = project.id
+        self.repo.create_from(secret_model, session=session)
+
+        secret_model = models.Secret()
+        secret_model.project_id = project.id
+        self.repo.create_from(secret_model, session=session)
+
+        session.commit()
+        count = self.repo.get_count(project.id, session=session)
+        self.assertEqual(count, 2)
+
+        self.repo.delete_entity_by_id(secret_model.id, "my keystone id",
+                                      session=session)
+        session.commit()
+
+        count = self.repo.get_count(project.id, session=session)
+        self.assertEqual(count, 1)

barbican/tests/model/test_models.py

@@ -181,10 +181,12 @@ class WhenCreatingNewConsumer(utils.BaseTestCase):
         super(WhenCreatingNewConsumer, self).setUp()
         self.parsed_consumer = {'name': 'name',
                                 'URL': 'URL'}
+        self.project_id = '12345project'
         self.container_id = '12345container'
 
     def test_new_consumer_is_created_from_dict(self):
         consumer = models.ContainerConsumerMetadatum(self.container_id,
+                                                     self.project_id,
                                                      self.parsed_consumer)
         self.assertEqual(consumer.name, self.parsed_consumer['name'])
         self.assertEqual(consumer.URL, self.parsed_consumer['URL'])
@@ -192,12 +194,14 @@ class WhenCreatingNewConsumer(utils.BaseTestCase):
 
     def test_new_consumer_has_correct_hash(self):
         consumer_one = models.ContainerConsumerMetadatum(self.container_id,
+                                                         self.project_id,
                                                          self.parsed_consumer)
         consumer_two = models.ContainerConsumerMetadatum(self.container_id,
+                                                         self.project_id,
                                                          self.parsed_consumer)
         different_container = '67890container'
         consumer_three = models.ContainerConsumerMetadatum(
-            different_container, self.parsed_consumer)
+            different_container, self.project_id, self.parsed_consumer)
         self.assertEqual(consumer_one.data_hash, consumer_two.data_hash)
         self.assertNotEqual(consumer_one.data_hash, consumer_three.data_hash)