decidim-core 0.29.2 → 0.30.0.rc1

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

@@ -4,8 +4,8 @@ require "spec_helper"
 
 shared_examples_for "general conversation permissions" do
   let(:context) { { conversation: } }
-  let(:another_user) { create :user }
-  let(:group) { create :user_group }
+  let(:another_user) { create(:user) }
+  let(:group) { create(:user_group) }
 
   context "when the originator of the conversation is the user" do
     let!(:conversation) do
@@ -46,7 +46,7 @@ shared_examples_for "general conversation permissions" do
   context "when the interlocutor is specified in the context" do
     let(:context) { { conversation:, interlocutor: } }
     let(:originator) { interlocutor }
-    let(:interlocutor) { create :user }
+    let(:interlocutor) { create(:user) }
 
     let!(:conversation) do
       Decidim::Messaging::Conversation.start!(
@@ -113,8 +113,8 @@ end
 
 shared_examples_for "restricted conversation permissions" do
   let(:context) { { conversation: } }
-  let(:user) { create :user }
-  let(:interlocutor) { create :user, organization: user.organization }
+  let(:user) { create(:user) }
+  let(:interlocutor) { create(:user, organization: user.organization) }
   let!(:conversation) do
     Decidim::Messaging::Conversation.start(
       originator: user,
@@ -128,14 +128,14 @@ shared_examples_for "restricted conversation permissions" do
   end
 
   context "when interlocutor restricts communications" do
-    let(:interlocutor) { create :user, direct_message_types: "followed-only" }
+    let(:interlocutor) { create(:user, direct_message_types: "followed-only") }
 
     context "and does not follow the user" do
       it { is_expected.to eq false }
     end
 
     context "and follows the user" do
-      let!(:follow) { create :follow, user: interlocutor, followable: user }
+      let!(:follow) { create(:follow, user: interlocutor, followable: user) }
 
       it { is_expected.to eq true }
     end

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+shared_examples "visit unpublished resource with a share token" do
+  context "when no share_token is provided" do
+    before do
+      visit_resource_page
+    end
+
+    it "does not allow visiting resource" do
+      expect(page).to have_content "You are not authorized"
+      expect(page).to have_no_current_path(resource_path, ignore_query: true)
+    end
+  end
+
+  context "when a share_token is provided" do
+    let(:share_token) { create(:share_token, token: "VALID_TOKEN", token_for: resource) }
+    let(:params) { { share_token: share_token.token } }
+
+    before do
+      uri = URI(resource_path)
+      uri.query = URI.encode_www_form(params.to_a)
+      visit uri
+    end
+
+    context "when a valid share_token is provided" do
+      it "allows visiting the resource" do
+        expect(page).to have_no_content "You are not authorized"
+        expect(current_url).to include(params[:share_token])
+        expect(page).to have_current_path(resource_path, ignore_query: true)
+
+        # repeat visit without the token in the params to check for the session
+        visit resource_path
+        expect(page).to have_no_content "You are not authorized"
+        expect(current_url).not_to include(params[:share_token])
+        expect(page).to have_current_path(resource_path, ignore_query: true)
+      end
+    end
+
+    context "when an invalid share_token is provided" do
+      let(:share_token) { create(:share_token, :expired, token: "INVALID_TOKEN_FOR_UNREGISTERED", token_for: resource) }
+
+      it "does not allow visiting resource" do
+        expect(page).to have_content "You are not authorized"
+        expect(page).to have_no_current_path(resource_path, ignore_query: true)
+      end
+    end
+
+    context "when the token requires the user to be registered" do
+      let!(:share_token) { create(:share_token, token: "VALID_TOKEN_FOR_REGISTERED", token_for: resource, registered_only: true) }
+      let!(:user) { create(:user, :confirmed, organization:) }
+
+      it "does not allow visiting resource" do
+        expect(page).to have_content "You are not authorized"
+        expect(page).to have_no_current_path(resource_path, ignore_query: true)
+      end
+
+      it "allows visiting resource to logged users" do
+        login_as user, scope: :user
+        sleep 0.5 # add a delay to ensure the user session cookie is set
+        uri = URI(resource_path)
+        uri.query = URI.encode_www_form(params.to_a)
+        visit uri
+        expect(page).to have_no_content "You are not authorized"
+        expect(page).to have_current_path(resource_path, ignore_query: true)
+      end
+    end
+  end
+end
+
+shared_examples "preview component with a share_token" do
+  let!(:component) { create(:component, manifest_name:, participatory_space:, published_at: nil) }
+  let(:resource) { component }
+  let(:resource_path) { main_component_path(component) }
+
+  def visit_resource_page
+    visit_component
+  end
+
+  it_behaves_like "visit unpublished resource with a share token"
+end
+
+shared_examples "preview participatory space with a share_token" do
+  let(:resource) { participatory_space }
+
+  before do
+    switch_to_host(organization.host)
+  end
+
+  def visit_resource_page
+    visit resource_path
+  end
+
+  it_behaves_like "visit unpublished resource with a share token"
+end

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

@@ -9,7 +9,7 @@ shared_examples "logged in user reports content" do
     context "and the user has not reported the resource yet" do
       it "reports the resource" do
         visit reportable_path
-
+        find("#dropdown-trigger-resource-#{reportable.id}").click
         expect(page).to have_css(%(button[data-dialog-open="flagModal"]))
         find(%(button[data-dialog-open="flagModal"])).click
         expect(page).to have_css(".flag-modal", visible: :visible)
@@ -44,6 +44,7 @@ shared_examples "higher user role hides" do
     it "reports the resource" do
       visit reportable_path
 
+      find("#dropdown-trigger-resource-#{reportable.id}").click
       expect(page).to have_css(%(button[data-dialog-open="flagModal"]))
       find(%(button[data-dialog-open="flagModal"])).click
       expect(page).to have_css(".flag-modal", visible: :visible)
@@ -67,6 +68,7 @@ shared_examples "higher user role does not have hide" do
     it "reports the resource" do
       visit reportable_path
 
+      find("#dropdown-trigger-resource-#{reportable.id}").click
       expect(page).to have_css(%(button[data-dialog-open="flagModal"]))
       find(%(button[data-dialog-open="flagModal"])).click
       expect(page).to have_css(".flag-modal", visible: :visible)
@@ -85,6 +87,7 @@ shared_examples "reports" do
 
       expect(page).to have_no_css("html.is-disabled")
 
+      find("#dropdown-trigger-resource-#{reportable.id}").click
       click_on "Report"
 
       expect(page).to have_css("html.is-disabled")
@@ -103,6 +106,7 @@ shared_examples "reports" do
     it "cannot report it twice" do
       visit reportable_path
 
+      find("#dropdown-trigger-resource-#{reportable.id}").click
       expect(page).to have_css(%(button[data-dialog-open="flagModal"]))
       find(%(button[data-dialog-open="flagModal"])).click
       expect(page).to have_css(".flag-modal", visible: :visible)
@@ -122,23 +126,23 @@ shared_examples "reports by user type" do
     include_examples "higher user role hides"
   end
   context "When reporting user is process admin" do
-    let!(:user) { create :process_admin, :confirmed, participatory_process: }
+    let!(:user) { create(:process_admin, :confirmed, participatory_process:) }
 
     include_examples "higher user role reports"
     include_examples "higher user role hides"
   end
   context "When reporting user is process collaborator" do
-    let!(:user) { create :process_collaborator, :confirmed, participatory_process: }
+    let!(:user) { create(:process_collaborator, :confirmed, participatory_process:) }
     include_examples "higher user role reports"
     include_examples "higher user role does not have hide"
   end
   context "When reporting user is process moderator" do
-    let!(:user) { create :process_moderator, :confirmed, participatory_process: }
+    let!(:user) { create(:process_moderator, :confirmed, participatory_process:) }
     include_examples "higher user role reports"
     include_examples "higher user role hides"
   end
   context "When reporting user is process valuator" do
-    let!(:user) { create :process_valuator, :confirmed, participatory_process: }
+    let!(:user) { create(:process_valuator, :confirmed, participatory_process:) }
     include_examples "higher user role reports"
     include_examples "higher user role does not have hide"
   end

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

@@ -6,10 +6,10 @@ shared_examples_for "resource endorsed event" do
   include_context "when a simple event"
 
   let(:event_name) { "decidim.events.resource_endorsed" }
-  let(:author) { create :user, organization: resource.organization }
+  let(:author) { create(:user, organization: resource.organization) }
 
   let(:extra) { { endorser_id: author.id } }
-  let(:endorsement) { create :endorsement, resource:, author: }
+  let(:endorsement) { create(:endorsement, resource:, author:) }
   let(:resource_path) { resource_locator(resource).path }
   let(:follower) { create(:user, organization: resource.organization) }
   let(:follow) { create(:follow, followable: author, user: follower) }

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

@@ -29,9 +29,9 @@ shared_examples_for "a resource search with scopes" do |factory_name|
   describe "scope_id filter" do
     let(:filter_params) { { with_any_scope: 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(: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:, scope: scope1 }.merge(factory_params)) }
     let!(:resource2) { create(factory_name, { component:, scope: scope2 }.merge(factory_params)) }
@@ -117,94 +117,100 @@ shared_examples_for "a resource search with scopes" do |factory_name|
   end
 end
 
-shared_examples_for "a resource search with categories" do |factory_name, category_mode = :multi|
-  let(:participatory_space) { component.participatory_space }
-  let(:filter_params) do
-    case category_mode
-    when :single
-      { with_category: category_ids }
-    else
-      { with_any_category: category_ids }
-    end
-  end
+shared_examples_for "a resource search with taxonomies" do |factory_name|
   let(:factory_params) do
     resource_params
   rescue StandardError
     {}
   end
 
-  describe "results" do
-    let(:category1) { create :category, participatory_space: }
-    let(:category2) { create :category, participatory_space: }
-    let(:child_category) { create :category, participatory_space:, parent: category2 }
-    let!(:resource) { create(factory_name, { component: }.merge(factory_params)) }
-    let!(:resource2) { create(factory_name, { component:, category: category1 }.merge(factory_params)) }
-    let!(:resource3) { create(factory_name, { component:, category: category2 }.merge(factory_params)) }
-    let!(:resource4) { create(factory_name, { component:, category: child_category }.merge(factory_params)) }
+  let(:participatory_space) { component.participatory_space }
+  let(:filter_params) do
+    { with_any_taxonomies: { "#{root_taxonomy.id}": taxonomy_ids } }
+  end
 
-    before do
-      get(
-        request_path,
-        params: { filter: filter_params },
-        headers: { "HOST" => component.organization.host }
-      )
+  let(:root_taxonomy) { create(:taxonomy, organization:) }
+  let(:taxonomy1) { create(:taxonomy, parent: root_taxonomy, organization:) }
+  let(:taxonomy2) { create(:taxonomy, parent: root_taxonomy, organization:) }
+  let(:child_taxonomy) { create(:taxonomy, organization:, parent: taxonomy2) }
+  let!(:resource) { create(factory_name, { component: }.merge(factory_params)) }
+  let!(:resource2) { create(factory_name, { component:, taxonomies: [taxonomy1] }.merge(factory_params)) }
+  let!(:resource3) { create(factory_name, { component:, taxonomies: [taxonomy2] }.merge(factory_params)) }
+  let!(:resource4) { create(factory_name, { component:, taxonomies: [child_taxonomy] }.merge(factory_params)) }
+
+  before do
+    get(
+      request_path,
+      params: { filter: filter_params },
+      headers: { "HOST" => component.organization.host }
+    )
+  end
+
+  context "when no taxonomy filter is present" do
+    let(:filter_params) do
+      { with_any_taxonomies: [] }
     end
 
-    context "when no category filter is present" do
-      let(:category_ids) { nil }
+    it "includes all resources" do
+      expect(subject).to have_escaped_html(translated(resource.try(:title) || resource.try(:name)))
+      expect(subject).to have_escaped_html(translated(resource2.try(:title) || resource2.try(:name)))
+      expect(subject).to have_escaped_html(translated(resource3.try(:title) || resource3.try(:name)))
+      expect(subject).to have_escaped_html(translated(resource4.try(:title) || resource4.try(:name)))
+    end
+  end
 
-      it "includes all resources" do
-        expect(subject).to have_escaped_html(translated(resource.try(:title) || resource.try(:name)))
-        expect(subject).to have_escaped_html(translated(resource2.try(:title) || resource2.try(:name)))
-        expect(subject).to have_escaped_html(translated(resource3.try(:title) || resource3.try(:name)))
-        expect(subject).to have_escaped_html(translated(resource4.try(:title) || resource4.try(:name)))
-      end
+  context "when no ids are specified" do
+    let(:taxonomy_ids) { [] }
+
+    it "includes all resources" do
+      expect(subject).to have_escaped_html(translated(resource.try(:title) || resource.try(:name)))
+      expect(subject).to have_escaped_html(translated(resource2.try(:title) || resource2.try(:name)))
+      expect(subject).to have_escaped_html(translated(resource3.try(:title) || resource3.try(:name)))
+      expect(subject).to have_escaped_html(translated(resource4.try(:title) || resource4.try(:name)))
     end
+  end
 
-    context "when a category is selected" do
-      let(:category_ids) { [category2.id] }
+  context "when `all` is being sent" do
+    let(:taxonomy_ids) { ["all"] }
 
-      it "includes only resources for that category and its children" do
-        expect(subject).not_to have_escaped_html(translated(resource.try(:title) || resource.try(:name)))
-        expect(subject).not_to have_escaped_html(translated(resource2.try(:title) || resource2.try(:name)))
-        expect(subject).to have_escaped_html(translated(resource3.try(:title) || resource3.try(:name)))
-        expect(subject).to have_escaped_html(translated(resource4.try(:title) || resource4.try(:name)))
-      end
+    it "includes all resources with the root taxonomy" do
+      expect(subject).not_to have_escaped_html(translated(resource.try(:title) || resource.try(:name)))
+      expect(subject).to have_escaped_html(translated(resource2.try(:title) || resource2.try(:name)))
+      expect(subject).to have_escaped_html(translated(resource3.try(:title) || resource3.try(:name)))
+      expect(subject).to have_escaped_html(translated(resource4.try(:title) || resource4.try(:name)))
     end
+  end
 
-    context "when a subcategory is selected" do
-      let(:category_ids) { [child_category.id] }
+  context "when a taxonomy is selected" do
+    let(:taxonomy_ids) { [taxonomy2.id] }
 
-      it "includes only resources for that category" do
-        expect(subject).not_to have_escaped_html(translated(resource.try(:title) || resource.try(:name)))
-        expect(subject).not_to have_escaped_html(translated(resource2.try(:title) || resource2.try(:name)))
-        expect(subject).not_to have_escaped_html(translated(resource3.try(:title) || resource3.try(:name)))
-        expect(subject).to have_escaped_html(translated(resource4.try(:title) || resource4.try(:name)))
-      end
+    it "includes only resources for that taxonomy and its children" do
+      expect(subject).not_to have_escaped_html(translated(resource.try(:title) || resource.try(:name)))
+      expect(subject).not_to have_escaped_html(translated(resource2.try(:title) || resource2.try(:name)))
+      expect(subject).to have_escaped_html(translated(resource3.try(:title) || resource3.try(:name)))
+      expect(subject).to have_escaped_html(translated(resource4.try(:title) || resource4.try(:name)))
     end
+  end
 
-    context "when `without` is being sent" do
-      let(:category_ids) { ["without"] }
+  context "when multiple taxonomies are selected" do
+    let(:taxonomy_ids) { [taxonomy1.id, taxonomy2.id] }
 
-      it "returns resources without a category" do
-        expect(subject).to have_escaped_html(translated(resource.try(:title) || resource.try(:name)))
-        expect(subject).not_to have_escaped_html(translated(resource2.try(:title) || resource2.try(:name)))
-        expect(subject).not_to have_escaped_html(translated(resource3.try(:title) || resource3.try(:name)))
-        expect(subject).not_to have_escaped_html(translated(resource4.try(:title) || resource4.try(:name)))
-      end
+    it "includes only resources for those taxonomies" do
+      expect(subject).not_to have_escaped_html(translated(resource.try(:title) || resource.try(:name)))
+      expect(subject).to have_escaped_html(translated(resource2.try(:title) || resource2.try(:name)))
+      expect(subject).to have_escaped_html(translated(resource3.try(:title) || resource3.try(:name)))
+      expect(subject).to have_escaped_html(translated(resource4.try(:title) || resource4.try(:name)))
     end
+  end
 
-    if category_mode == :multi
-      context "when `without` and some category id is being sent" do
-        let(:category_ids) { ["without", category1.id] }
+  context "when a sub_taxonomy is selected" do
+    let(:taxonomy_ids) { [child_taxonomy.id] }
 
-        it "returns resources without a category and with the selected category" do
-          expect(subject).to have_escaped_html(translated(resource.try(:title) || resource.try(:name)))
-          expect(subject).to have_escaped_html(translated(resource2.try(:title) || resource2.try(:name)))
-          expect(subject).not_to have_escaped_html(translated(resource3.try(:title) || resource3.try(:name)))
-          expect(subject).not_to have_escaped_html(translated(resource4.try(:title) || resource4.try(:name)))
-        end
-      end
+    it "includes only resources for that taxonomy" do
+      expect(subject).not_to have_escaped_html(translated(resource.try(:title) || resource.try(:name)))
+      expect(subject).not_to have_escaped_html(translated(resource2.try(:title) || resource2.try(:name)))
+      expect(subject).not_to have_escaped_html(translated(resource3.try(:title) || resource3.try(:name)))
+      expect(subject).to have_escaped_html(translated(resource4.try(:title) || resource4.try(:name)))
     end
   end
 end

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

@@ -3,7 +3,7 @@
 RSpec.shared_context "when a resource is ready for global search" do
   let!(:organization) { create(:organization) }
   let!(:author) { create(:user, :admin, organization:) }
-  let!(:scope1) { create :scope, organization: }
+  let!(:scope1) { create(:scope, organization:) }
 
   let(:test_locales) { [:ca, :en, :es] }
   let(:description1) do

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

@@ -105,25 +105,6 @@ shared_examples_for "a simple event" do |skip_space_checks|
     end
   end
 
-  describe "resource_path" do
-    it "is generated correctly" do
-      expect(subject.resource_path).to be_kind_of(String)
-    end
-  end
-
-  describe "resource_url" do
-    it "is generated correctly" do
-      expect(subject.resource_url).to be_kind_of(String)
-      expect(subject.resource_url).to start_with("http")
-    end
-  end
-
-  describe "resource_title" do
-    it "responds to the method" do
-      expect(subject).to respond_to(:resource_title)
-    end
-  end
-
   unless skip_space_checks
     describe "participatory_space_url" do
       it "is generated correctly" do
@@ -197,3 +178,36 @@ shared_examples_for "a simple event notification" do
     end
   end
 end
+
+shared_examples_for "a notification event only" do
+  describe "types" do
+    subject { described_class }
+
+    it "supports notifications" do
+      expect(subject.types).to include :notification
+    end
+
+    it "does not support emails" do
+      expect(subject.types).not_to include :email
+    end
+  end
+
+  describe "resource_path" do
+    it "is generated correctly" do
+      expect(subject.resource_path).to be_kind_of(String)
+    end
+  end
+
+  describe "resource_url" do
+    it "is generated correctly" do
+      expect(subject.resource_url).to be_kind_of(String)
+      expect(subject.resource_url).to start_with("http")
+    end
+  end
+
+  describe "resource_title" do
+    it "responds to the method" do
+      expect(subject).to respond_to(:resource_title)
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+def visit_resource
+  return visit resource if resource.is_a?(String)
+
+  return visit decidim.root_path if resource.is_a?(Decidim::Organization)
+
+  visit resource_locator(resource).path
+end
+
+shared_examples "a empty social share meta tag" do
+  it "has no meta tag" do
+    visit_resource
+    expect(find('meta[property="og:image"]', visible: false)[:content]).to be_blank
+  end
+end
+
+shared_examples "a social share meta tag" do |image|
+  it "has meta tag for #{image}" do
+    visit_resource
+    expect(find('meta[property="og:image"]', visible: false)[:content]).to end_with(image)
+  end
+end