pact_broker 1.18.0 → 2.0.0.beta.1

data/lib/pact_broker/pacts/all_pacts.rb

@@ -1,96 +1,11 @@
-require 'pact_broker/domain/tag'
-require 'pact_broker/domain/pacticipant'
-require 'pact_broker/domain/version'
-require 'pact_broker/pacts/pact_version_content'
-require 'pact_broker/repositories/helpers'
+require 'pact_broker/pacts/all_pact_publications'
 
 module PactBroker
   module Pacts
 
-    class AllPacts < Sequel::Model(:all_pacts)
-
-      set_primary_key :id
-      associate(:one_to_many, :tags, :class => "PactBroker::Domain::Tag", :reciprocal => :version, :key => :version_id, :primary_key => :consumer_version_id)
-      associate(:many_to_one, :pact_version_content, :key => :pact_version_content_sha, :primary_key => :sha)
-
-      dataset_module do
-      #   def latest_versions
-      #     join(:latest_pact_consumer_version_orders,
-      #       {
-      #         consumer_id: :consumer_id,
-      #         provider_id: :provider_id,
-      #         latest_consumer_version_order: :consumer_version_order
-      #       },
-      #       {table_alias: :lp}
-      #     )
-      #   end
-        include PactBroker::Repositories::Helpers
-
-        def consumer consumer_name
-          where(name_like(:consumer_name, consumer_name))
-        end
-
-        def provider provider_name
-          where(name_like(:provider_name, provider_name))
-        end
-
-        def tag tag_name
-          filter = name_like(Sequel.qualify(:tags, :name), tag_name)
-          join(:tags, {version_id: :consumer_version_id}).where(filter)
-        end
-
-        def consumer_version_number number
-          where(name_like(:consumer_version_number, number))
-        end
-
-        def consumer_version_order_before order
-          where('consumer_version_order < ?', order)
-        end
-
-        def consumer_version_order_after order
-          where('consumer_version_order > ?', order)
-        end
-
-        def latest
-          reverse_order(:consumer_version_order).limit(1)
-        end
-
-        def earliest
-          order(:consumer_version_order).limit(1)
-        end
-      end
-
-      def to_domain
-        domain = to_domain_without_tags
-        domain.consumer_version.tags = tags
-        domain
-      end
-
-      def to_domain_without_tags
-        consumer = Domain::Pacticipant.new(name: consumer_name)
-        consumer.id = consumer_id
-        provider = Domain::Pacticipant.new(name: provider_name)
-        provider.id = provider_id
-        consumer_version = OpenStruct.new(
-          number: consumer_version_number,
-          order: consumer_version_order,
-          pacticipant: consumer,
-          tags: nil)
-        Domain::Pact.new(id: id,
-          consumer: consumer,
-          consumer_version: consumer_version,
-          provider: provider,
-          consumer_version_number: consumer_version_number,
-          created_at: created_at,
-          updated_at: updated_at)
-      end
-
-      def to_domain_with_content
-        to_domain.tap do | pact |
-          pact.json_content = pact_version_content.content
-        end
-      end
-
+    # See /DEVELOPER_DOCUMENTATION.md for all_pacts view
+    class AllPacts < AllPactPublications
+      set_dataset(:all_pacts)
     end
 
   end

data/lib/pact_broker/pacts/diff.rb

@@ -62,7 +62,7 @@ module PactBroker
         attr_reader :pact, :previous_distinct_pact, :next_pact, :base_url
 
         def change_date_in_words
-          DateHelper.local_date_in_words next_pact.updated_at
+          DateHelper.local_date_in_words next_pact.created_at
         end
 
         def now
@@ -100,7 +100,7 @@ module PactBroker
         end
 
         def change_date_ago_in_words
-          DateHelper.distance_of_time_in_words next_pact.updated_at, now
+          DateHelper.distance_of_time_in_words next_pact.created_at, now
         end
       end
     end

data/lib/pact_broker/pacts/latest_pact_publications.rb

@@ -0,0 +1,11 @@
+require 'pact_broker/pacts/latest_pact_publications_by_consumer_version'
+
+module PactBroker
+  module Pacts
+
+    class LatestPactPublications < LatestPactPublicationsByConsumerVersion
+      set_dataset(:latest_pact_publications)
+    end
+
+  end
+end

data/lib/pact_broker/pacts/latest_pact_publications_by_consumer_version.rb

@@ -0,0 +1,11 @@
+require 'pact_broker/pacts/all_pact_publications'
+
+module PactBroker
+  module Pacts
+
+    class LatestPactPublicationsByConsumerVersion < AllPactPublications
+      set_dataset(:latest_pact_publications_by_consumer_versions)
+    end
+
+  end
+end

data/lib/pact_broker/pacts/latest_pacts.rb

@@ -3,6 +3,7 @@ require 'pact_broker/pacts/all_pacts'
 module PactBroker
   module Pacts
 
+    # See /DEVELOPER_DOCUMENTATION.md for latest_pacts view
     class LatestPacts < AllPacts
       set_dataset(:latest_pacts)
     end

data/lib/pact_broker/pacts/latest_tagged_pact_publications.rb

@@ -0,0 +1,11 @@
+require 'pact_broker/pacts/latest_pact_publications_by_consumer_version'
+
+module PactBroker
+  module Pacts
+
+    class LatestTaggedPactPublications < LatestPactPublicationsByConsumerVersion
+      set_dataset(:latest_tagged_pact_publications)
+    end
+
+  end
+end

data/lib/pact_broker/pacts/pact_params.rb

@@ -24,7 +24,9 @@ module PactBroker
         new(
           consumer_name: path_info.fetch(:consumer_name),
           provider_name: path_info.fetch(:provider_name),
-          consumer_version_number: path_info.fetch(:consumer_version_number),
+          revision_number: path_info[:revision_number],
+          consumer_version_number: path_info[:consumer_version_number],
+          pact_version_sha: path_info[:pact_version_sha],
           consumer_name_in_pact: consumer_name_in_pact,
           provider_name_in_pact: provider_name_in_pact,
           json_content: json_content
@@ -47,6 +49,14 @@ module PactBroker
         self[:consumer_version_number]
       end
 
+      def pact_version_sha
+        self[:pact_version_sha]
+      end
+
+      def revision_number
+        self[:revision_number]
+      end
+
       def json_content
         self[:json_content]
       end

data/lib/pact_broker/pacts/pact_publication.rb

@@ -0,0 +1,50 @@
+require 'pact_broker/domain/pact'
+require 'pact_broker/pacts/pact_version'
+
+module PactBroker
+  module Pacts
+
+    class PactPublication < Sequel::Model(:pact_publications)
+
+      extend Forwardable
+
+      delegate [:consumer, :consumer_version_number, :name, :provider_name, :consumer_name] => :cached_domain_for_delegation
+
+      set_primary_key :id
+      associate(:many_to_one, :provider, :class => "PactBroker::Domain::Pacticipant", :key => :provider_id, :primary_key => :id)
+      associate(:many_to_one, :consumer_version, :class => "PactBroker::Domain::Version", :key => :consumer_version_id, :primary_key => :id)
+      associate(:many_to_one, :pact_version, class: "PactBroker::Pacts::PactVersion", :key => :pact_version_id, :primary_key => :id)
+
+      PactPublication.plugin :timestamps, :update_on_create=>true
+
+      def before_create
+        super
+        self.revision_number ||= 1
+      end
+
+      def to_domain
+        PactBroker::Domain::Pact.new(
+          id: id,
+          provider: provider,
+          consumer: consumer_version.pacticipant,
+          consumer_version_number: consumer_version.number,
+          consumer_version: to_version_domain,
+          revision_number: revision_number,
+          json_content: pact_version.content,
+          pact_version_sha: pact_version.sha,
+          created_at: created_at
+          )
+      end
+
+      def to_version_domain
+        OpenStruct.new(number: consumer_version.number, pacticipant: consumer_version.pacticipant, tags: consumer_version.tags, order: consumer_version.order)
+      end
+
+      private
+
+      def cached_domain_for_delegation
+        @domain_object ||= to_domain
+      end
+    end
+  end
+end

data/lib/pact_broker/pacts/pact_version.rb

@@ -0,0 +1,39 @@
+require 'sequel'
+
+module PactBroker
+  module Pacts
+    class PactVersion < Sequel::Model(:pact_versions)
+      one_to_many :pact_publications, :reciprocal => :pact_version
+
+      def name
+        "Pact between #{consumer_name} and #{provider_name}"
+      end
+
+      def provider_name
+        pact_publications.last.provider.name
+      end
+
+      def consumer_name
+        pact_publications.last.consumer.name
+      end
+
+      def latest_consumer_version
+        consumer_versions.last
+      end
+
+      def latest_pact_publication
+        latest_consumer_version.latest_pact_publication
+      end
+
+      def consumer_versions
+        PactBroker::Domain::Version.where(id: PactBroker::Pacts::PactPublication.select(:consumer_version_id).where(pact_version_id: id)).order(:order)
+      end
+
+      def latest_consumer_version_number
+        latest_consumer_version.number
+      end
+    end
+
+    PactVersion.plugin :timestamps
+  end
+end

data/lib/pact_broker/pacts/repository.rb

@@ -2,11 +2,13 @@ require 'digest/sha1'
 require 'sequel'
 require 'ostruct'
 require 'pact_broker/logging'
-require 'pact_broker/pacts/database_model'
-require 'pact_broker/pacts/all_pacts'
-require 'pact_broker/pacts/latest_pacts'
-require 'pact_broker/pacts/latest_tagged_pacts'
+require 'pact_broker/pacts/pact_publication'
+require 'pact_broker/pacts/all_pact_publications'
+require 'pact_broker/pacts/latest_pact_publications_by_consumer_version'
+require 'pact_broker/pacts/latest_pact_publications'
+require 'pact_broker/pacts/latest_tagged_pact_publications'
 require 'pact/shared/json_differ'
+require 'pact_broker/domain'
 
 module PactBroker
   module Pacts
@@ -15,31 +17,39 @@ module PactBroker
       include PactBroker::Logging
 
       def create params
-        DatabaseModel.new(
-          version_id: params[:version_id],
+        PactPublication.new(
+          consumer_version_id: params[:version_id],
           provider_id: params[:provider_id],
-          pact_version_content: find_or_create_pact_version_content(params[:json_content]),
+          pact_version: find_or_create_pact_version(params.fetch(:consumer_id), params.fetch(:provider_id), params[:json_content]),
         ).save.to_domain
       end
 
       def update id, params
-        DatabaseModel.find(id: id).tap do | pact |
-          pact_version_content = find_or_create_pact_version_content(params[:json_content])
-          pact.update(pact_version_content: pact_version_content)
-        end.to_domain
+        existing_model = PactPublication.find(id: id)
+        pact_version = find_or_create_pact_version(existing_model.consumer_version.pacticipant_id, existing_model.provider_id, params[:json_content])
+        if existing_model.pact_version_id != pact_version.id
+          PactPublication.new(
+            consumer_version_id: existing_model.consumer_version_id,
+            provider_id: existing_model.provider_id,
+            revision_number: (existing_model.revision_number + 1),
+            pact_version: pact_version,
+          ).save.to_domain
+        else
+          existing_model.to_domain
+        end
       end
 
       def delete params
-        id = AllPacts
+        id = AllPactPublications
           .consumer(params.consumer_name)
           .provider(params.provider_name)
           .consumer_version_number(params.consumer_version_number)
-          .limit(1).first.id
-        DatabaseModel.where(id: id).delete
+          .select(:id)
+        PactPublication.where(id: id).delete
       end
 
       def find_all_pact_versions_between consumer_name, options
-        AllPacts
+        LatestPactPublicationsByConsumerVersion
           .eager(:tags)
           .consumer(consumer_name)
           .provider(options.fetch(:and))
@@ -49,42 +59,43 @@ module PactBroker
 
       def find_latest_pact_versions_for_provider provider_name, tag = nil
         if tag
-          LatestTaggedPacts.provider(provider_name).where(tag_name: tag).collect(&:to_domain)
+          LatestTaggedPactPublications.provider(provider_name).where(tag_name: tag).collect(&:to_domain)
         else
-          LatestPacts.provider(provider_name).collect(&:to_domain)
+          LatestPactPublications.provider(provider_name).collect(&:to_domain)
         end
       end
 
       def find_by_version_and_provider version_id, provider_id
-        AllPacts
+        LatestPactPublicationsByConsumerVersion
           .eager(:tags)
           .where(consumer_version_id: version_id, provider_id: provider_id)
           .limit(1).collect(&:to_domain_with_content)[0]
       end
 
       def find_latest_pacts
-        LatestPacts.collect(&:to_domain_without_tags)
+        LatestPactPublications.collect(&:to_domain_without_tags)
       end
 
       def find_latest_pact(consumer_name, provider_name, tag = nil)
-        query = AllPacts
+        query = LatestPactPublicationsByConsumerVersion
           .consumer(consumer_name)
           .provider(provider_name)
         query = query.tag(tag) unless tag.nil?
         query.latest.all.collect(&:to_domain_with_content)[0]
       end
 
-      def find_pact consumer_name, consumer_version, provider_name
-        AllPacts
+      def find_pact consumer_name, consumer_version, provider_name, pact_version_sha = nil
+        query = pact_version_sha ? AllPactPublications.pact_version_sha(pact_version_sha) : LatestPactPublicationsByConsumerVersion
+        query = query
           .eager(:tags)
           .consumer(consumer_name)
           .provider(provider_name)
-          .consumer_version_number(consumer_version)
-          .limit(1).collect(&:to_domain_with_content)[0]
+        query = query.consumer_version_number(consumer_version) if consumer_version
+        query.limit(1).collect(&:to_domain_with_content)[0]
       end
 
       def find_previous_pact pact
-        AllPacts
+        LatestPactPublicationsByConsumerVersion
           .eager(:tags)
           .consumer(pact.consumer.name)
           .provider(pact.provider.name)
@@ -93,7 +104,7 @@ module PactBroker
       end
 
       def find_next_pact pact
-        AllPacts
+        LatestPactPublicationsByConsumerVersion
           .eager(:tags)
           .consumer(pact.consumer.name)
           .provider(pact.provider.name)
@@ -114,18 +125,18 @@ module PactBroker
 
       def find_previous_distinct_pact_by_sha pact
         current_pact_content_sha =
-          AllPacts.select(:pact_version_content_sha)
+          LatestPactPublicationsByConsumerVersion.select(:pact_version_sha)
           .consumer(pact.consumer.name)
           .provider(pact.provider.name)
           .consumer_version_number(pact.consumer_version_number)
           .limit(1)
 
-        AllPacts
+        LatestPactPublicationsByConsumerVersion
           .eager(:tags)
           .consumer(pact.consumer.name)
           .provider(pact.provider.name)
           .consumer_version_order_before(pact.consumer_version.order)
-          .where('pact_version_content_sha != ?', current_pact_content_sha)
+          .where('pact_version_sha != ?', current_pact_content_sha)
           .latest
           .collect(&:to_domain_with_content)[0]
       end
@@ -134,16 +145,15 @@ module PactBroker
         Pact::JsonDiffer.(pact.content_hash, other_pact.content_hash, allow_unexpected_keys: false).any?
       end
 
-      def find_or_create_pact_version_content json_content
+      def find_or_create_pact_version consumer_id, provider_id, json_content
         sha = Digest::SHA1.hexdigest(json_content)
-        PactVersionContent.find(sha: sha) || create_pact_version_content(sha, json_content)
+        PactVersion.find(sha: sha, consumer_id: consumer_id, provider_id: provider_id) || create_pact_version(consumer_id, provider_id, sha, json_content)
       end
 
-      def create_pact_version_content sha, json_content
-        PactBroker.logger.debug("Creating new PactVersionContent for sha #{sha}")
-        pact_version_content = PactVersionContent.new(content: json_content)
-        pact_version_content[:sha] = sha
-        pact_version_content.save
+      def create_pact_version consumer_id, provider_id, sha, json_content
+        PactBroker.logger.debug("Creating new PactVersion for sha #{sha}")
+        pact_version = PactVersion.new(consumer_id: consumer_id, provider_id: provider_id, sha: sha, content: json_content)
+        pact_version.save
       end
 
     end