decidim-core 0.22.0 → 0.23.3

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/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"
@@ -42,7 +42,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 "Already following #{translated(followable.participatory_space.title)}"
           expect(page).to have_content "Stop following"

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

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

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+shared_context "with map utility" do
+  let(:organization) { create(:organization) }
+  let(:locale) { "en" }
+  let(:config) { {} }
+
+  let(:utility_class) { described_class }
+  let(:utility) { utility_class.new(organization: organization, config: config, locale: locale) }
+end
+
+shared_context "with frontend map builder" do
+  subject { described_class.new(template, options) }
+
+  let(:template_class) do
+    Class.new(ActionView::Base) do
+      def protect_against_forgery?
+        false
+      end
+
+      def snippets
+        @snippets ||= Decidim::Snippets.new
+      end
+    end
+  end
+  let(:organization) { create(:organization) }
+  let(:template) { template_class.new }
+  let(:options) { {} }
+  let(:js_options) { options.map { |k, v| [k.to_s.camelize(:lower), v] }.to_h }
+
+  before do
+    allow(template).to receive(:current_organization).and_return(organization)
+  end
+end
+
+shared_context "with dynamic map builder" do
+  include_context "with frontend map builder"
+
+  let(:options) do
+    {
+      tile_layer: {
+        url: "https://tiles.example.org",
+        options: {
+          foo: "bar",
+          attribution: "Test Attribution"
+        }
+      }
+    }
+  end
+end
+
+shared_context "with map autocomplete builder" do
+  include_context "with frontend map builder"
+
+  let(:options) { { url: "https://photon.example.org/api/" } }
+end
+
+shared_context "with frontend map elements" do
+  let(:html_head) { "" }
+  let(:html_document) do
+    builder = subject
+    document_inner = html_body
+    head_extra = html_head
+    template.instance_eval do
+      <<~HTML.strip
+        <!doctype html>
+        <html lang="en">
+        <head>
+          <title>Map Test</title>
+          #{stylesheet_link_tag "application"}
+          #{javascript_include_tag "application"}
+          #{builder.stylesheet_snippets}
+          #{builder.javascript_snippets}
+          #{head_extra}
+        </head>
+        <body>
+          #{document_inner}
+          <script type="text/javascript">
+            // This is just to indicate to Capybara that the page has fully
+            // finished loading.
+            $(document).ready(function() {
+              setTimeout(function() {
+                $("body").append('<div id="ready_indicator">Document ready</div>');
+              }, 1000);
+            });
+          </script>
+        </body>
+        </html>
+      HTML
+    end
+  end
+  let(:html_body) { "" }
+
+  before do
+    # Create a temporary route to display the generated HTML in a correct site
+    # context.
+    final_html = html_document
+    Rails.application.routes.draw do
+      get "test_dynamic_map", to: ->(_) { [200, {}, [final_html]] }
+    end
+
+    visit "/test_dynamic_map"
+  end
+
+  after do
+    expect(page).to have_selector("#ready_indicator", text: "Document ready")
+
+    expect_no_js_errors
+
+    # Reset the routes back to original
+    Rails.application.reload_routes!
+  end
+end
+
+shared_examples "a page with dynamic map" do
+  include_context "with dynamic map builder"
+
+  include_context "with frontend map elements" do
+    let(:html_body) do
+      builder = subject
+      template.instance_eval do
+        builder.map_element(id: "map", class: "google-map") do
+          content_tag(:span, "", id: "map_inner")
+        end
+      end
+    end
+  end
+
+  it "displays the map" do
+    expect(page).to have_selector("#map.google-map", visible: :all)
+    expect(page).to have_selector("#map_inner", visible: :all)
+  end
+end
+
+shared_examples "a page with geocoding input" do
+  include_context "with map autocomplete builder"
+
+  include_context "with frontend map elements" do
+    let(:html_body) do
+      builder = subject
+      template.instance_eval do
+        builder.geocoding_field(:test, :address)
+      end
+    end
+  end
+
+  it "displays the geocoding field element" do
+    config = ERB::Util.html_escape(js_options.to_json)
+    expect(subject.geocoding_field(:test, :address)).to eq(
+      %(<input autocomplete="off" data-decidim-geocoding="#{config}" type="text" name="test[address]" id="test_address" />)
+    )
+  end
+end
+
+# Use this shared example to test that the front-end geocoded address field is
+# working correctly. Fill in the other fields in the view in the before block so
+# that the saving will proceed successfully.
+shared_examples "a record with front-end geocoding address field" do |geocoded_model, view_options|
+  let(:geocoded_record) { nil }
+  let(:geocoded_address_value) { "Street2" }
+  let(:geocoded_address_coordinates) { [3.345, 4.456] }
+
+  it "calls the front-end geocoder when an address is written", :slow do
+    within view_options[:within_selector] do
+      fill_in_geocoding view_options[:address_field], with: geocoded_address_value
+      find(".tribute-container ul#results li", match: :first).click
+      find("*[type=submit]").click
+    end
+
+    # Check that the latitude and longitude are according to the front-end
+    # geocoder as one of the autocompleted addresses were selected. The back-end
+    # geocoding should be bypassed in this situation which is why these match
+    # what was returned by the front-end geocoding. These values are returned by
+    # the dummy test geocoding API defined at
+    # `decidim-dev/lib/decidim/dev/test/rspec_support/geocoder.rb`. Search for
+    # `:serves_geocoding_autocomplete`.
+    expect(page).to have_content("successfully")
+    final = if geocoded_record
+              geocoded_model.find(geocoded_record.id)
+            else
+              geocoded_model.last
+            end
+    expect(final.latitude).to eq(geocoded_address_coordinates[0])
+    expect(final.longitude).to eq(geocoded_address_coordinates[1])
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+shared_examples_for "preview component with share_token" do
+  context "when component is unpublished" do
+    before do
+      component.unpublish!
+    end
+
+    context "when no share_token is provided" do
+      before do
+        visit_component
+      end
+
+      it "does not allow visiting component" do
+        expect(page).to have_content "You are not authorized"
+        # rubocop:disable Capybara/CurrentPathExpectation
+        expect(page.current_path).not_to match main_component_path(component)
+        # rubocop:enable Capybara/CurrentPathExpectation
+      end
+    end
+
+    context "when a share_token is provided" do
+      let(:share_token) { create(:share_token, token_for: component) }
+      let(:params) { { share_token: share_token.token } }
+
+      before do
+        uri = URI(main_component_path(component))
+        uri.query = URI.encode_www_form(params.to_a)
+        visit uri
+      end
+
+      context "when a valid share_token is provided" do
+        it "allows visiting component" do
+          expect(page).not_to have_content "You are not authorized"
+          # rubocop:disable Capybara/CurrentPathExpectation
+          expect(page.current_path).to match main_component_path(component)
+          # rubocop:enable Capybara/CurrentPathExpectation
+        end
+      end
+
+      context "when an invalid share_token is provided" do
+        let(:share_token) { create(:share_token, :expired, token_for: component) }
+
+        it "does not allow visiting component" do
+          expect(page).to have_content "You are not authorized"
+          # rubocop:disable Capybara/CurrentPathExpectation
+          expect(page.current_path).not_to match main_component_path(component)
+          # rubocop:enable Capybara/CurrentPathExpectation
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+shared_examples_for "a resource search" do |factory_name|
+  context "when no component is passed" do
+    let(:params) { default_params.merge(component: nil) }
+
+    it "raises an error" do
+      expect { subject }.to raise_error(StandardError, "Missing component")
+    end
+  end
+
+  describe "component_id" do
+    it "only returns resources from the given component" do
+      external_resource = create(factory_name)
+
+      expect(subject).not_to include(external_resource)
+    end
+  end
+end
+
+shared_examples_for "a resource search with scopes" do |factory_name|
+  let(:factory_params) do
+    resource_params
+  rescue StandardError
+    {}
+  end
+
+  describe "scope_id filter" do
+    let(:params) { default_params.merge(scope_id: scope_ids) }
+
+    let(:scope1) { create :scope, organization: component.organization }
+    let(:scope2) { create :scope, organization: component.organization }
+    let(:subscope1) { create :scope, organization: component.organization, parent: scope1 }
+
+    let!(:resource) { create(factory_name, { component: component, scope: scope1 }.merge(factory_params)) }
+    let!(:resource2) { create(factory_name, { component: component, scope: scope2 }.merge(factory_params)) }
+    let!(:resource3) { create(factory_name, { component: component, scope: subscope1 }.merge(factory_params)) }
+
+    context "when a parent scope id is being sent" do
+      let(:scope_ids) { [scope1.id] }
+
+      it "filters resources by scope" do
+        expect(subject).to match_array [resource, resource3]
+      end
+    end
+
+    context "when a subscope id is being sent" do
+      let(:scope_ids) { [subscope1.id] }
+
+      it "filters resources by scope" do
+        expect(subject).to eq [resource3]
+      end
+    end
+
+    context "when multiple ids are sent" do
+      let(:scope_ids) { [scope2.id, scope1.id] }
+
+      it "filters resources by scope" do
+        expect(subject).to match_array [resource, resource2, resource3]
+      end
+    end
+
+    context "when `global` is being sent" do
+      let!(:resource_without_scope) { create(factory_name, { component: component, scope: nil }.merge(factory_params)) }
+      let(:scope_ids) { ["global"] }
+
+      it "returns resources without a scope" do
+        expect(subject).to match_array [resource_without_scope]
+      end
+    end
+
+    context "when `global` and some ids is being sent" do
+      let!(:resource_without_scope) { create(factory_name, { component: component, scope: nil }.merge(factory_params)) }
+      let(:scope_ids) { ["global", scope2.id, scope1.id] }
+
+      it "returns resources without a scope and with selected scopes" do
+        expect(subject).to match_array [resource_without_scope, resource, resource2, resource3]
+      end
+    end
+  end
+end
+
+shared_examples_for "a resource search with categories" do |factory_name|
+  let(:participatory_process) { component.participatory_space }
+  let(:params) { default_params.merge(category_id: category_ids) }
+  let(:factory_params) do
+    resource_params
+  rescue StandardError
+    {}
+  end
+
+  describe "results" do
+    let(:category1) { create :category, participatory_space: participatory_process }
+    let(:category2) { create :category, participatory_space: participatory_process }
+    let(:child_category) { create :category, participatory_space: participatory_process, parent: category2 }
+    let!(:resource) { create(factory_name, { component: component }.merge(factory_params)) }
+    let!(:resource2) { create(factory_name, { component: component, category: category1 }.merge(factory_params)) }
+    let!(:resource3) { create(factory_name, { component: component, category: category2 }.merge(factory_params)) }
+    let!(:resource4) { create(factory_name, { component: component, category: child_category }.merge(factory_params)) }
+
+    context "when no category filter is present" do
+      let(:category_ids) { nil }
+
+      it "includes all resources" do
+        expect(subject).to match_array [resource, resource2, resource3, resource4]
+      end
+    end
+
+    context "when a category is selected" do
+      let(:category_ids) { [category2.id] }
+
+      it "includes only resources for that category and its children" do
+        expect(subject).to match_array [resource3, resource4]
+      end
+    end
+
+    context "when a subcategory is selected" do
+      let(:category_ids) { [child_category.id] }
+
+      it "includes only resources for that category" do
+        expect(subject).to eq [resource4]
+      end
+    end
+
+    context "when `without` is being sent" do
+      let(:category_ids) { ["without"] }
+
+      it "returns resources without a category" do
+        expect(subject).to eq [resource]
+      end
+    end
+
+    context "when `without` and some category id is being sent" do
+      let(:category_ids) { ["without", category1.id] }
+
+      it "returns resources without a category and with the selected category" do
+        expect(subject).to match_array [resource, resource2]
+      end
+    end
+  end
+end
+
+shared_examples_for "a resource search with origin" do |factory_name|
+  let(:factory_params) do
+    resource_params
+  rescue StandardError
+    {}
+  end
+  let(:params) { default_params.merge(origin: origins) }
+
+  describe "results" do
+    let!(:official_resource) { create(factory_name, :official, { component: component }.merge(factory_params)) }
+    let!(:user_group_resource) { create(factory_name, :user_group_author, { component: component }.merge(factory_params)) }
+    let!(:citizen_resource) { create(factory_name, :citizen_author, { component: component }.merge(factory_params)) }
+
+    if FactoryBot.factory_by_name(factory_name).defined_traits.map(&:name).include?(:meeting_resource)
+      let!(:meeting_resource) { create(factory_name, :official_meeting, { component: component }.merge(factory_params)) }
+    end
+
+    context "when filtering official resources" do
+      let(:origins) { %w(official) }
+
+      it "returns only official resources" do
+        expect(subject.size).to eq(1)
+        expect(subject).to include(official_resource)
+      end
+    end
+
+    context "when filtering citizen resources" do
+      let(:origins) { %w(citizens) }
+
+      it "returns only citizen resources" do
+        expect(subject.size).to eq(1)
+        expect(subject).to include(citizen_resource)
+      end
+    end
+
+    context "when filtering user groups resources" do
+      let(:origins) { %w(user_group) }
+
+      it "returns only user groups resources" do
+        expect(subject.size).to eq(1)
+        expect(subject).to include(user_group_resource)
+      end
+    end
+
+    if respond_to?(:meeting_resource)
+      context "when filtering meetings resources" do
+        let(:origins) { %w(meeting) }
+
+        it "returns only meeting resources" do
+          expect(subject.size).to eq(1)
+          expect(subject).to include(meeting_resource)
+        end
+      end
+    end
+  end
+end