pact_broker 2.89.1 → 2.90.0

data/spec/lib/pact_broker/matrix/parse_query_spec.rb

@@ -1,141 +0,0 @@
-require "pact_broker/matrix/parse_query"
-
-module PactBroker
-  module Matrix
-    describe ParseQuery do
-      describe ".call" do
-        let(:query) { "q[][pacticipant]=Foo&q[][version]=1.2.3&q[][pacticipant]=Bar&q[][version]=9.9.9" }
-
-        subject { ParseQuery.call(query) }
-
-        it "extracts the pacticipant names and respective versions" do
-          expect(subject.first).to eq([
-            PactBroker::Matrix::UnresolvedSelector.new(pacticipant_name: "Foo", pacticipant_version_number: "1.2.3"),
-            PactBroker::Matrix::UnresolvedSelector.new(pacticipant_name: "Bar", pacticipant_version_number: "9.9.9")
-          ])
-        end
-
-        context "with spaces" do
-          let(:query) { "q[][pacticipant]=Name%20With%20Spaces&q[][version]=1%202" }
-
-          it "works" do
-            expect(subject.first).to eq [{pacticipant_name: "Name With Spaces", pacticipant_version_number: "1 2"}]
-          end
-        end
-
-        context "with no q" do
-          let(:query) { "foo" }
-
-          it "returns an empty hash" do
-            expect(subject.first).to eq([])
-          end
-        end
-
-        context "with an incorrect param names" do
-          let(:query) { "q[][wrong]=Foo&q[][blah]=1.2.3" }
-
-          it "returns nil keys or values" do
-            expect(subject.first).to eq [{}]
-          end
-        end
-
-        context "with no options specified" do
-          let(:query) { "" }
-
-          it "sets the defaults" do
-            expect(subject.last).to eq(limit: "100", ignore_selectors: [])
-          end
-        end
-
-        context "with just one status specified" do
-          let(:query) { "success=true" }
-          it "extracts the one status" do
-            expect(subject.last).to include success: [true]
-          end
-        end
-
-        context "with an array of statuses" do
-          let(:query) { "success[]=true&success[]=false&success[]=" }
-          it "extracts the statuses" do
-            expect(subject.last).to include success: [true, false, nil]
-          end
-        end
-
-        context "with success[]=" do
-          let(:query) { "success[]=&foo=bar" }
-
-          it "sets an array with a nil success" do
-            expect(subject.last).to include success: [nil]
-          end
-        end
-
-        context "with success=" do
-          let(:query) { "success=&foo=bar" }
-
-          it "sets an array with a nil success" do
-            expect(subject.last).to include success: [nil]
-          end
-        end
-
-        context "when latest is true" do
-          let(:query) { "q[][pacticipant]=Foo&q[][latest]=true" }
-
-          it "returns a selector with latest true" do
-            expect(subject.first).to eq [{ pacticipant_name: "Foo", latest: true }]
-          end
-        end
-
-        context "when global latest is true" do
-          let(:query) { "q[][pacticipant]=Foo&latest=true" }
-
-          it "returns options with latest true" do
-            expect(subject.last).to include latest: true
-          end
-        end
-
-        context "when latest is not true" do
-          let(:query) { "q[][pacticipant]=Foo&q[][latest]=false" }
-
-          it "returns a selector with no latest key" do
-            expect(subject.first).to eq [{ pacticipant_name: "Foo" }]
-          end
-        end
-
-        context "when there is a tag" do
-          let(:query) { "q[][pacticipant]=Foo&q[][tag]=prod" }
-
-          it "returns a selector with a tag" do
-            expect(subject.first).to eq [{ pacticipant_name: "Foo", tag: "prod" }]
-          end
-        end
-
-        context "when a limit is specified" do
-          let(:query) { "limit=200" }
-
-          it "sets the limit" do
-            expect(subject.last[:limit]).to eq "200"
-          end
-        end
-
-        context "when there are ignored selectors" do
-          let(:query) { "q[][pacticipant]=Foo&q[][tag]=prod&ignore[][pacticipant]=Bar&ignore[][pacticipant]=Waffle&ignore[][version]=1" }
-
-          it "sets the pacticipants to ignore" do
-            expect(subject.last[:ignore_selectors]).to eq [
-              PactBroker::Matrix::UnresolvedSelector.new(pacticipant_name: "Bar"),
-              PactBroker::Matrix::UnresolvedSelector.new(pacticipant_name: "Waffle", pacticipant_version_number: "1")
-            ]
-          end
-        end
-
-        context "when the ignored selectors isn't a hash" do
-          let(:query) { "q[][pacticipant]=Foo&q[][tag]=prod&ignore=1" }
-
-          it "sets an empty array" do
-            expect(subject.last[:ignore_selectors]).to eq []
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/matrix/quick_row_spec.rb

@@ -1,74 +0,0 @@
-require "pact_broker/matrix/quick_row"
-require "pact_broker/matrix/resolved_selector"
-
-module PactBroker
-  module Matrix
-    describe QuickRow do
-      describe "the interface" do
-        before do
-          td.create_pact_with_hierarchy("A", "1", "B")
-            .create_verification(provider_version: "1", success: false)
-            .create_verification(provider_version: "1", number: 2, success: true)
-            .create_verification(provider_version: "2", number: 3, success: true)
-            .create_provider("C")
-            .create_pact
-            .create_verification(provider_version: "1")
-            .create_consumer_version("2")
-            .create_pact
-            .create_verification(provider_version: "3")
-            .use_provider("B")
-            .create_pact
-        end
-
-        it "behaves like a Row, except quicker" do
-          a_id = QuickRow.db[:pacticipants].where(name: "A").select(:id).single_record[:id]
-          rows = QuickRow.default_scope.where(consumer_id: a_id).eager(:consumer).eager(:verification).all
-          expect(rows.first.consumer).to be rows.last.consumer
-          expect(rows.first.verification).to_not be nil
-          expect(rows.first.consumer_name).to_not be nil
-          expect(rows.first.provider_name).to_not be nil
-        end
-
-      end
-
-      describe "order_by_last_action_date" do
-        subject { QuickRow.default_scope.order_by_last_action_date }
-
-        context "when there are two pacts verified at the same time" do
-          before do
-            td.create_consumer("Foo")
-              .create_provider("Bar")
-              .create_consumer_version("10")
-              .create_pact(created_at: day_1)
-              .create_verification(provider_version: "2", created_at: day_3)
-              .create_consumer_version("3")
-              .create_pact(created_at: day_2)
-              .create_verification(provider_version: "2", created_at: day_3)
-          end
-
-          let(:day_1) { DateTime.now + 1  }
-          let(:day_2) { DateTime.now + 2  }
-          let(:day_3) { DateTime.now + 3  }
-
-          it "orders by the pact publication id desc" do
-            expect(subject.first.last_action_date).to eq subject.last.last_action_date
-            expect(subject.first.consumer_version_number).to eq "3"
-            expect(subject.last.consumer_version_number).to eq "10"
-          end
-        end
-
-        context "when a pact has been published after a pact has been verified" do
-          before do
-            td.create_pact_with_verification("Foo", "1", "Bar", "2")
-              .create_pact_with_hierarchy("Foo", "2", "Bar")
-          end
-
-          it "puts the unverified pact before the verification" do
-            expect(subject.first.consumer_version_number).to eq "2"
-            expect(subject.last.consumer_version_number).to eq "1"
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/matrix/repository_dependency_spec.rb

@@ -1,56 +0,0 @@
-require "pact_broker/matrix/repository"
-
-module PactBroker
-  module Matrix
-    describe Repository do
-      def build_selectors(hash)
-        hash.collect do | key, value |
-          UnresolvedSelector.new(pacticipant_name: key, pacticipant_version_number: value)
-        end
-      end
-
-      def shorten_row row
-        "#{row[:consumer_name]}#{row[:consumer_version_number]} #{row[:provider_name]}#{row[:provider_version_number] || '?'} n#{row[:verification_number] || '?'}"
-      end
-
-      def shorten_rows rows
-        rows.collect{ |r| shorten_row(r) }
-      end
-
-      describe "find when deploying a provider to prod for the first time and the consumer has not been deployed yet" do
-        before do
-          td.create_pact_with_hierarchy("Foo", "1", "Bar")
-            .create_verification(provider_version: "2")
-        end
-
-        let(:selectors) { [ UnresolvedSelector.new(pacticipant_name: "Bar", pacticipant_version_number: "2") ] }
-        let(:options) { { latest: true, tag: "prod"} }
-
-        subject { shorten_rows(rows) }
-        let(:rows) { Repository.new.find(selectors, options) }
-
-        it "returns an empty array" do
-          expect(rows).to eq []
-        end
-      end
-
-      describe "find when deploying a consumer to prod for the first time and the provider has not been deployed yet" do
-        before do
-          td.create_pact_with_hierarchy("Foo", "1", "Bar")
-            .create_verification(provider_version: "2")
-        end
-
-        let(:selectors) { [ UnresolvedSelector.new(pacticipant_name: "Foo", pacticipant_version_number: "1") ] }
-        let(:options) { { latest: true, tag: "prod"} }
-
-        subject { shorten_rows(rows) }
-        let(:results) { Repository.new.find(selectors, options) }
-
-        it "returns an array with one row that does not have a verification" do
-          expect(results.first).to_not have_verification
-          expect(results.resolved_selectors.find{ |s | s[:pacticipant_name] == "Bar"}.pacticipant_version_id).to eq(-1)
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/matrix/repository_query_limit_spec.rb

@@ -1,78 +0,0 @@
-require "pact_broker/matrix/repository"
-
-module PactBroker
-  module Matrix
-    describe Repository do
-      # See https://github.com/pact-foundation/pact_broker-client/issues/53
-      # The problem occurs when a pact has so many verifications for the same provider
-      # version that relevant rows do get returned in the result set because the specified limit
-      # causes them to be truncated.
-      # The most elegant solution is to create views have the data already grouped by
-      # consumer version/provider version, consumer version/provider, and consumer/provider,
-      # however, I don't have the time to work out how to make that view query efficient - I suspect
-      # it will require lots of full table scans, as it will have to work out the latest pact revision
-      # and latest verification for each pact publication and I'm not sure if it will have to do it
-      # for the entire table, or whether it will apply the consumer/provider filters...
-      # The quick and dirty solution is to do a pre-query to get the latest pact revision and latest
-      # verifications for the pact versions before we do the matrix query.
-      describe "querying for can-i-deploy when there are more matrix rows than the specified query limit" do
-        before do
-          td.create_consumer("Foo")
-            .create_provider("Bar")
-            .create_consumer_version("1")
-            .create_pact
-            .create_verification(number: 1, provider_version: "2", tag_names: ["staging"])
-            .create_verification(number: 2, provider_version: "2")
-            .create_verification(number: 3, provider_version: "2")
-            .create_verification(number: 4, provider_version: "2")
-            .create_verification(number: 5, provider_version: "3")
-            .create_provider("Wiffle")
-            .create_pact
-            .create_verification(number: 1, provider_version: "6", tag_names: ["staging"])
-        end
-
-        let(:path) { "/matrix?q[][pacticipant]=Foo&q[][version]=1&tag=staging&latestby=cvp&limit=2" }
-
-        subject { get(path) }
-
-        it "does not remove relevant rows from the query due to the specified limit" do
-          expect(JSON.parse(subject.body)["summary"]["deployable"]).to be true
-        end
-      end
-
-      describe "querying for the UI when there is a bi-directional pact and there are more matrix rows for one direction than the specified query limit" do
-        before do
-          td.create_pact_with_verification("Foo", "1", "Bar", "2")
-            .create_pact_with_verification("Bar", "2", "Foo", "1")
-            .add_day
-            .create_pact_with_verification("Foo", "3", "Bar", "4")
-            .create_pact_with_verification("Bar", "4", "Foo", "3")
-            .add_day
-            .create_pact_with_verification("Foo", "5", "Bar", "6")
-            .create_pact_with_verification("Bar", "6", "Foo", "5")
-        end
-        let(:selectors) do
-          [
-            UnresolvedSelector.new(pacticipant_name: "Foo"),
-            UnresolvedSelector.new(pacticipant_name: "Bar")
-          ]
-        end
-        let(:options) { { limit: 4 } }
-
-        subject { Repository.new.find(selectors, options) }
-
-        it "includes rows from each direction" do
-          expect(subject.count{ |r| r.consumer_name == "Foo" }).to eq(subject.count{ |r| r.consumer_name == "Bar" })
-        end
-
-        context "when where is a latestby" do
-          let(:options) { { limit: 4, latestby: "cvpv"} }
-
-          it "includes rows from each direction" do
-            expect(subject.count{ |r| r.consumer_name == "Foo" }).to eq(subject.count{ |r| r.consumer_name == "Bar" })
-          end
-        end
-      end
-    end
-  end
-end