decidim-core 0.20.1 → 0.21.0

data/lib/decidim/core/api.rb

@@ -6,9 +6,16 @@ module Decidim
     autoload :ComponentInterface, "decidim/api/component_interface"
     autoload :AuthorInterface, "decidim/api/author_interface"
     autoload :AuthorableInterface, "decidim/api/authorable_interface"
+    autoload :CoauthorableInterface, "decidim/api/coauthorable_interface"
     autoload :CategorizableInterface, "decidim/api/categorizable_interface"
     autoload :ScopableInterface, "decidim/api/scopable_interface"
     autoload :AttachableInterface, "decidim/api/attachable_interface"
     autoload :HashtagInterface, "decidim/api/hashtag_interface"
+    autoload :ParticipatorySpaceResourceableInterface, "decidim/api/participatory_space_resourceable_interface"
+    autoload :FingerprintInterface, "decidim/api/fingerprint_interface"
+    autoload :AmendableInterface, "decidim/api/amendable_interface"
+    autoload :AmendableEntityInterface, "decidim/api/amendable_entity_interface"
+    autoload :TraceableInterface, "decidim/api/traceable_interface"
+    autoload :TimestampsInterface, "decidim/api/timestamps_interface"
   end
 end

data/lib/decidim/core/test.rb

@@ -46,3 +46,4 @@ require "decidim/core/test/shared_examples/uncommentable_component_examples"
 require "decidim/core/test/shared_examples/searchable_resources_shared_context"
 require "decidim/core/test/shared_examples/searchable_participatory_space_examples"
 require "decidim/core/test/shared_examples/has_private_users"
+require "decidim/core/test/shared_examples/rich_text_editor_examples"

data/lib/decidim/core/test/factories.rb

@@ -69,6 +69,7 @@ FactoryBot.define do
   factory :organization, class: "Decidim::Organization" do
     name { Faker::Company.unique.name }
     reference_prefix { Faker::Name.suffix }
+    time_zone { "UTC" }
     twitter_handler { Faker::Hipster.word }
     facebook_handler { Faker::Hipster.word }
     instagram_handler { Faker::Hipster.word }
@@ -88,6 +89,7 @@ FactoryBot.define do
     badges_enabled { true }
     user_groups_enabled { true }
     send_welcome_notification { true }
+    admin_terms_of_use_body { Decidim::Faker::Localized.wrapped("<p>", "</p>") { generate_localized_title } }
     force_users_to_authenticate_before_access_organization { false }
     smtp_settings do
       {
@@ -130,12 +132,18 @@ FactoryBot.define do
       deleted_at { Time.current }
     end
 
+    trait :admin_terms_accepted do
+      admin_terms_accepted_at { Time.current }
+    end
+
     trait :admin do
       admin { true }
+      admin_terms_accepted
     end
 
     trait :user_manager do
       roles { ["user_manager"] }
+      admin_terms_accepted
     end
 
     trait :managed do
@@ -325,6 +333,14 @@ FactoryBot.define do
       }
     end
 
+    trait :with_one_step do
+      step_settings do
+        {
+          1 => { dummy_step_setting: true }
+        }
+      end
+    end
+
     trait :unpublished do
       published_at { nil }
     end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+shared_examples_for "amendable interface" do
+  describe "amendments" do
+    let(:query) { "{ amendments { id } }" }
+
+    it "includes the amendments id" do
+      amendments_ids = response["amendments"].map { |amendment| amendment["id"].to_i }
+      expect(amendments_ids).to include(*model.amendments.map(&:id))
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+shared_examples_for "amendable proposals interface" do
+  describe "amendments" do
+    let(:query) do
+      "{ amendments {
+      state
+      amendable { ...on Proposal { title } }
+      amendableType
+      emendation { ...on Proposal { title } }
+      emendationType
+      amender { name }
+    } }"
+    end
+
+    it "includes the amendments states" do
+      amendments_states = response["amendments"].map { |amendment| amendment["state"] }
+      expect(amendments_states).to include(*model.amendments.map(&:state))
+    end
+
+    it "amendable types matches Proposals Type" do
+      response["amendments"].each do |amendment|
+        expect(amendment["amendableType"]).to eq("Decidim::Proposals::Proposal")
+      end
+    end
+
+    it "emendation types matches Proposals Type" do
+      response["amendments"].each do |amendment|
+        expect(amendment["emendationType"]).to eq("Decidim::Proposals::Proposal")
+      end
+    end
+
+    it "returns amendable as parent proposal" do
+      amendment_amendables = response["amendments"].map { |amendment| amendment["amendable"] }
+      expect(amendment_amendables).to include(*model.amendments.map(&:amendable).map { |p| { "title" => p.title } })
+    end
+
+    it "returns emendations received" do
+      amendment_emendations = response["amendments"].map { |amendment| amendment["emendation"] }
+      expect(amendment_emendations).to include(*model.amendments.map(&:emendation).map { |p| { "title" => p.title } })
+    end
+
+    it "returns amender as emendation author" do
+      amendment_amenders = response["amendments"].map { |amendment| amendment["amender"] }
+      expect(amendment_amenders).to include(*model.amendments.map(&:amender).map { |p| { "name" => p.name } })
+    end
+  end
+end

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

@@ -5,6 +5,9 @@ require "spec_helper"
 shared_examples_for "authorable interface" do
   describe "author" do
     describe "when author is not present" do
+      let(:author) { nil }
+      let(:query) { "{ author { name } }" }
+
       before do
         model.update(author: author)
       end

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

@@ -27,5 +27,65 @@ shared_examples_for "coauthorable interface" do
         expect(response["author"]["name"]).to eq(user_group.name)
       end
     end
+
+    describe "with a several coauthors" do
+      let(:query) { "{ author { name } authors { name } authorsCount }" }
+      let(:coauthor) { create(:user, :confirmed, organization: model.participatory_space.organization) }
+
+      before do
+        model.add_coauthor coauthor
+        model.save!
+      end
+
+      context "when both are users" do
+        it "returns 2 total co-authors" do
+          expect(response["authorsCount"]).to eq(2)
+        end
+
+        it "returns an array of authors" do
+          expect(response["authors"].count).to eq(2)
+          expect(response["authors"]).to include("name" => author.name)
+          expect(response["authors"]).to include("name" => coauthor.name)
+        end
+
+        it "returns a main author" do
+          expect(response["author"]["name"]).to eq(author.name)
+        end
+      end
+
+      context "when author is the organization" do
+        let(:model) { create(:proposal, :official, component: component) }
+
+        it "returns 2 total co-authors" do
+          expect(response["authorsCount"]).to eq(2)
+        end
+
+        it "returns 1 author in authors array" do
+          expect(response["authors"].count).to eq(1)
+          expect(response["authors"]).to include("name" => coauthor.name)
+        end
+
+        it "do not return a main author" do
+          expect(response["author"]).to eq(nil)
+        end
+      end
+
+      context "when author is a meeting" do
+        let(:model) { create(:proposal, :official_meeting, component: component) }
+
+        it "returns 2 total co-authors" do
+          expect(response["authorsCount"]).to eq(2)
+        end
+
+        it "returns 1 author in authors array" do
+          expect(response["authors"].count).to eq(1)
+          expect(response["authors"]).to include("name" => coauthor.name)
+        end
+
+        it "do not return a main author" do
+          expect(response["author"]).to eq(nil)
+        end
+      end
+    end
   end
 end

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

@@ -9,7 +9,7 @@ shared_examples "comments" do
     switch_to_host(organization.host)
   end
 
-  it "shows the list of comments for the resorce" do
+  it "shows the list of comments for the resource" do
     visit resource_path
 
     expect(page).to have_selector("#comments")
@@ -64,7 +64,7 @@ shared_examples "comments" do
       end
 
       it "shows comment to the user" do
-        expect(page).to have_comment_from(user, "This is a new comment")
+        expect(page).to have_comment_from(user, "This is a new comment", wait: 20)
       end
     end
 
@@ -86,7 +86,7 @@ shared_examples "comments" do
           click_button "Send"
         end
 
-        expect(page).to have_comment_from(user_group, "This is a new comment")
+        expect(page).to have_comment_from(user_group, "This is a new comment", wait: 20)
       end
     end
 
@@ -110,7 +110,7 @@ shared_examples "comments" do
           click_button "Send"
         end
 
-        expect(page).to have_selector(".comment-thread .comment--nested")
+        expect(page).to have_selector(".comment-thread .comment--nested", wait: 20)
         expect(page).to have_selector(".comment__additionalreply")
         expect(page).to have_reply_to(comment, "This is a reply")
       end
@@ -150,7 +150,7 @@ shared_examples "comments" do
             end
 
             within "#comments" do
-              expect(page).to have_selector "span.success.label", text: "In favor"
+              expect(page).to have_selector "span.success.label", text: "In favor", wait: 20
             end
           else
             expect(page).to have_no_selector(".opinion-toggle--ok")
@@ -247,7 +247,7 @@ shared_examples "comments" do
         let(:content) { "A valid user mention: @#{mentioned_user.nickname}." }
 
         it "replaces the mention with a link to the user's profile" do
-          expect(page).to have_comment_from(user, "A valid user mention: @#{mentioned_user.nickname}")
+          expect(page).to have_comment_from(user, "A valid user mention: @#{mentioned_user.nickname}", wait: 20)
           expect(page).to have_link "@#{mentioned_user.nickname}", href: "/profiles/#{mentioned_user.nickname}"
         end
       end
@@ -257,7 +257,7 @@ shared_examples "comments" do
         let(:content) { "This text mentions a user outside current organization: @#{mentioned_user.nickname}" }
 
         it "ignores the mention" do
-          expect(page).to have_comment_from(user, "This text mentions a user outside current organization: @#{mentioned_user.nickname}")
+          expect(page).to have_comment_from(user, "This text mentions a user outside current organization: @#{mentioned_user.nickname}", wait: 20)
           expect(page).not_to have_link "@#{mentioned_user.nickname}"
         end
       end
@@ -266,7 +266,7 @@ shared_examples "comments" do
         let(:content) { "This text mentions a @nonexistent user" }
 
         it "ignores the mention" do
-          expect(page).to have_comment_from(user, "This text mentions a @nonexistent user")
+          expect(page).to have_comment_from(user, "This text mentions a @nonexistent user", wait: 20)
           expect(page).not_to have_link "@nonexistent"
         end
       end

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

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

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

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

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

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

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

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