decidim-core 0.26.2 → 0.27.0.rc1

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

@@ -121,6 +121,209 @@ shared_examples "comments" do
         end
       end
 
+      it "updates the numbers of characters left correctly" do
+        within ".add-comment form" do
+          fill_in "add-comment-#{commentable.commentable_type.demodulize}-#{commentable.id}", with: "This is a new comment."
+          expect(page).to have_content("1978 characters left")
+        end
+      end
+
+      context "when working with the screen reader character counter" do
+        let(:field_id) { "add-comment-#{commentable.commentable_type.demodulize}-#{commentable.id}" }
+        let(:field) { page.find("##{field_id}") }
+
+        before do
+          # Make sure the focus stays in the comment form during these tests
+          # because only then the screen reader
+          page.execute_script("document.getElementById('#{field_id}').focus()")
+        end
+
+        it "updates the numbers of characters left correctly for screen reader" do
+          within ".add-comment form" do
+            fill_in field_id, with: "This is a new comment."
+
+            # The screen reader character counter should update only when the user
+            # reaches 10% interval of the total characters available not to
+            # announce the remaining characters after every keystroke.
+            field.native.send_keys " Sending some new text."
+            within ".remaining-character-count" do
+              expect(page).to have_content("1955 characters left") # Normal
+            end
+            within ".remaining-character-count-sr" do
+              expect(page).to have_content("2000 characters left") # Screen reader
+            end
+
+            # After 10% of the total characters is reached, it should be updated
+            # to the screen reader section to announce it.
+            field.native.send_keys "a" * 155
+            within ".remaining-character-count" do
+              expect(page).to have_content("1800 characters left") # Normal
+            end
+            within ".remaining-character-count-sr" do
+              expect(page).to have_content("1800 characters left") # Screen reader
+            end
+
+            # After continuing typing after the announcement, the screen reader
+            # characters should stay the same (announced on the next 10%
+            # interval).
+            field.native.send_keys "b"
+            within ".remaining-character-count" do
+              expect(page).to have_content("1799 characters left") # Normal
+            end
+            within ".remaining-character-count-sr" do
+              expect(page).to have_content("1800 characters left") # Screen reader
+            end
+
+            # When text is removed at the interval, the screen reader should
+            # update back to the previous interval.
+            field.native.send_keys [:backspace, :backspace, :backspace, :backspace]
+            within ".remaining-character-count" do
+              expect(page).to have_content("1803 characters left") # Normal
+            end
+            within ".remaining-character-count-sr" do
+              expect(page).to have_content("1800 characters left") # Screen reader
+            end
+
+            # After continuing typing after the removal of characters, we should
+            # stay in the "latest announcement" not to confuse the user as
+            # - "1800 characters left" (actual 1803)
+            # - Type in one character
+            # - "1900 characters left" (actual 1802)
+            field.native.send_keys "b"
+            within ".remaining-character-count" do
+              expect(page).to have_content("1802 characters left") # Normal
+            end
+            within ".remaining-character-count-sr" do
+              expect(page).to have_content("1800 characters left") # Screen reader
+            end
+
+            # After the input is blurred, the screen reader character counter
+            # should show the actual amount of characters left.
+            page.execute_script("document.getElementById('#{field_id}').blur()")
+            within ".remaining-character-count" do
+              expect(page).to have_content("1802 characters left") # Normal
+            end
+            within ".remaining-character-count-sr" do
+              expect(page).to have_content("1802 characters left") # Screen reader
+            end
+          end
+        end
+
+        context "when reaching the announce after every threshold" do
+          it "updates the numbers of characters left correctly for screen reader" do
+            within ".add-comment form" do
+              # Test that when reaching the "announce after every" threshold, the
+              # characters are announced after every keystroke.
+              fill_in field_id, with: "a" * 1989
+              within ".remaining-character-count" do
+                expect(page).to have_content("11 characters left") # Normal
+              end
+              within ".remaining-character-count-sr" do
+                expect(page).to have_content("200 characters left") # Screen reader
+              end
+
+              (2..10).reverse_each do |remaining|
+                field.native.send_keys "b"
+                within ".remaining-character-count-sr" do
+                  expect(page).to have_content("#{remaining} characters left")
+                end
+              end
+
+              field.native.send_keys "b"
+              within ".remaining-character-count-sr" do
+                expect(page).to have_content("1 character left")
+              end
+
+              field.native.send_keys "c"
+              within ".remaining-character-count-sr" do
+                expect(page).to have_content("0 characters left")
+              end
+
+              # Test that the SR counter will stick at the last announced
+              # threshold if the next threshold is not hit and text is removed.
+              # This prevents weird announcements such as:
+              # - 0 characters left
+              # - Remove 10 characters
+              # - 10 characters left
+              # - Remove 1 character
+              # - 200 characters left
+              page.execute_script("document.getElementById('#{field_id}').setSelectionRange(1850, 2000)")
+              field.native.send_keys [:backspace]
+              within ".remaining-character-count" do
+                expect(page).to have_content("150 characters left") # Normal
+              end
+              within ".remaining-character-count-sr" do
+                expect(page).to have_content("0 characters left") # Screen reader
+              end
+
+              field.native.send_keys "d"
+              within ".remaining-character-count-sr" do
+                expect(page).to have_content("0 characters left")
+              end
+            end
+          end
+        end
+
+        context "when deleting text the announce after every threshold" do
+          it "updates the numbers of characters left correctly for screen reader" do
+            within ".add-comment form" do
+              fill_in field_id, with: "a" * 2000
+              within ".remaining-character-count" do
+                expect(page).to have_content("0 characters left") # Normal
+              end
+              within ".remaining-character-count-sr" do
+                expect(page).to have_content("0 characters left") # Screen reader
+              end
+
+              # Test that the SR counter updates correctly after hitting the
+              # next threshold.
+              page.execute_script("document.getElementById('#{field_id}').setSelectionRange(1800, 2000)")
+              field.native.send_keys [:backspace]
+              within ".remaining-character-count" do
+                expect(page).to have_content("200 characters left") # Normal
+              end
+              within ".remaining-character-count-sr" do
+                expect(page).to have_content("200 characters left") # Screen reader
+              end
+
+              # The SR counter should stay at the correct boundary.
+              field.native.send_keys [:backspace, :backspace]
+              within ".remaining-character-count" do
+                expect(page).to have_content("202 characters left") # Normal
+              end
+              within ".remaining-character-count-sr" do
+                expect(page).to have_content("200 characters left") # Screen reader
+              end
+
+              # It stays at the correct boundary when starting to type again.
+              field.native.send_keys "b"
+              within ".remaining-character-count" do
+                expect(page).to have_content("201 characters left") # Normal
+              end
+              within ".remaining-character-count-sr" do
+                expect(page).to have_content("200 characters left") # Screen reader
+              end
+
+              field.native.send_keys "c"
+              within ".remaining-character-count" do
+                expect(page).to have_content("200 characters left") # Normal
+              end
+              within ".remaining-character-count-sr" do
+                expect(page).to have_content("200 characters left") # Screen reader
+              end
+
+              field.native.send_keys "d"
+              within ".remaining-character-count" do
+                expect(page).to have_content("199 characters left") # Normal
+              end
+              within ".remaining-character-count-sr" do
+                expect(page).to have_content("200 characters left") # Screen reader
+              end
+            end
+          end
+        end
+      end
+
       context "when component is present and has a default comments length params" do
         it "displays the numbers of characters left" do
           if component.present?

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

@@ -9,7 +9,7 @@ shared_examples "localised email" do
     let(:locale) { "ca" }
 
     it "uses the user's locale" do
-      expect(mail.subject).to eq(subject)
+      expect(mail.subject).to eq(mail_subject)
       expect(mail.body.encoded).to match(body)
     end
   end

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

@@ -15,7 +15,7 @@ shared_examples "email with logo" do
 
     it "includes organization logo with full link" do
       expect(mail.body).to include("alt=\"#{organization.name}\"")
-      expect(mail.body).to match(%r{https{0,1}://#{organization.host}#{logo_path}})
+      expect(mail.body).to match(%r{https{0,1}://#{organization.host}:#{Capybara.server_port}#{logo_path}})
     end
   end
 end

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

@@ -24,7 +24,7 @@ shared_context "with frontend map builder" do
     end
   end
   let(:organization) { create(:organization) }
-  let(:template) { template_class.new(ActionView::LookupContext.new(nil)) }
+  let(:template) { template_class.new(ActionView::LookupContext.new(ActionController::Base.view_paths), {}, []) }
   let(:options) { {} }
   let(:js_options) { options.transform_keys { |k| k.to_s.camelize(:lower) }.to_h }
 
@@ -103,6 +103,7 @@ shared_context "with frontend map elements" do
     final_html = html_document
     Rails.application.routes.draw do
       get "test_dynamic_map", to: ->(_) { [200, {}, [final_html]] }
+      get "offline", to: ->(_) { [200, {}, [""]] }
     end
 
     visit "/test_dynamic_map"
@@ -180,7 +181,6 @@ shared_examples "a record with front-end geocoding address field" do |geocoded_m
   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
 

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

@@ -15,9 +15,7 @@ shared_examples_for "preview component with share_token" do
 
       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
 
@@ -34,9 +32,7 @@ shared_examples_for "preview component with share_token" do
       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
 
@@ -45,9 +41,7 @@ shared_examples_for "preview component with share_token" do
 
         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

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

@@ -3,19 +3,18 @@
 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")
+  describe "component_id" do
+    before do
+      get(
+        request_path,
+        headers: { "HOST" => component.organization.host }
+      )
     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)
+      expect(subject).not_to have_escaped_html(translated(external_resource.try(:title) || external_resource.try(:name)))
     end
   end
 end
@@ -28,7 +27,7 @@ shared_examples_for "a resource search with scopes" do |factory_name|
   end
 
   describe "scope_id filter" do
-    let(:params) { default_params.merge(scope_id: scope_ids) }
+    let(:filter_params) { { with_any_scope: scope_ids } }
 
     let(:scope1) { create :scope, organization: component.organization }
     let(:scope2) { create :scope, organization: component.organization }
@@ -38,11 +37,21 @@ shared_examples_for "a resource search with scopes" do |factory_name|
     let!(:resource2) { create(factory_name, { component: component, scope: scope2 }.merge(factory_params)) }
     let!(:resource3) { create(factory_name, { component: component, scope: subscope1 }.merge(factory_params)) }
 
+    before do
+      get(
+        request_path,
+        params: { filter: filter_params },
+        headers: { "HOST" => component.organization.host }
+      )
+    end
+
     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]
+        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).to have_escaped_html(translated(resource3.try(:title) || resource3.try(:name)))
       end
     end
 
@@ -50,7 +59,9 @@ shared_examples_for "a resource search with scopes" do |factory_name|
       let(:scope_ids) { [subscope1.id] }
 
       it "filters resources by scope" do
-        expect(subject).to eq [resource3]
+        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)))
       end
     end
 
@@ -58,7 +69,9 @@ shared_examples_for "a resource search with scopes" do |factory_name|
       let(:scope_ids) { [scope2.id, scope1.id] }
 
       it "filters resources by scope" do
-        expect(subject).to match_array [resource, resource2, resource3]
+        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)))
       end
     end
 
@@ -66,8 +79,19 @@ shared_examples_for "a resource search with scopes" do |factory_name|
       let!(:resource_without_scope) { create(factory_name, { component: component, scope: nil }.merge(factory_params)) }
       let(:scope_ids) { ["global"] }
 
+      before do
+        get(
+          request_path,
+          params: { filter: filter_params },
+          headers: { "HOST" => component.organization.host }
+        )
+      end
+
       it "returns resources without a scope" do
-        expect(subject).to match_array [resource_without_scope]
+        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(resource_without_scope.try(:title) || resource_without_scope.try(:name)))
       end
     end
 
@@ -75,16 +99,34 @@ shared_examples_for "a resource search with scopes" do |factory_name|
       let!(:resource_without_scope) { create(factory_name, { component: component, scope: nil }.merge(factory_params)) }
       let(:scope_ids) { ["global", scope2.id, scope1.id] }
 
+      before do
+        get(
+          request_path,
+          params: { filter: filter_params },
+          headers: { "HOST" => component.organization.host }
+        )
+      end
+
       it "returns resources without a scope and with selected scopes" do
-        expect(subject).to match_array [resource_without_scope, resource, resource2, resource3]
+        expect(subject).to have_escaped_html(translated(resource_without_scope.try(:title) || resource_without_scope.try(:name)))
+        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)))
       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) }
+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
   let(:factory_params) do
     resource_params
   rescue StandardError
@@ -92,19 +134,30 @@ shared_examples_for "a resource search with categories" do |factory_name|
   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(:category1) { create :category, participatory_space: participatory_space }
+    let(:category2) { create :category, participatory_space: participatory_space }
+    let(:child_category) { create :category, participatory_space: participatory_space, 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)) }
 
+    before do
+      get(
+        request_path,
+        params: { filter: filter_params },
+        headers: { "HOST" => component.organization.host }
+      )
+    end
+
     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]
+        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
 
@@ -112,7 +165,10 @@ shared_examples_for "a resource search with categories" do |factory_name|
       let(:category_ids) { [category2.id] }
 
       it "includes only resources for that category and its children" do
-        expect(subject).to match_array [resource3, resource4]
+        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
 
@@ -120,7 +176,10 @@ shared_examples_for "a resource search with categories" do |factory_name|
       let(:category_ids) { [child_category.id] }
 
       it "includes only resources for that category" do
-        expect(subject).to eq [resource4]
+        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
 
@@ -128,15 +187,23 @@ shared_examples_for "a resource search with categories" do |factory_name|
       let(:category_ids) { ["without"] }
 
       it "returns resources without a category" do
-        expect(subject).to eq [resource]
+        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
     end
 
-    context "when `without` and some category id is being sent" do
-      let(:category_ids) { ["without", category1.id] }
+    if category_mode == :multi
+      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]
+        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
     end
   end
@@ -148,32 +215,42 @@ shared_examples_for "a resource search with origin" do |factory_name|
   rescue StandardError
     {}
   end
-  let(:params) { default_params.merge(origin: origins) }
+  let(:filter_params) { { with_any_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)) }
+    let!(:participant_resource) { create(factory_name, :participant_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
 
+    before do
+      get(
+        request_path,
+        params: { filter: filter_params },
+        headers: { "HOST" => component.organization.host }
+      )
+    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)
+        expect(subject).to have_escaped_html(translated(official_resource.try(:title) || official_resource.try(:name)))
+        expect(subject).not_to have_escaped_html(translated(participant_resource.try(:title) || participant_resource.try(:name)))
+        expect(subject).not_to have_escaped_html(translated(user_group_resource.try(:title) || user_group_resource.try(:name)))
       end
     end
 
-    context "when filtering citizen resources" do
-      let(:origins) { %w(citizens) }
+    context "when filtering participants resources" do
+      let(:origins) { %w(participants) }
 
       it "returns only citizen resources" do
-        expect(subject.size).to eq(1)
-        expect(subject).to include(citizen_resource)
+        expect(subject).not_to have_escaped_html(translated(official_resource.try(:title) || official_resource.try(:name)))
+        expect(subject).to have_escaped_html(translated(participant_resource.try(:title) || participant_resource.try(:name)))
+        expect(subject).not_to have_escaped_html(translated(user_group_resource.try(:title) || user_group_resource.try(:name)))
       end
     end
 
@@ -181,8 +258,9 @@ shared_examples_for "a resource search with origin" do |factory_name|
       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)
+        expect(subject).not_to have_escaped_html(translated(official_resource.try(:title) || official_resource.try(:name)))
+        expect(subject).not_to have_escaped_html(translated(participant_resource.try(:title) || participant_resource.try(:name)))
+        expect(subject).to have_escaped_html(translated(user_group_resource.try(:title) || user_group_resource.try(:name)))
       end
     end
 
@@ -191,8 +269,10 @@ shared_examples_for "a resource search with origin" do |factory_name|
         let(:origins) { %w(meeting) }
 
         it "returns only meeting resources" do
-          expect(subject.size).to eq(1)
-          expect(subject).to include(meeting_resource)
+          expect(subject).not_to have_escaped_html(translated(official_resource.try(:title) || official_resource.try(:name)))
+          expect(subject).not_to have_escaped_html(translated(participant_resource.try(:title) || participant_resource.try(:name)))
+          expect(subject).not_to have_escaped_html(translated(user_group_resource.try(:title) || user_group_resource.try(:name)))
+          expect(subject).to have_escaped_html(translated(meeting_resource.try(:title) || meeting_resource.try(:name)))
         end
       end
     end

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

@@ -8,10 +8,4 @@ shared_examples_for "resourceable" do
       expect(subject.resource_title).to be_present
     end
   end
-
-  describe "resource_description" do
-    it "is defined" do
-      expect(subject.resource_title).to be_present
-    end
-  end
 end

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

@@ -83,7 +83,7 @@ shared_examples "global search of participatory spaces" do
   describe "Search" do
     # trick to force creating participatory_space2 declared in users of this shared_examples
     let!(:spaces) { [participatory_space, participatory_space2] }
-    let(:description_2) do
+    let(:description2) do
       msg = "Chewie, I'll be waiting for your signal. Take care, you two. May the Force be with you. Ow!"
       { ca: "CA:#{msg}", en: "EN:#{msg}", es: "ES:#{msg}" }
     end

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

@@ -6,7 +6,7 @@ RSpec.shared_context "when a resource is ready for global search" do
   let!(:scope1) { create :scope, organization: organization }
 
   let(:test_locales) { [:ca, :en, :es] }
-  let(:description_1) do
+  let(:description1) do
     Decidim::Faker::Localized.prefixed("Poemes als terrats de l'Empordà, Ow!", test_locales)
   end
 end

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

@@ -6,11 +6,11 @@ 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) {}
+  let!(:resource) { nil }
   # the name of the resource to be clicked from the component view
-  let(:resource_name) {}
+  let(:resource_name) { nil }
   # Should be overriden and create 3 extra resources in the current component
-  let!(:resources) {}
+  let!(:resources) { nil }
 end
 
 shared_examples "Endorse resource system specs" do

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

@@ -56,7 +56,7 @@ shared_examples_for "a translated event" do
       end
 
       context "when translation is not available" do
-        let(:body) { { "en": en_body } }
+        let(:body) { { en: en_body } }
 
         it "does perform translation" do
           expect(subject.perform_translation?).to eq(translatable)
@@ -104,7 +104,7 @@ shared_examples_for "a translated event" do
       end
 
       context "when translation is not available" do
-        let(:body) { { "en": en_body } }
+        let(:body) { { en: en_body } }
 
         it "does perform translation" do
           expect(subject.perform_translation?).to eq(translatable)

data/lib/decidim/core/version.rb

@@ -4,7 +4,7 @@ module Decidim
   # This holds the decidim-core version.
   module Core
     def self.version
-      "0.26.2"
+      "0.27.0.rc1"
     end
   end
 end