pact_broker 2.40.0 → 2.41.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9640609d3cd63f00f72cd919503c9753e7f14901
-  data.tar.gz: c538742c6e384659661609b059e24ca1c5732ae2
+  metadata.gz: 5aea6eddd75f874a8b5e1994d0269b72e4f8745c
+  data.tar.gz: bf9c5cc37f4d5df1dcaa53d21e8c902c645a0973
 SHA512:
-  metadata.gz: 9a6918c28db99e46a2c28c6ac608aadec4efe8780369328956a8617bd1f17dd3bb8899c80f0e597920d0005e9856e0cce56303f108df98240d32556808f1fd46
-  data.tar.gz: 99cc9f3892e31cd11c449de7f4da9469f70d96df2ec6501df37225f3d98b5068ac71fbf42e1f359e5acbe7c29f572aa2d6baaa066a180c3ffa65fea29e777979
+  metadata.gz: ea61f5bf743380ce29ab3ad0d5dadf842ae5aead4e0dd209157c8841ccbfc9b0614245463eaf596b40764e349635652394144f2769fc3ffd6a1f900e7e45a930
+  data.tar.gz: 1c023a21856fbbb8ca7e8a172b0720016b7509231270b64cf18a8bc8f6ba485131484debf7d261a7a6aff9cfd90de4d7b927da00d793e1744be679322f567d33

data/CHANGELOG.md

@@ -1,3 +1,39 @@
+<a name="v2.41.0"></a>
+### v2.41.0 (2019-11-21)
+
+
+#### Features
+
+* **pacts for verification**
+  * make latest flag required and true for now, until the 'all pacts for tag' is implemented	 ([ebbbbec9](/../../commit/ebbbbec9))
+  * include WIP pacts in list of pacts to verify	 ([04a0f40c](/../../commit/04a0f40c))
+  * allow pending status information to be optionall included	 ([a80f2fd6](/../../commit/a80f2fd6))
+  * support querying by POST	 ([5556b814](/../../commit/5556b814))
+
+* **matrix**
+  * show pact version SHA in popup text, and highlight pact publications with the same pact version	 ([0d539093](/../../commit/0d539093))
+  * update 'pre-verifed' pop up text, and add icon to indicate when a pact is pre-verified	 ([a86010e5](/../../commit/a86010e5))
+  * add tags to json response	 ([6d099f59](/../../commit/6d099f59))
+
+* **example data**
+  * include a pre-verified pact	 ([49fd5004](/../../commit/49fd5004))
+
+* **index**
+  * enable pagination feature	 ([9bb87eca](/../../commit/9bb87eca))
+  * add pagination controls to the bottom of the page	 ([9d9e6378](/../../commit/9d9e6378))
+  * optimise query, feature toggled	 ([e238749e](/../../commit/e238749e))
+  * optimise server side rendered page	 ([1f54ccf4](/../../commit/1f54ccf4))
+
+* **diagnostic**
+  * remove before_resource and after_resource hook calls from diagnostics endpoints	 ([b1dac2bd](/../../commit/b1dac2bd))
+
+* add missing super calls in BaseResource child classes	 ([1071ca8a](/../../commit/1071ca8a))
+* optimise latest_verification_ids_for_consumer_version_tags	 ([9e84ce7d](/../../commit/9e84ce7d))
+* optimise latest_pact_publications_by_consumer_versions	 ([86846271](/../../commit/86846271))
+* optimise latest_pact_consumer_version_orders	 ([c4febeaa](/../../commit/c4febeaa))
+* optimise latest_tagged_pact_consumer_version_orders view	 ([d92cb8f2](/../../commit/d92cb8f2))
+
+
 <a name="v2.40.0"></a>
 ### v2.40.0 (2019-10-26)
 

data/DEVELOPER_DOCUMENTATION.md

@@ -106,8 +106,19 @@ pact publication resource will be created, but it will reuse the existing pact v
     -> versions
   -> latest_tagged_pact_consumer_version_orders
   -> latest_pact_publications_by_consumer_versions
+
+= head_pact_publications
+  -> latest_pact_publications
+    -> latest_pact_publication_ids_for_consumer_versions
+  -> latest_tagged_pact_publications
+    -> latest_pact_publications_by_consumer_versions (optimised for pp_ids)
+    -> latest_tagged_pact_consumer_version_orders (optimised for pp_ids)
+
 ```
 
+
+
+
 ### Useful to know stuff
 
 * The supported database types are Postgres (recommended), MySQL (sigh) and Sqlite (just for testing, not recommended for production). Check the travis.yml file for the supported database versions.

data/db/ddl_statements/head_pact_tags.rb

@@ -0,0 +1,10 @@
+def head_pact_tags_v1(connection)
+  connection.from(Sequel.as(:latest_pact_publication_ids_for_consumer_versions, :lp))
+  .join(:versions,{ Sequel[:lp][:consumer_version_id] => Sequel[:cv][:id]}, { table_alias: :cv })
+  .join(:latest_tagged_pact_consumer_version_orders, {
+    Sequel[:lp][:consumer_id] => Sequel[:o][:consumer_id],
+    Sequel[:lp][:provider_id] => Sequel[:o][:provider_id],
+    Sequel[:cv][:order] => Sequel[:o][:latest_consumer_version_order]
+  }, { table_alias: :o})
+  .select(Sequel[:o][:tag_name].as(:name), Sequel[:lp][:pact_publication_id])
+end

data/db/ddl_statements/latest_pact_consumer_version_orders.rb

@@ -0,0 +1,16 @@
+# The consumer id, provider id, and consumer version order
+# for the latest consumer version that has a pact with that provider.
+
+def latest_pact_consumer_version_orders_v1(connection = nil)
+  "select provider_id, consumer_id, max(consumer_version_order) as latest_consumer_version_order
+  from all_pact_publications
+  group by provider_id, consumer_id"
+end
+
+def latest_pact_consumer_version_orders_v2(connection = nil)
+  view = Sequel.as(:latest_pact_publication_ids_for_consumer_versions, :lp)
+  connection.from(view)
+    .select_group(:provider_id, :consumer_id)
+    .select_append{ max(order).as(latest_consumer_version_order) }
+    .join(:versions, { Sequel[:lp][:consumer_version_id] => Sequel[:cv][:id]}, { table_alias: :cv } )
+end

data/db/ddl_statements/latest_pact_publications_by_consumer_versions.rb

@@ -0,0 +1,16 @@
+def latest_pact_publications_by_consumer_versions_v2(connection = nil)
+  "select app.*
+  from latest_pact_publication_ids_for_consumer_versions lpp
+  inner join all_pact_publications app
+  on lpp.consumer_version_id = app.consumer_version_id
+  and lpp.pact_publication_id = app.id
+  and lpp.provider_id = app.provider_id"
+end
+
+# Don't need all the join keys, just pact_publication_id
+def latest_pact_publications_by_consumer_versions_v3(connection)
+  "select app.*
+  from latest_pact_publication_ids_for_consumer_versions lpp
+  inner join all_pact_publications app
+  on lpp.pact_publication_id = app.id"
+end

data/db/ddl_statements/latest_tagged_pact_consumer_version_orders.rb

@@ -0,0 +1,23 @@
+def latest_tagged_pact_consumer_version_orders_v2(connection)
+  pp = :pact_publications
+  connection.from(pp)
+    .select_group(
+      Sequel[pp][:provider_id],
+      Sequel[:cv][:pacticipant_id].as(:consumer_id),
+      Sequel[:t][:name].as(:tag_name))
+    .select_append{ max(order).as(latest_consumer_version_order) }
+    .join(:versions, { Sequel[pp][:consumer_version_id] => Sequel[:cv][:id] }, { table_alias: :cv} )
+    .join(:tags, { Sequel[:t][:version_id] => Sequel[pp][:consumer_version_id] }, { table_alias: :t })
+end
+
+def latest_tagged_pact_consumer_version_orders_v3(connection)
+  view = Sequel.as(:latest_pact_publication_ids_for_consumer_versions, :lp)
+  connection.from(view)
+    .select_group(
+      Sequel[:lp][:provider_id],
+      Sequel[:lp][:consumer_id],
+      Sequel[:t][:name].as(:tag_name))
+    .select_append{ max(order).as(latest_consumer_version_order) }
+    .join(:versions, { Sequel[:lp][:consumer_version_id] => Sequel[:cv][:id] }, { table_alias: :cv} )
+    .join(:tags, { Sequel[:t][:version_id] => Sequel[:lp][:consumer_version_id] }, { table_alias: :t })
+end

data/db/ddl_statements/latest_verification_ids_for_consumer_version_tags.rb

@@ -36,3 +36,18 @@ LATEST_VERIFICATION_IDS_FOR_CONSUMER_VERSION_TAGS_V2 = "select
       join versions pv
         on v.provider_version_id = pv.id
       group by pv.pacticipant_id, lpp.consumer_id, t.name"
+
+LATEST_VERIFICATION_IDS_FOR_CONSUMER_VERSION_TAGS_V3 = "select
+        pv.pacticipant_id as provider_id,
+        lpp.consumer_id,
+        t.name as consumer_version_tag_name,
+        max(v.id) as latest_verification_id
+      from verifications v
+      join latest_pact_publication_ids_for_consumer_versions lpp
+        on v.pact_version_id = lpp.pact_version_id
+      join tags t
+        on lpp.consumer_version_id = t.version_id
+      join versions pv
+        on v.provider_version_id = pv.id
+      where v.id in (select latest_verification_id from latest_verification_ids_for_pact_versions)
+      group by pv.pacticipant_id, lpp.consumer_id, t.name"

data/db/migrations/000028_create_all_pact_publications.rb

@@ -23,6 +23,7 @@ Sequel.migration do
 
     # Latest pact_publication (revision) for each provider/consumer version
     # updated in 20180519_recreate_views.rb
+    # latest_pact_publications_by_consumer_versions_v1
     create_view(:latest_pact_publications_by_consumer_versions,
       "select app.*
       from all_pact_publications app

data/db/migrations/20180311_optimise_head_matrix.rb

@@ -6,15 +6,7 @@ Sequel.migration do
     pp = :pact_publications
     # For each consumer_id/provider_id/tag_name, the version order of the latest version that has a pact
     create_or_replace_view(:latest_tagged_pact_consumer_version_orders,
-      from(:pact_publications)
-        .select_group(
-          Sequel[pp][:provider_id],
-          Sequel[:cv][:pacticipant_id].as(:consumer_id),
-          Sequel[:t][:name].as(:tag_name))
-        .select_append{ max(order).as(latest_consumer_version_order) }
-        .join(:versions, { Sequel[pp][:consumer_version_id] => Sequel[:cv][:id] }, { table_alias: :cv} )
-        .join(:tags, { Sequel[:t][:version_id] => Sequel[pp][:consumer_version_id] }, { table_alias: :t })
-    )
+      latest_tagged_pact_consumer_version_orders_v2(self))
 
     # Add provider_version_order to original definition
     # The most recent verification for each pact_version

data/db/migrations/20180722_recreate_views.rb

@@ -1,29 +1,19 @@
+require_relative '../ddl_statements'
+
 Sequel.migration do
   up do
     # Latest pact_publication details for each provider/consumer version
     create_or_replace_view(:latest_pact_publications_by_consumer_versions,
-      "select app.*
-      from latest_pact_publication_ids_for_consumer_versions lpp
-      inner join all_pact_publications app
-      on lpp.consumer_version_id = app.consumer_version_id
-      and lpp.pact_publication_id = app.id
-      and lpp.provider_id = app.provider_id"
-    )
+      latest_pact_publications_by_consumer_versions_v2(self))
 
     # Latest consumer version order for consumer/provider
     # Recreate latest_pact_publication_ids_for_consumer_versions view
-    lpp = :latest_pact_publication_ids_for_consumer_versions
-    latest_pact_consumer_version_orders = from(lpp).select_group(
-        Sequel[lpp][:provider_id],
-        Sequel[:cv][:pacticipant_id].as(:consumer_id))
-      .select_append{ max(order).as(latest_consumer_version_order) }
-      .join(:versions, { Sequel[lpp][:consumer_version_id] => Sequel[:cv][:id] }, { table_alias: :cv })
-
-    create_or_replace_view(:latest_pact_consumer_version_orders, latest_pact_consumer_version_orders)
+    create_or_replace_view(:latest_pact_consumer_version_orders, latest_pact_consumer_version_orders_v2(self))
   end
 
   down do
     # Latest pact_publication details for each provider/consumer version
+    # latest_pact_publications_by_consumer_versions_v1
     create_or_replace_view(:latest_pact_publications_by_consumer_versions,
       "select app.*
       from all_pact_publications app
@@ -35,9 +25,6 @@ Sequel.migration do
         )
 
     create_or_replace_view(:latest_pact_consumer_version_orders,
-      "select provider_id, consumer_id, max(consumer_version_order) as latest_consumer_version_order
-      from all_pact_publications
-      group by provider_id, consumer_id"
-    )
+      latest_pact_consumer_version_orders_v1(self))
   end
 end

data/db/migrations/20191028_optimise_latest_tagged_pact_cv_orders.rb

@@ -0,0 +1,13 @@
+require_relative '../ddl_statements'
+
+Sequel.migration do
+  up do
+    create_or_replace_view(:latest_tagged_pact_consumer_version_orders,
+      latest_tagged_pact_consumer_version_orders_v3(self))
+  end
+
+  down do
+    create_or_replace_view(:latest_tagged_pact_consumer_version_orders,
+      latest_tagged_pact_consumer_version_orders_v2(self))
+  end
+end

data/db/migrations/20191030_optimise_latest_pact_publications_by_consumer_versions_.rb

@@ -0,0 +1,13 @@
+require_relative '../ddl_statements'
+
+Sequel.migration do
+  up do
+    create_or_replace_view(:latest_pact_publications_by_consumer_versions,
+      latest_pact_publications_by_consumer_versions_v3(self))
+  end
+
+  down do
+    create_or_replace_view(:latest_pact_publications_by_consumer_versions,
+      latest_pact_publications_by_consumer_versions_v2(self))
+  end
+end

data/db/migrations/20191031_optimise_latest_verification_ids_for_consumer_version_tags.rb

@@ -0,0 +1,13 @@
+require_relative '../ddl_statements'
+
+Sequel.migration do
+  up do
+    create_or_replace_view(:latest_verification_ids_for_consumer_version_tags,
+      LATEST_VERIFICATION_IDS_FOR_CONSUMER_VERSION_TAGS_V3)
+  end
+
+  down do
+    create_or_replace_view(:latest_verification_ids_for_consumer_version_tags,
+      LATEST_VERIFICATION_IDS_FOR_CONSUMER_VERSION_TAGS_V2)
+  end
+end

data/db/migrations/20191101_create_head_pact_tags.rb

@@ -0,0 +1,11 @@
+require_relative '../ddl_statements'
+
+Sequel.migration do
+  up do
+    create_view(:head_pact_tags, head_pact_tags_v1(self))
+  end
+
+  down do
+    drop_view(:head_pact_tags)
+  end
+end

data/lib/db.rb

@@ -29,6 +29,7 @@ module DB
     # logger = Logger.new($stdout)
     con = Sequel.connect(db_credentials.merge(:logger => logger, :pool_class => Sequel::ThreadedConnectionPool, :encoding => 'utf8'))
     con.extension(:connection_validator)
+    con.extension(:pagination)
     con.pool.connection_validation_timeout = -1 #Check the connection on every request
     con.timezone = :utc
     con.run("SET sql_mode='STRICT_TRANS_TABLES';") if db_credentials[:adapter].to_s =~ /mysql/

data/lib/pact_broker/api/contracts/dry_validation_predicates.rb

@@ -0,0 +1,15 @@
+require 'dry-validation'
+
+module PactBroker
+  module Api
+    module Contracts
+      module DryValidationPredicates
+        include Dry::Logic::Predicates
+
+        predicate(:date?) do |value|
+          DateTime.parse(value) rescue false
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/api/contracts/dry_validation_workarounds.rb

@@ -0,0 +1,38 @@
+module PactBroker
+  module Api
+    module Contracts
+      module DryValidationWorkarounds
+        extend self
+
+        # I just cannot seem to get the validation to stop on the first error.
+        # If one rule fails, they all come back failed, and it's driving me nuts.
+        # Why on earth would I want that behaviour?
+        def select_first_message(messages)
+          messages.each_with_object({}) do | (key, value), new_messages |
+            new_messages[key] = [value.first]
+          end
+        end
+
+        def flatten_array_of_hashes(array_of_hashes)
+          new_messages = array_of_hashes.collect do | index, hash |
+            hash.values.flatten.collect { | text | "#{text} at index #{index}"}
+          end.flatten
+        end
+
+        def flatten_indexed_messages(messages)
+          if messages.values.any?{ | value | is_indexed_structure?(value) }
+            messages.each_with_object({}) do | (key, value), new_messages |
+              new_messages[key] = is_indexed_structure?(value) ? flatten_array_of_hashes(value) : value
+            end
+          else
+            messages
+          end
+        end
+
+        def is_indexed_structure?(thing)
+          thing.is_a?(Hash) && thing.keys.first.is_a?(Integer)
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/api/contracts/verifiable_pacts_json_query_schema.rb

@@ -0,0 +1,34 @@
+require 'dry-validation'
+require 'pact_broker/hash_refinements'
+require 'pact_broker/api/contracts/dry_validation_workarounds'
+require 'pact_broker/api/contracts/dry_validation_predicates'
+
+module PactBroker
+  module Api
+    module Contracts
+      class VerifiablePactsJSONQuerySchema
+        extend DryValidationWorkarounds
+        using PactBroker::HashRefinements
+
+        SCHEMA = Dry::Validation.Schema do
+          configure do
+            predicates(DryValidationPredicates)
+          end
+          optional(:providerVersionTags).maybe(:array?)
+          optional(:consumerVersionSelectors).each do
+            schema do
+              required(:tag).filled(:str?)
+              required(:latest).filled(included_in?: [true])
+            end
+          end
+          optional(:includePendingStatus).filled(included_in?: [true, false])
+          optional(:includeWipPactsSince).filled(:date?)
+        end
+
+        def self.call(params)
+          select_first_message(flatten_indexed_messages(SCHEMA.call(params&.symbolize_keys).messages(full: true)))
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/api/contracts/verifiable_pacts_query_schema.rb

@@ -1,39 +1,31 @@
 require 'dry-validation'
+require 'pact_broker/api/contracts/dry_validation_workarounds'
+require 'pact_broker/api/contracts/dry_validation_predicates'
 
 module PactBroker
   module Api
     module Contracts
       class VerifiablePactsQuerySchema
+        extend DryValidationWorkarounds
+        using PactBroker::HashRefinements
+
         SCHEMA = Dry::Validation.Schema do
+          configure do
+            predicates(DryValidationPredicates)
+          end
           optional(:provider_version_tags).maybe(:array?)
-          # optional(:exclude_other_pending).filled(included_in?: ["true", "false"])
           optional(:consumer_version_selectors).each do
             schema do
               required(:tag).filled(:str?)
-              optional(:latest).filled(included_in?: ["true", "false"])
+              required(:latest).filled(included_in?: ["true"])
             end
           end
+          optional(:include_pending_status).filled(included_in?: ["true", "false"])
+          optional(:include_wip_pacts_since).filled(:date?)
         end
 
         def self.call(params)
-          select_first_message(flatten_index_messages(SCHEMA.call(params).messages(full: true)))
-        end
-
-        def self.select_first_message(messages)
-          messages.each_with_object({}) do | (key, value), new_messages |
-            new_messages[key] = [value.first]
-          end
-        end
-
-        def self.flatten_index_messages(messages)
-          if messages[:consumer_version_selectors]
-            new_messages = messages[:consumer_version_selectors].collect do | index, value |
-              value.values.flatten.collect { | text | "#{text} at index #{index}"}
-            end.flatten
-            messages.merge(consumer_version_selectors: new_messages)
-          else
-            messages
-          end
+          select_first_message(flatten_indexed_messages(SCHEMA.call(params&.symbolize_keys).messages(full: true)))
         end
       end
     end