decidim-core 0.20.0 → 0.23.1.rc1

data/lib/decidim/core/test/shared_examples/embed_resource_examples.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+shared_examples_for "an embed resource" do |options|
+  if options.is_a?(Hash) && options[:skip_space_checks]
+    let(:organization) { resource.organization }
+
+    before do
+      switch_to_host(organization.host)
+    end
+  else
+    include_context "with a component"
+  end
+
+  context "when visiting the embed page for a resource" do
+    before do
+      visit resource_locator(resource).path
+      visit "#{current_path}/embed"
+    end
+
+    it "renders the page correctly" do
+      if resource.title.is_a?(Hash)
+        expect(page).to have_i18n_content(resource.title)
+      else
+        expect(page).to have_content(resource.title)
+      end
+
+      expect(page).to have_content(organization.name)
+    end
+
+    unless options.is_a?(Hash) && options[:skip_space_checks]
+      context "when the participatory_space is a process" do
+        it "shows the process name" do
+          expect(page).to have_i18n_content(participatory_process.title)
+        end
+      end
+
+      context "when the participatory_space is an assembly" do
+        let(:assembly) do
+          create(:assembly, organization: organization)
+        end
+        let(:participatory_space) { assembly }
+
+        it "shows the assembly name" do
+          expect(page).to have_i18n_content(assembly.title)
+        end
+      end
+    end
+  end
+end

data/lib/decidim/core/test/shared_examples/endorsable_interface_examples.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+shared_examples_for "endorsable interface" do
+  describe "endorsementsCount" do
+    let(:query) { "{ endorsementsCount }" }
+
+    it "returns the amount of endorsements for this query" do
+      expect(response["endorsementsCount"]).to eq(model.endorsements.count)
+    end
+  end
+
+  describe "endorsements" do
+    let(:query) { "{ endorsements { name } }" }
+
+    it "returns the endorsements this query has received" do
+      endorsement_names = response["endorsements"].map { |endorsement| endorsement["name"] }
+      expect(endorsement_names).to include(*model.endorsements.map(&:author).map(&:name))
+    end
+  end
+end

data/lib/decidim/core/test/shared_examples/endorsements_controller_shared_context.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+RSpec.shared_context "when in a resource" do
+  routes { Decidim::Core::Engine.routes }
+
+  let(:resource) { create(:dummy_resource, component: component) }
+  let(:user) { create(:user, :confirmed, organization: component.organization) }
+  let(:params) do
+    {
+      id: resource.to_gid.to_param,
+      component_id: component.id,
+      participatory_process_slug: component.participatory_space.slug
+    }
+  end
+
+  before do
+    request.env["decidim.current_organization"] = component.organization
+    request.env["decidim.current_component"] = component
+    request.env["decidim.current_participatory_space"] = component.participatory_space
+    sign_in user
+  end
+end

data/lib/decidim/core/test/shared_examples/fingerprintable_interface_examples.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+shared_examples_for "fingerprintable interface" do
+  describe "fingerprint" do
+    let(:query) { "{ fingerprint { value source } }" }
+
+    it "returns the fingerprint value" do
+      expect(response["fingerprint"]["value"]).to eq(model.fingerprint.value)
+    end
+
+    it "returns the fingerprint source" do
+      expect(response["fingerprint"]["source"]).to eq(model.fingerprint.source)
+    end
+  end
+end

data/lib/decidim/core/test/shared_examples/follows_examples.rb

@@ -10,7 +10,7 @@ shared_examples "follows" do
   context "when not following the followable" do
     context "when user clicks the Follow button" do
       it "makes the user follow the followable" do
-        visit resource_locator(followable).path
+        visit followable_path
         expect do
           click_button "Follow"
           expect(page).to have_content "Stop following"
@@ -26,7 +26,7 @@ shared_examples "follows" do
 
     context "when user clicks the Follow button" do
       it "makes the user follow the followable" do
-        visit resource_locator(followable).path
+        visit followable_path
         expect do
           click_button "Stop following"
           expect(page).to have_content "Follow"
@@ -34,4 +34,20 @@ shared_examples "follows" do
       end
     end
   end
+
+  context "when the user is following the followable's participatory space" do
+    before do
+      create(:follow, followable: followable.participatory_space, user: user)
+    end
+
+    context "when user clicks the Follow button" do
+      it "makes the user follow the followable" do
+        visit followable_path
+        expect do
+          click_button "Already following #{translated(followable.participatory_space.title)}"
+          expect(page).to have_content "Stop following"
+        end.to change(Decidim::Follow, :count).by(1)
+      end
+    end
+  end
 end

data/lib/decidim/core/test/shared_examples/input_filter_examples.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+shared_examples_for "collection has before/since input filter" do |collection, field|
+  context "when date is before the past" do
+    let(:query) { %[{ #{collection}(filter: {#{field}Before: "#{2.days.ago.to_date}"}) { id } }] }
+
+    it "finds nothing" do
+      ids = response[collection].map { |item| item["id"] }
+      expect(ids).to eq([])
+    end
+  end
+
+  context "when date is before the future" do
+    let(:query) { %[{ #{collection}(filter: {#{field}Before: "#{2.days.from_now.to_date}"}) { id } }] }
+
+    it "finds the models " do
+      ids = response[collection].map { |item| item["id"] }
+      expect(ids).to match_array(models.map(&:id).map(&:to_s))
+    end
+  end
+
+  context "when date is after the future" do
+    let(:query) { %[{ #{collection}(filter: {#{field}Since: "#{2.days.from_now.to_date}"}) { id } }] }
+
+    it "finds nothing " do
+      ids = response[collection].map { |item| item["id"] }
+      expect(ids).to eq([])
+    end
+  end
+
+  context "when date is after the past" do
+    let(:query) { %[{ #{collection}(filter: {#{field}Since: "#{2.days.ago.to_date}"}) { id } }] }
+
+    it "finds the models " do
+      ids = response[collection].map { |item| item["id"] }
+      expect(ids).to match_array(models.map(&:id).map(&:to_s))
+    end
+  end
+end
+
+shared_examples_for "connection has before/since input filter" do |connection, field|
+  context "when date is before the past" do
+    let(:query) { %[{ #{connection}(filter: {#{field}Before: "#{2.days.ago.to_date}"}) { edges { node { id } } } }] }
+
+    it "finds nothing" do
+      ids = response[connection]["edges"].map { |edge| edge["node"]["id"] }
+      expect(ids).to eq([])
+    end
+  end
+
+  context "when date is before the future" do
+    let(:query) { %[{ #{connection}(filter: {#{field}Before: "#{2.days.from_now.to_date}"}) { edges { node { id } } } }] }
+
+    it "finds the models " do
+      ids = response[connection]["edges"].map { |edge| edge["node"]["id"] }
+      expect(ids).to match_array(models.map(&:id).map(&:to_s))
+    end
+  end
+
+  context "when date is after the future" do
+    let(:query) { %[{ #{connection}(filter: {#{field}Since: "#{2.days.from_now.to_date}"}) { edges { node { id } } } }] }
+
+    it "finds nothing " do
+      ids = response[connection]["edges"].map { |edge| edge["node"]["id"] }
+      expect(ids).to eq([])
+    end
+  end
+
+  context "when date is after the past" do
+    let(:query) { %[{ #{connection}(filter: {#{field}Since: "#{2.days.ago.to_date}"}) { edges { node { id } } } }] }
+
+    it "finds the models " do
+      ids = response[connection]["edges"].map { |edge| edge["node"]["id"] }
+      expect(ids).to match_array(models.map(&:id).map(&:to_s))
+    end
+  end
+end
+
+shared_examples_for "collection has hashtag input filter" do |collection|
+  let(:query) { %[{ #{collection}(filter: { hashtag: "#{hashtag}" }) { id }}] }
+
+  before do
+    models.first.hashtag = "#someWeirdHashtag"
+    models.first.save!
+    models.second.hashtag = "#anotherWeirdHashtag"
+    models.second.save!
+  end
+
+  context "when hashtag starts with #" do
+    let(:hashtag) { "#someWeirdHashtag" }
+
+    it "finds the model" do
+      ids = response[collection].map { |item| item["id"] }
+      expect(ids).to include(models.first.id.to_s)
+      expect(ids).not_to include(models.second.id.to_s)
+    end
+  end
+
+  context "when hashtag starts without #" do
+    let(:hashtag) { "anotherWeirdHashtag" }
+
+    it "finds the model" do
+      ids = response[collection].map { |item| item["id"] }
+      expect(ids).not_to include(models.first.id.to_s)
+      expect(ids).to include(models.second.id.to_s)
+    end
+  end
+
+  context "when hashtag is different" do
+    let(:hashtag) { "someEvenWeirderHashtag" }
+
+    it "does not find the model" do
+      ids = response[collection].map { |item| item["id"] }
+      expect(ids).not_to include(models.first.id.to_s)
+      expect(ids).not_to include(models.second.id.to_s)
+    end
+  end
+end

data/lib/decidim/core/test/shared_examples/input_sort_examples.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+shared_examples_for "collection has input sort" do |collection, field|
+  describe "ASC" do
+    let(:query) { %[{ #{collection}(order: {#{field}: "ASC"}) { id } }] }
+
+    it "returns expected order" do
+      ids = response[collection].map { |item| item["id"] }
+      replies_ids = models.sort_by(&field.underscore.to_sym).map(&:id).map(&:to_s)
+      expect(ids).to eq(replies_ids)
+      expect(ids).not_to eq(replies_ids.reverse)
+    end
+  end
+
+  describe "DESC" do
+    let(:query) { %[{ #{collection}(order: {#{field}: "DESC"}) { id } }] }
+
+    it "returns reversed order" do
+      ids = response[collection].map { |item| item["id"] }
+      replies_ids = models.sort_by(&field.underscore.to_sym).map(&:id).map(&:to_s)
+      expect(ids).not_to eq(replies_ids)
+      expect(ids).to eq(replies_ids.reverse)
+    end
+  end
+end
+
+shared_examples_for "collection has i18n input sort" do |collection, field|
+  context "when locale is not specified" do
+    describe "ASC" do
+      let(:query) { %[{ #{collection}(order: { #{field}: "ASC" }) { id } }] }
+
+      it "returns alphabetical order" do
+        response_ids = response[collection].map { |item| item["id"].to_i }
+        ids = models.sort_by { |item| item.public_send(field.to_sym)[current_organization.default_locale] }.map { |item| item.id.to_i }
+        expect(response_ids).to eq(ids)
+        expect(response_ids).not_to eq(ids.reverse)
+      end
+    end
+
+    describe "DESC" do
+      let(:query) { %[{ #{collection}(order: { #{field}: "DESC" }) { id } }] }
+
+      it "returns revered alphabetical order" do
+        response_ids = response[collection].map { |item| item["id"].to_i }
+        ids = models.sort_by { |item| item.public_send(field.to_sym)[current_organization.default_locale] }.map { |item| item.id.to_i }
+        expect(response_ids).not_to eq(ids)
+        expect(response_ids).to eq(ids.reverse)
+      end
+    end
+  end
+
+  context "when locale is specified" do
+    describe "ASC" do
+      let(:query) { %[{ #{collection}(order: { #{field}: "ASC", locale: "ca" }) { id } }] }
+
+      it "returns alphabetical order" do
+        response_ids = response[collection].map { |item| item["id"].to_i }
+        ids = models.sort_by { |item| item.public_send(field.to_sym)["ca"] }.map { |item| item.id.to_i }
+        expect(response_ids).to eq(ids)
+        expect(response_ids).not_to eq(ids.reverse)
+      end
+    end
+
+    describe "DESC" do
+      let(:query) { %[{ #{collection}(order: { #{field}: "DESC", locale: "ca" }) { id } }] }
+
+      it "returns revered alphabetical order" do
+        response_ids = response[collection].map { |item| item["id"].to_i }
+        ids = models.sort_by { |item| item.public_send(field.to_sym)["ca"] }.map { |item| item.id.to_i }
+        expect(response_ids).not_to eq(ids)
+        expect(response_ids).to eq(ids.reverse)
+      end
+    end
+
+    context "when locale does not exist in the organization" do
+      let(:query) { %[{ #{collection}(order: { #{field}: "DESC", locale: "de" }) { id } }] }
+
+      it "returns all the component ordered" do
+        expect { response }.to raise_exception(Exception)
+      end
+    end
+  end
+end
+
+shared_examples_for "connection has input sort" do |connection, field|
+  describe "ASC" do
+    let(:query) { %[{ #{connection}(order: {#{field}: "ASC"}) { edges { node { id } } } }] }
+
+    it "returns expected order" do
+      ids = response[connection]["edges"].map { |edge| edge["node"]["id"] }
+      replies_ids = models.sort_by(&field.underscore.to_sym).map(&:id).map(&:to_s)
+      expect(ids).to eq(replies_ids)
+    end
+  end
+
+  describe "DESC" do
+    let(:query) { %[{ #{connection}(order: {#{field}: "DESC"}) { edges { node { id } } } }] }
+
+    it "returns reversed order" do
+      ids = response[connection]["edges"].map { |edge| edge["node"]["id"] }
+      replies_ids = models.sort_by(&field.underscore.to_sym).map(&:id).map(&:to_s)
+      expect(ids).to eq(replies_ids.reverse)
+    end
+  end
+end
+
+# This example requires a let!(:most_endorsed)
+shared_examples_for "connection has endorsement_count sort" do |connection|
+  describe "ASC" do
+    let(:query) { %[{ #{connection}(order: {endorsementCount: "ASC"}) { edges { node { id } } } }] }
+
+    it "returns the most endorsed last" do
+      expect(response[connection]["edges"].count).to eq(4)
+      expect(response[connection]["edges"].last["node"]["id"]).to eq(most_endorsed.id.to_s)
+    end
+  end
+
+  describe "DESC" do
+    let(:query) { %[{ #{connection}(order: {endorsementCount: "DESC"}) { edges { node { id } } } }] }
+
+    it "returns the most endorsed first" do
+      expect(response[connection]["edges"].count).to eq(4)
+      expect(response[connection]["edges"].first["node"]["id"]).to eq(most_endorsed.id.to_s)
+    end
+  end
+end

data/lib/decidim/core/test/shared_examples/logo_email.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+shared_examples "email with logo" do
+  context "when organization has a logo" do
+    let(:organization_logo) { Decidim::Dev.test_file("city.jpeg", "image/jpeg") }
+    let(:organization) { create(:organization, logo: organization_logo) }
+    let(:mail) { described_class.event_received(event, event_class_name, resource, user, :follower, extra) }
+
+    it "includes organization logo" do
+      expect(mail.body).to include(organization.logo.medium.url)
+    end
+
+    it "includes organization logo with full link" do
+      expect(mail.body).to include("alt=\"#{organization.name}\"")
+      expect(mail.body).to match(%r{http[s]{0,1}:\/\/#{organization.host}#{organization.logo.medium.url}})
+    end
+  end
+end

data/lib/decidim/core/test/shared_examples/manage_component_share_tokens.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples "manage component share tokens" do
+  let!(:components_path) { participatory_space_components_path(participatory_space) }
+
+  context "when visiting the components page for the participatory space" do
+    before do
+      visit components_path
+    end
+
+    it "has a share button that opens the share url for the component" do
+      share_window = window_opened_by { click_link "Share", wait: 2 }
+
+      within_window share_window do
+        expect(page).to have_current_path(component.share_tokens.reload.last.url)
+      end
+    end
+  end
+
+  context "when visiting the component configuration page" do
+    context "when there are tokens" do
+      let!(:share_tokens) { create_list(:share_token, 3, token_for: component, organization: component.organization) }
+      let!(:share_token) { share_tokens.last }
+
+      before do
+        visit components_path
+
+        within find("tr", text: component.name["en"]) do
+          click_link "Configure"
+        end
+      end
+
+      it "displays all tokens" do
+        within ".share_tokens" do
+          expect(page).to have_selector("tbody tr", count: 3)
+        end
+      end
+
+      it "displays relevant attributes for each token" do
+        share_tokens.each do |share_token|
+          within ".share_tokens tbody" do
+            expect(page).to have_content share_token.token
+            expect(page).to have_content share_token.user.name
+          end
+        end
+      end
+
+      it "has a share link for each token" do
+        urls = share_tokens.map(&:url).map { |url| url.split("?").first }
+        within ".share_tokens tbody tr:first-child" do
+          share_window = window_opened_by { click_link "Share" }
+
+          within_window share_window do
+            expect(urls).to include(page.current_path)
+          end
+        end
+      end
+
+      it "has a link to delete tokens" do
+        within ".share_tokens tbody tr:first-child" do
+          accept_confirm { click_link "Delete" }
+        end
+
+        expect(page).to have_admin_callout("successfully")
+        expect(page).to have_selector("tbody tr", count: 2)
+      end
+    end
+
+    context "when there are no tokens" do
+      before do
+        visit components_path
+
+        within find("tr", text: component.name["en"]) do
+          click_link "Configure"
+        end
+      end
+
+      it "displays empty message" do
+        expect(page).to have_content "There are no active tokens"
+      end
+    end
+  end
+end