pact_broker 2.89.1 → 2.90.0

data/spec/lib/pact_broker/api/decorators/matrix_decorator_spec.rb

@@ -1,259 +0,0 @@
-require "pact_broker/api/decorators/matrix_decorator"
-require "pact_broker/matrix/query_results_with_deployment_status_summary"
-require "pact_broker/matrix/deployment_status_summary"
-require "pact_broker/matrix/quick_row"
-
-module PactBroker
-  module Api
-    module Decorators
-      describe MatrixDecorator do
-        describe "to_json" do
-          before do
-            allow_any_instance_of(ReasonDecorator).to receive(:to_s).and_return("foo")
-            allow_any_instance_of(PactBroker::Api::PactBrokerUrls).to receive(:branch_version_url).and_return("branch_version_url")
-          end
-          let(:verification_date) { DateTime.new(2017, 12, 31) }
-          let(:pact_created_at) { DateTime.new(2017, 1, 1) }
-          let(:row_1_success) { true }
-          let(:row_2_success) { true }
-          let(:row_1) do
-            instance_double("PactBroker::Matrix::QuickRow",
-              {
-                consumer_name: "Consumer",
-                consumer_version_number: "1.0.0",
-                consumer_version_branch_versions: consumer_version_branch_versions,
-                consumer_version_tags: consumer_version_tags,
-                provider_version_tags: provider_version_tags,
-                pact_version_sha: "1234",
-                pact_created_at: pact_created_at,
-                provider_version_number: "4.5.6",
-                provider_version_branch_versions: provider_version_branch_versions,
-                provider_name: "Provider",
-                success: row_1_success,
-                verification_number: 1,
-                verification_executed_at: verification_date
-              }
-            )
-          end
-
-          let(:row_2) do
-            instance_double("PactBroker::Matrix::QuickRow",
-              {
-                consumer_name: "Consumer",
-                consumer_version_number: "1.0.0",
-                consumer_version_branch_versions: [],
-                consumer_version_tags: [],
-                pact_version_sha: "1234",
-                pact_created_at: pact_created_at,
-                provider_version_number: nil,
-                provider_version_branch_versions: [],
-                provider_name: "Provider",
-                success: row_2_success,
-                verification_number: nil,
-                verification_executed_at: verification_date
-              }
-            )
-          end
-
-          let(:consumer_hash) do
-            {
-              name: "Consumer",
-              _links: {
-                self: {
-                  href: "http://example.org/pacticipants/Consumer"
-                }
-              },
-              version: {
-                number: "1.0.0",
-                branch: "main",
-                branches: [
-                  name: "main",
-                  _links: {
-
-                  }
-                ],
-                _links: {
-                  self: {
-                    href: "http://example.org/pacticipants/Consumer/versions/1.0.0"
-                  }
-                },
-                tags: [
-                  {
-                    name: "prod",
-                    latest: true,
-                    _links: {
-                      self: {
-                        href: "http://example.org/pacticipants/Consumer/versions/1.0.0/tags/prod"
-                      }
-                    }
-                  }
-                ]
-              }
-            }
-          end
-
-          let(:provider_hash) do
-            {
-              name: "Provider",
-              _links: {
-                self: {
-                  href: "http://example.org/pacticipants/Provider"
-                }
-              },
-              version: {
-                number: "4.5.6",
-                branch: "feat/x",
-                _links: {
-                  self: {
-                    href: "http://example.org/pacticipants/Provider/versions/4.5.6"
-                  }
-                },
-                tags: [
-                  {
-                    name: "master",
-                    latest: false,
-                    _links: {
-                      self: {
-                        href: "http://example.org/pacticipants/Provider/versions/4.5.6/tags/master"
-                      }
-                    }
-                  }
-                ]
-              }
-            }
-          end
-
-          let(:verification_hash) do
-            {
-              success: true,
-              verifiedAt: "2017-12-31T00:00:00+00:00",
-              _links: {
-                self: {
-                  href: "http://example.org/pacts/provider/Provider/consumer/Consumer/pact-version/1234/metadata/Y3ZuPTEuMC4w/verification-results/1"
-                }
-              }
-            }
-          end
-
-          let(:pact_hash) do
-            {
-              createdAt: "2017-01-01T00:00:00+00:00",
-              _links: {
-                self: {
-                  href: "http://example.org/pacts/provider/Provider/consumer/Consumer/version/1.0.0"
-                }
-              }
-            }
-          end
-
-          let(:consumer_version) { double("consumer version", number: "1.0.0", pacticipant: double("consumer", name: "Consumer")) }
-
-          let(:consumer_version_branch_versions) do
-            [ instance_double("PactBroker::Versions::BranchVersion", branch_name: "main", latest?: true) ]
-          end
-
-          let(:consumer_version_tags) do
-            [
-              double("tag", name: "prod", latest?: true, version: consumer_version, created_at: DateTime.now )
-            ]
-          end
-
-          let(:provider_version) { double("provider version", number: "4.5.6", pacticipant: double("provider", name: "Provider")) }
-
-          let(:provider_version_branch_versions) do
-            [ instance_double("PactBroker::Versions::BranchVersion", branch_name: "feat/x", latest?: true) ]
-          end
-
-          let(:provider_version_tags) do
-            [
-              double("tag", name: "master", latest?: false, version: provider_version, created_at: DateTime.now)
-            ]
-          end
-
-          let(:query_results) do
-            double("QueryResults",
-              considered_rows: [row_1, row_2],
-              ignored_rows: ignored_rows,
-              selectors: selectors,
-              options: options,
-              resolved_selectors: resolved_selectors,
-              integrations: integrations
-            )
-          end
-          let(:ignored_rows) { [] }
-          let(:query_results_with_deployment_status_summary){ PactBroker::Matrix::QueryResultsWithDeploymentStatusSummary.new(query_results, deployment_status_summary)}
-          let(:selectors) { nil }
-          let(:integrations){ [] }
-          let(:options) { nil }
-          let(:resolved_selectors) { nil }
-          let(:counts) { { success: 1 } }
-          let(:deployment_status_summary) do
-            instance_double("PactBroker::Matrix::DeploymentStatusSummary", reasons: [reason_1, reason_2], deployable?: deployable, counts: counts)
-          end
-          let(:reason_1) { instance_double("PactBroker::Matrix::Reason", type: "info") }
-          let(:reason_2) { instance_double("PactBroker::Matrix::Reason", type: "warning") }
-          let(:deployable) { true }
-          let(:json) { MatrixDecorator.new(query_results_with_deployment_status_summary).to_json(user_options: { base_url: "http://example.org" }) }
-          let(:parsed_json) { JSON.parse(json, symbolize_names: true) }
-
-          it "includes the consumer details" do
-            expect(parsed_json[:matrix][0][:consumer]).to match_pact consumer_hash
-          end
-
-          it "includes the provider details" do
-            expect(parsed_json[:matrix][0][:provider]).to match_pact provider_hash
-          end
-
-          it "includes the verification details" do
-            expect(parsed_json[:matrix][0][:verificationResult]).to eq verification_hash
-          end
-
-          it "includes the pact details" do
-            expect(parsed_json[:matrix][0][:pact]).to eq pact_hash
-          end
-
-          it "includes a summary" do
-            expect(parsed_json[:summary][:deployable]).to eq true
-            expect(parsed_json[:summary][:reason]).to eq "foo\nfoo"
-            expect(parsed_json[:summary][:success]).to eq 1
-          end
-
-          it "includes notices" do
-            expect(parsed_json[:notices][0]).to eq text: "foo", type: "info"
-            expect(parsed_json[:notices][1]).to eq text: "foo", type: "warning"
-          end
-
-          context "when the pact has not been verified" do
-            before do
-              allow(row_2).to receive(:success).and_return(nil)
-              allow(row_2).to receive(:verification_executed_at).and_return(nil)
-            end
-
-            let(:verification_hash) { nil }
-
-            it "has empty provider details" do
-              expect(parsed_json[:matrix][1][:provider]).to eq provider_hash.merge(version: nil)
-            end
-
-            it "has a nil verificationResult" do
-              expect(parsed_json[:matrix][1][:verificationResult]).to eq verification_hash
-            end
-          end
-
-          context "with ignored rows" do
-            let(:ignored_rows) { [row_1] }
-
-            it "includes the considered and ignored rows" do
-              expect(parsed_json[:matrix].size).to eq 3
-              expect(parsed_json[:matrix].first).to_not have_key(:ignored)
-            end
-
-            it "includes the ignored flag" do
-              expect(parsed_json[:matrix].last[:ignored]).to be true
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/api/decorators/pact_collection_decorator_spec.rb

@@ -1,23 +0,0 @@
-require "spec_helper"
-
-require "pact_broker/domain"
-require "pact_broker/api/decorators"
-
-module PactBroker::Api::Decorators
-
-  describe PactCollectionDecorator do
-
-    let(:pact) do
-      provider = PactBroker::Domain::Pacticipant.create(:name => "Pricing Service")
-      consumer = PactBroker::Domain::Pacticipant.create(:name => "Condor")
-      version = PactBroker::Domain::Version.create(:number => "1.3.0", :pacticipant => consumer)
-      pact = PactBroker::Domain::Pact.create(:consumer_version => version, :provider => provider)
-      pact
-    end
-
-    xit "should description" do
-      puts PactCollectionDecorator.new([pact]).to_json
-    end
-  end
-
-end

data/spec/lib/pact_broker/api/decorators/pact_decorator_spec.rb

@@ -1,136 +0,0 @@
-require "spec_helper"
-require "pact_broker/api/decorators/pact_decorator"
-
-module PactBroker
-  module Api
-    module Decorators
-      describe PactDecorator do
-        before do
-          allow(decorator).to receive(:templated_diff_url).and_return("templated-diff-url")
-          allow(decorator).to receive(:verification_publication_url).and_return("verification-publication-url")
-        end
-        let(:content_hash) {
-          {
-            "consumer" => {"name" => "Consumer"},
-            "provider" => {"name" => "Provider"},
-            "interactions" => [],
-            "metadata" => {}
-          }
-        }
-
-        let(:base_url) { "http://example.org" }
-        let(:created_at) { Time.new(2014, 3, 4) }
-        let(:pact) { double("pact",
-          content_hash: content_hash,
-          created_at: created_at,
-          consumer: consumer,
-          consumer_name: consumer.name,
-          provider: provider,
-          provider_name: provider.name,
-          consumer_version: consumer_version,
-          consumer_version_number: "1234",
-          pact_version_sha: "9999",
-          revision_number: 2,
-          name: "A Pact"
-        )}
-        let(:consumer) { instance_double(PactBroker::Domain::Pacticipant, name: "A Consumer")}
-        let(:provider) { instance_double(PactBroker::Domain::Pacticipant, name: "A Provider")}
-        let(:consumer_version) { instance_double(PactBroker::Domain::Version, number: "1234", pacticipant: consumer)}
-        let(:metadata) { "abcd" }
-        let(:decorator) { PactDecorator.new(pact) }
-        let(:json) { decorator.to_json(user_options: { base_url: base_url, metadata: metadata }) }
-        subject { JSON.parse(json, symbolize_names: true) }
-
-        describe "#to_json" do
-
-          it "creates the verification link" do
-            expect(decorator).to receive(:verification_publication_url).with(pact, base_url, metadata)
-            subject
-          end
-
-          it "includes the json_content" do
-            expect(subject[:consumer]).to eq name: "Consumer"
-          end
-
-          it "includes the createdAt date" do
-            expect(subject[:createdAt]).to eq FormatDateTime.call(created_at)
-          end
-
-          it "includes a link to itself" do
-            expect(subject[:_links][:self]).to eq href: "http://example.org/pacts/provider/A%20Provider/consumer/A%20Consumer/version/1234", name: "A Pact", title: "Pact"
-          end
-
-          it "includes a link to the diff with the previous distinct version" do
-            expect(subject[:_links][:'pb:diff-previous-distinct']).to eq({href: "http://example.org/pacts/provider/A%20Provider/consumer/A%20Consumer/version/1234/diff/previous-distinct",
-              title: "Diff with previous distinct version of this pact"})
-          end
-
-          it "includes a link to the previous distinct pact version" do
-            expect(subject[:_links][:'pb:previous-distinct']).to eq({href: "http://example.org/pacts/provider/A%20Provider/consumer/A%20Consumer/version/1234/previous-distinct",
-              title: "Previous distinct version of this pact"})
-          end
-
-          it "includes a link to tag this version" do
-            expect(subject[:_links][:'pb:tag-version'][:href]).to eq "http://example.org/pacticipants/A%20Consumer/versions/1234/tags/{tag}"
-          end
-
-          it "includes a link to the consumer" do
-            expect(subject[:_links][:'pb:consumer']).to eq name: "A Consumer", title: "Consumer", href: "http://example.org/pacticipants/A%20Consumer"
-          end
-
-          it "includes a link to the provider" do
-            expect(subject[:_links][:'pb:provider']).to eq name: "A Provider", title: "Provider", href: "http://example.org/pacticipants/A%20Provider"
-          end
-
-          it "includes a link to the webhooks for this pact" do
-            expect(subject[:_links][:'pb:pact-webhooks'][:href]).to eq "http://example.org/webhooks/provider/A%20Provider/consumer/A%20Consumer"
-          end
-
-          it "includes a link to the latest pact" do
-            expect(subject[:_links][:'pb:latest-pact-version'][:title]).to eq "Latest version of this pact"
-            expect(subject[:_links][:'pb:latest-pact-version'][:href]).to eq "http://example.org/pacts/provider/A%20Provider/consumer/A%20Consumer/latest"
-          end
-
-          it "includes a link to all pact versions" do
-            expect(subject[:_links][:'pb:all-pact-versions'][:title]).to eq "All versions of this pact"
-            expect(subject[:_links][:'pb:all-pact-versions'][:href]).to eq "http://example.org/pacts/provider/A%20Provider/consumer/A%20Consumer/versions"
-          end
-
-          it "includes a link to the pact version" do
-            expect(subject[:_links][:'pb:consumer-version'][:title]).to eq "Consumer version"
-            expect(subject[:_links][:'pb:consumer-version'][:name]).to eq "1234"
-            expect(subject[:_links][:'pb:consumer-version'][:href]).to eq "http://example.org/pacticipants/A%20Consumer/versions/1234"
-          end
-
-          it "includes a link to the latest untagged version" do
-            expect(subject[:_links][:'pb:latest-untagged-pact-version'][:href]).to eq "http://example.org/pacts/provider/A%20Provider/consumer/A%20Consumer/latest-untagged"
-          end
-
-          it "includes a link to the latest tagged version" do
-            expect(subject[:_links][:'pb:latest-tagged-pact-version'][:href]).to eq "http://example.org/pacts/provider/A%20Provider/consumer/A%20Consumer/latest/{tag}"
-          end
-
-          it "includes a link to publish a verification" do
-            expect(subject[:_links][:'pb:publish-verification-results'][:href]).to eq "verification-publication-url"
-          end
-
-          it "includes a link to diff this pact version with another pact version" do
-            expect(subject[:_links][:'pb:diff'][:href]).to eq "templated-diff-url"
-            expect(subject[:_links][:'pb:diff'][:templated]).to eq true
-          end
-
-          it "includes a curie" do
-            expect(subject[:_links][:curies]).to eq [{ name: "pb", href: "http://example.org/doc/{rel}?context=pact", templated: true }]
-          end
-
-          context "when the json_content is not a Hash" do
-            let(:content_hash) { [1] }
-            it "returns the plain JSON without any links" do
-              expect(subject).to eq content_hash
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/api/decorators/pact_version_decorator_spec.rb

@@ -1,61 +0,0 @@
-require "spec_helper"
-require "pact_broker/api/decorators/pact_version_decorator"
-
-module PactBroker
-  module Api
-    module Decorators
-      describe PactVersionDecorator do
-        let(:json_content) {
-          {
-            "consumer" => {"name" => "Consumer"},
-            "provider" => {"name" => "Provider"},
-            "interactions" => [],
-            "metadata" => {}
-          }.to_json
-        }
-
-        let(:base_url) { "http://example.org" }
-        let(:created_at) { Time.new(2014, 3, 4) }
-        let(:pact) { double("pact",
-          json_content: json_content,
-          created_at: created_at,
-          consumer: consumer,
-          provider: provider,
-          consumer_version: consumer_version,
-          consumer_version_number: "1234",
-          name: "pact_name")}
-        let(:consumer) { instance_double(PactBroker::Domain::Pacticipant, name: "Consumer") }
-        let(:provider) { instance_double(PactBroker::Domain::Pacticipant, name: "Provider") }
-        let(:consumer_version) do
-          instance_double(PactBroker::Domain::Version,
-            number: "1234",
-            branch: "main",
-            pacticipant: consumer,
-            build_url: "http://build"
-          )
-        end
-        let(:decorator_context) { DecoratorContext.new(base_url, "", {}) }
-
-        let(:json) { PactVersionDecorator.new(pact).to_json(user_options: decorator_context) }
-
-        subject { JSON.parse(json, symbolize_names: true) }
-
-        it "includes a link to the pact" do
-          expect(subject[:_links][:self][:href]).to eq "http://example.org/pacts/provider/Provider/consumer/Consumer/version/1234"
-        end
-
-        it "includes the consumer version number" do
-          expect(subject[:_embedded][:consumerVersion][:number]).to eq "1234"
-        end
-
-        it "includes a link to the version" do
-          expect(subject[:_embedded][:consumerVersion][:_links][:self][:href]).to eq "http://example.org/pacticipants/Consumer/versions/1234"
-        end
-
-        it "includes timestamps" do
-          expect(subject[:createdAt]).to_not be_nil
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/api/decorators/pact_webhooks_status_decorator_spec.rb

@@ -1,138 +0,0 @@
-require "pact_broker/api/decorators/pact_webhooks_status_decorator"
-
-module PactBroker
-  module Api
-    module Decorators
-      describe PactWebhooksStatusDecorator do
-
-        let(:user_options) do
-          {consumer: "Foo", provider: "Bar", resource_url: "http://example.org/foo", base_url: "http://example.org"}
-        end
-
-        let(:triggered_webhook) do
-          double("PactBroker::Webhooks::TriggeredWebhook",
-            trigger_type: PactBroker::Webhooks::TriggeredWebhook::TRIGGER_TYPE_RESOURCE_CREATION,
-            status: status,
-            failure?: failure,
-            retrying?: retrying,
-            uuid: "1234",
-            webhook_uuid: "4321",
-            request_description: "GET http://foo",
-            pact_publication: pact,
-            number_of_attempts_made: 1,
-            number_of_attempts_remaining: 2,
-            created_at: DateTime.new(2017),
-            updated_at: DateTime.new(2017),
-            event_name: "some_event",
-            webhook: webhook
-          )
-        end
-
-        let(:webhook) { double("webhook") }
-
-        let(:pact) do
-          double("pact",
-            provider: double(name: "provider"),
-            consumer: double(name: "consumer"),
-            consumer_version_number: "1",
-            name: "foo "
-          )
-        end
-        let(:failure) { false }
-        let(:retrying) { false }
-        let(:status) { PactBroker::Webhooks::TriggeredWebhook::STATUS_SUCCESS }
-        let(:logs_url) { "http://example.org/triggered-webhooks/1234/logs" }
-        let(:triggered_webhooks) { [triggered_webhook] }
-
-        let(:json) do
-          PactWebhooksStatusDecorator.new(triggered_webhooks).to_json(user_options: user_options)
-        end
-
-        subject { JSON.parse json, symbolize_names: true }
-
-        it "includes a list of triggered webhooks" do
-          expect(subject[:_embedded][:triggeredWebhooks]).to be_instance_of(Array)
-        end
-
-        it "includes a link to the logs" do
-          expect(subject[:_embedded][:triggeredWebhooks][0][:_links][:logs][:href]).to eq logs_url
-        end
-
-        it "includes a link to the webhook" do
-          expect(subject[:_embedded][:triggeredWebhooks][0][:_links][:'pb:webhook'][:href]).to eq "http://example.org/webhooks/4321"
-        end
-
-        it "includes the triggered webhooks properties" do
-          expect(subject[:_embedded][:triggeredWebhooks].first).to include(
-            status: "success",
-            triggerType: "resource_creation",
-            attemptsMade: 1,
-            attemptsRemaining: 2
-          )
-        end
-
-        it "includes a link to the consumer" do
-          expect(subject[:_links][:'pb:consumer']).to_not be nil
-        end
-
-        it "includes a link to the provider" do
-          expect(subject[:_links][:'pb:provider']).to_not be nil
-        end
-
-        it "includes a link to the pact" do
-          expect(subject[:_links][:'pb:pact-version']).to_not be nil
-        end
-
-        it "includes a summary of the triggered webhook statuses" do
-          expect(subject[:summary]).to eq({successful: 1, failed: 0})
-        end
-
-        context "when there is a failure" do
-          let(:status) { PactBroker::Webhooks::TriggeredWebhook::STATUS_FAILURE }
-          let(:failure) { true }
-
-          it "includes a link to the error logs" do
-            expect(subject[:_links][:'pb:error-logs'][0][:href]).to eq logs_url
-          end
-
-          it "has a failed count of 1" do
-            expect(subject[:summary]).to eq({successful: 0, failed: 1})
-          end
-        end
-
-        context "when there is a retry" do
-          let(:status) { PactBroker::Webhooks::TriggeredWebhook::STATUS_RETRYING }
-          let(:retrying) { true }
-
-          it "includes a link to the error logs" do
-            expect(subject[:_links][:'pb:error-logs'][0][:href]).to eq logs_url
-          end
-
-          it "has a retrying count of 1" do
-            expect(subject[:summary]).to eq({successful: 0, failed: 0, retrying: 1})
-          end
-        end
-
-        context "when there is a not_run triggered webhook" do
-          let(:status) { PactBroker::Webhooks::TriggeredWebhook::STATUS_NOT_RUN }
-
-          it "does not include a link to the error logs" do
-            expect(subject[:_links][:'pb:error-logs']).to be_empty
-          end
-
-          it "has a notRun count of 1" do
-            expect(subject[:summary]).to eq({successful: 0, failed: 0, notRun: 1})
-          end
-        end
-
-        context "when there are no triggered webhooks" do
-          let(:triggered_webhooks) { [] }
-
-          it "doesn't blow up" do
-            subject
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/pact_broker/api/decorators/pacticipant_collection_decorator_spec.rb

@@ -1,62 +0,0 @@
-require "spec_helper"
-require "pact_broker/api/decorators/pacticipant_collection_decorator"
-require "pact_broker/domain/pacticipant"
-
-module PactBroker
-  module Api
-    module Decorators
-      describe PacticipantCollectionDecorator do
-        let(:options) { {user_options: {base_url: "http://example.org"} } }
-        let(:pacticipants) { [] }
-        let(:json) { PacticipantCollectionDecorator.new(pacticipants).to_json(options) }
-
-        subject { JSON.parse json, symbolize_names: true }
-
-        it "includes a link to find pacticipants by label" do
-          expect(subject[:_links][:'pb:pacticipants-with-label'][:href]).to match %r{http://.*label/{label}}
-        end
-
-        context "with no pacticipants" do
-          it "doesn't blow up" do
-            subject
-          end
-        end
-
-        context "with pacticipants" do
-          let(:pacticipant) { PactBroker::Domain::Pacticipant.new(name: "Name", created_at: DateTime.new, updated_at: DateTime.new)}
-          let(:pacticipants) { [pacticipant] }
-
-          it "displays a list of pacticipants" do
-            expect(subject[:_embedded][:pacticipants]).to be_instance_of(Array)
-            expect(subject[:_embedded][:pacticipants].size).to eq 1
-          end
-        end
-      end
-
-      describe DeprecatedPacticipantCollectionDecorator do
-        let(:options) { {user_options: {base_url: "http://example.org"} } }
-        let(:pacticipant) { PactBroker::Domain::Pacticipant.new(name: "Name", created_at: DateTime.new, updated_at: DateTime.new)}
-        let(:pacticipants) { [pacticipant] }
-        let(:json) { DeprecatedPacticipantCollectionDecorator.new(pacticipants).to_json(options) }
-
-        subject { JSON.parse json, symbolize_names: true }
-
-        it "includes the pacticipants under the _embedded key" do
-          expect(subject[:_embedded][:pacticipants]).to be_instance_of(Array)
-        end
-
-        it "includes the pacticipants under the pacticipants key" do
-          expect(subject[:pacticipants]).to be_instance_of(Array)
-        end
-
-        it "includes a deprecation warning in the pacticipants links" do
-          expect(subject[:_links][:pacticipants].first[:name]).to include "DEPRECATED"
-        end
-
-        it "includes a deprecation warning in the non-embedded pacticipant title" do
-          expect(subject[:pacticipants].first[:title]).to include "DEPRECATED"
-        end
-      end
-    end
-  end
-end