decidim-core 0.20.0 → 0.23.1.rc1

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

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+shared_examples "having a rich text editor" do |css, toolbar|
+  it "has a form with a rich text editor" do
+    within "form.#{css}" do
+      expect(page).to have_selector("div.editor-container[data-toolbar='#{toolbar}']", visible: :all)
+    end
+  end
+end
+
+shared_context "with rich text editor content" do
+  let(:content) { "<p>" + safe_tags + "</p>" + script }
+  let(:safe_tags) { em + u + strong }
+  let(:em) { "<em>em</em>" }
+  let(:u) { "<u>u</u>" }
+  let(:strong) { "<strong>strong</strong>" }
+  let(:script) { "<script>alert('SCRIPT')</script>" }
+end
+
+shared_examples "rendering safe content" do |css|
+  include_context "with rich text editor content"
+
+  it "renders potentially safe HTML tags unescaped" do
+    within css do
+      expect(page).to have_selector("em", text: "em")
+      expect(page).to have_selector("u", text: "u")
+      expect(page).to have_selector("strong", text: "strong")
+    end
+  end
+
+  it "sanitizes potentially malicious HTML tags" do
+    within css do
+      expect(page).not_to have_selector("script", visible: :all)
+      expect(page).to have_content("alert('SCRIPT')")
+    end
+  end
+end
+
+shared_examples "rendering unsafe content" do |css|
+  include_context "with rich text editor content"
+
+  it "sanitizes potentially safe HTML tags" do
+    within css do
+      expect(page).not_to have_selector("em")
+      expect(page).to have_content("em")
+      expect(page).not_to have_selector("u")
+      expect(page).to have_content("u")
+      expect(page).not_to have_selector("strong")
+      expect(page).to have_content("strong")
+    end
+  end
+
+  it "strips potentially malicious HTML tags" do
+    within css do
+      expect(page).not_to have_selector("script", visible: :all)
+      expect(page).not_to have_content("alert('SCRIPT')")
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+shared_examples_for "a scopable resource" do
+  before do
+    current_component.update!(settings: { scopes_enabled: true, scope_id: parent_scope.id })
+  end
+
+  context "when the scope exists" do
+    it { expect(form.scope).to be_kind_of(Decidim::Scope) }
+  end
+
+  context "when the scope does not exist" do
+    let(:scope_id) { 3456 }
+
+    it { expect(form.scope).to eq(nil) }
+  end
+
+  context "when the scope is from another organization" do
+    let(:scope_id) { create(:scope).id }
+
+    it { expect(form.scope).to eq(nil) }
+  end
+
+  context "when the component has a scope" do
+    context "when the scope is descendant from component scope" do
+      let(:scope) { create(:scope, organization: organization, parent: parent_scope) }
+
+      it { expect(form.scope).to eq(scope) }
+    end
+
+    context "when the scope is not descendant from component scope" do
+      let(:another_scope) { create(:scope, organization: organization) }
+      let(:scope) { create(:subscope, parent: another_scope) }
+      let(:scope_id) { scope.id }
+
+      it { expect(form.scope).to eq(scope) }
+
+      it "makes the form invalid" do
+        expect(form).to be_invalid
+      end
+    end
+  end
+end

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

@@ -6,8 +6,17 @@ shared_examples "scope helpers" do
   let(:organization) { create(:organization) }
   let(:scopes_enabled) { true }
   let(:participatory_space_scope) { nil }
-  let(:component) { create(:component, manifest_name: "dummy", participatory_space: participatory_space) }
+  let(:component_scope) { nil }
+  let(:component) do
+    create(
+      :component,
+      manifest_name: "dummy",
+      participatory_space: participatory_space,
+      settings: { scopes_enabled: scopes_enabled, scope_id: component_scope&.id }
+    )
+  end
   let(:scope) { create(:scope, organization: organization) }
+  let(:subscope) { create(:subscope, organization: organization) }
   let(:resource) { create(:dummy_resource, component: component, scope: scope) }
 
   before do
@@ -36,12 +45,14 @@ shared_examples "scope helpers" do
 
     context "when the process has a different scope than the organization" do
       let(:participatory_space_scope) { create(:scope, organization: organization) }
+      let(:component_scope) { participatory_space_scope }
 
       it { is_expected.to be_truthy }
     end
 
     context "when the process has the same scope as the organization" do
       let(:participatory_space_scope) { scope }
+      let(:component_scope) { scope }
 
       it { is_expected.to be_falsey }
     end

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

@@ -36,7 +36,7 @@ shared_examples "global search of participatory spaces" do
         it "updates the associated SearchableResource after published ParticipatorySpace update" do
           searchable = ::Decidim::SearchableResource.find_by(resource_type: participatory_space.class.name, resource_id: participatory_space.id)
           created_at = searchable.created_at
-          updated_title = "Brand new title"
+          updated_title = { "en" => "Brand new title" }
           participatory_space.update(title: updated_title)
 
           participatory_space.save!
@@ -44,7 +44,7 @@ shared_examples "global search of participatory spaces" do
 
           organization.available_locales.each do |locale|
             searchable = ::Decidim::SearchableResource.find_by(resource_type: participatory_space.class.name, resource_id: participatory_space.id, locale: locale)
-            expect(searchable.content_a).to eq updated_title
+            expect(searchable.content_a).to eq updated_title[locale.to_s].to_s
             expect(searchable.updated_at).to be > created_at
           end
         end
@@ -139,7 +139,6 @@ shared_examples "global search of participatory spaces" do
       "resource_id" => space.id,
       "resource_type" => space.class.name
     }.merge(searchable_resource_attrs_mapper.call(space, locale))
-    h.merge
     h
   end
 end

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

@@ -12,16 +12,29 @@ shared_examples "searchable results" do
     before do
       expect(searchables).not_to be_empty
       expect(term).not_to be_empty
+    end
 
+    it "contains these searchables" do
       fill_in "term", with: term
       find("input#term").native.send_keys :enter
-    end
 
-    it "contains these searchables" do
       expect(page).to have_current_path decidim.search_path, ignore_query: true
       expect(page).to have_content(/results for the search: "#{term}"/i)
       expect(page).to have_selector(".filters__section")
       expect(page.find("#search-count .section-heading").text.to_i).to be_positive
     end
+
+    it "finds content by hashtag" do
+      if respond_to?(:hashtag)
+        fill_in "term", with: hashtag
+        find("input#term").native.send_keys :enter
+
+        expect(page.find("#search-count .section-heading").text.to_i).to be_positive
+
+        within "#results" do
+          expect(page).to have_content(hashtag)
+        end
+      end
+    end
   end
 end

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

@@ -29,6 +29,7 @@ shared_context "when a simple event" do
   let(:resource_path) { resource_locator(resource).path }
   let(:resource_url) { resource_locator(resource).url }
   let(:resource_title) { resource.title["en"] }
+  # to be used when resource is a component resource, not a participatory space, in which case should be overriden
   let(:participatory_space) { resource.participatory_space }
   let(:participatory_space_title) { participatory_space.title["en"] }
   let(:participatory_space_path) { Decidim::ResourceLocatorPresenter.new(participatory_space).path }
@@ -88,6 +89,13 @@ shared_examples_for "a simple event" do |skip_space_checks|
     end
   end
 
+  describe "safe_resource_text" do
+    it "is generated correctly" do
+      expect(subject.safe_resource_text).to be_kind_of(String)
+      expect(subject.safe_resource_text).to be_html_safe
+    end
+  end
+
   describe "notification_title" do
     it "is generated correctly" do
       expect(subject.notification_title).to be_kind_of(String)

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

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+shared_context "with resources to be endorsed or not" do
+  include_context "with a component"
+
+  # Should be overriden and create one main resource
+  let!(:resource) {}
+  # the name of the resource to be clicked from the component view
+  let(:resource_name) {}
+  # Should be overriden and create 3 extra resources in the current component
+  let!(:resources) {}
+end
+
+shared_examples "Endorse resource system specs" do
+  def expect_page_not_to_include_endorsements
+    expect(page).to have_no_button("Endorse")
+    expect(page).to have_no_css("#resource-#{resource.id}-endorsements-count")
+  end
+
+  def visit_resource
+    visit_component
+    click_link resource_name
+  end
+
+  context "when endorsements are not enabled" do
+    let(:component_traits) { [:with_votes_enabled, :with_endorsements_disabled] }
+
+    context "when the user is not logged in" do
+      it "doesn't show the endorse resource button and counts" do
+        visit_resource
+        expect_page_not_to_include_endorsements
+      end
+    end
+
+    context "when the user is logged in" do
+      before do
+        login_as user, scope: :user
+      end
+
+      it "doesn't show the endorse resource button and counts" do
+        visit_resource
+        expect_page_not_to_include_endorsements
+      end
+    end
+  end
+
+  context "when endorsements are enabled but blocked" do
+    let(:component_traits) { [:with_endorsements_enabled, :with_endorsements_blocked] }
+
+    it "shows the endorsements count and the endorse button is disabled" do
+      visit_resource
+      expect(page).to have_css(".buttons__row span[disabled]")
+    end
+  end
+
+  context "when endorsements are enabled" do
+    let(:component_traits) { [:with_votes_enabled, :with_endorsements_enabled] }
+
+    context "when the user is not logged in" do
+      it "is given the option to sign in" do
+        visit_resource
+        within ".buttons__row", match: :first do
+          click_button "Endorse"
+        end
+
+        expect(page).to have_css("#loginModal", visible: :visible)
+      end
+    end
+
+    context "when the user is logged in" do
+      before do
+        login_as user, scope: :user
+      end
+
+      context "when the resource is not endorsed yet" do
+        it "is able to endorse the resource" do
+          visit_resource
+          within ".buttons__row" do
+            click_button "Endorse"
+            expect(page).to have_button("Endorsed")
+          end
+
+          within "#resource-#{resource.id}-endorsements-count" do
+            expect(page).to have_content("1")
+          end
+        end
+      end
+
+      context "when the resource is already endorsed" do
+        let!(:endorsement) { create(:endorsement, resource: resource, author: user) }
+
+        it "is not able to endorse it again" do
+          visit_resource
+          within ".buttons__row" do
+            expect(page).to have_button("Endorsed")
+            expect(page).to have_no_button("Endorse ")
+          end
+
+          within "#resource-#{resource.id}-endorsements-count" do
+            expect(page).to have_content("1")
+          end
+        end
+
+        it "is able to undo the endorsement" do
+          visit_resource
+          within ".buttons__row" do
+            click_button "Endorsed"
+            expect(page).to have_button("Endorse")
+          end
+
+          within "#resource-#{resource.id}-endorsements-count" do
+            expect(page).to have_content("0")
+          end
+        end
+      end
+
+      context "when verification is required" do
+        let(:permissions) do
+          {
+            endorse: {
+              authorization_handlers: {
+                "dummy_authorization_handler" => { "options" => {} }
+              }
+            }
+          }
+        end
+
+        before do
+          organization.available_authorizations = ["dummy_authorization_handler"]
+          organization.save!
+          component.update(permissions: permissions)
+        end
+
+        context "when user is NOT verified" do
+          it "is NOT able to endorse" do
+            visit_resource
+            within ".buttons__row", match: :first do
+              click_button "Endorse"
+            end
+            expect(page).to have_css("#authorizationModal", visible: :visible)
+          end
+        end
+
+        context "when user IS verified" do
+          before do
+            handler_params = { user: user }
+            handler_name = "dummy_authorization_handler"
+            handler = Decidim::AuthorizationHandler.handler_for(handler_name, handler_params)
+
+            Decidim::Authorization.create_or_update_from(handler)
+          end
+
+          it "IS able to endorse", :slow do
+            visit_resource
+            within ".buttons__row", match: :first do
+              click_button "Endorse"
+            end
+            expect(page).to have_button("Endorsed")
+          end
+        end
+      end
+    end
+  end
+end