decidim-api 0.30.8 → 0.31.0.rc1

data/lib/decidim/api/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/api/test/shared_examples/followable_interface_examples.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+shared_examples_for "followable interface" do
+  describe "follows_count" do
+    let(:query) { "{ followsCount }" }
+
+    it "includes the field" do
+      expect(response["followsCount"]).to eq(model.follows_count)
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# 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

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

@@ -0,0 +1,126 @@
+# 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
+
+# This example requires a let!(:most_liked)
+shared_examples_for "connection has like_count sort" do |connection|
+  describe "ASC" do
+    let(:query) { %[{ #{connection}(order: {likeCount: "ASC"}) { edges { node { id } } } }] }
+
+    it "returns the most liked last" do
+      expect(response[connection]["edges"].count).to eq(4)
+      expect(response[connection]["edges"].last["node"]["id"]).to eq(most_liked.id.to_s)
+    end
+  end
+
+  describe "DESC" do
+    let(:query) { %[{ #{connection}(order: {likeCount: "DESC"}) { edges { node { id } } } }] }
+
+    it "returns the most liked first" do
+      expect(response[connection]["edges"].count).to eq(4)
+      expect(response[connection]["edges"].first["node"]["id"]).to eq(most_liked.id.to_s)
+    end
+  end
+end

data/lib/decidim/api/test/shared_examples/likeable_interface_examples.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+shared_examples_for "likeable interface" do
+  describe "likesCount" do
+    let(:query) { "{ likesCount }" }
+
+    it "returns the amount of likes for this query" do
+      expect(response["likesCount"]).to eq(model.likes.count)
+    end
+  end
+
+  describe "likes" do
+    let(:query) { "{ likes { name } }" }
+
+    it "returns the likes this query has received" do
+      like_names = response["likes"].map { |like| like["name"] }
+      expect(like_names).to include(*model.likes.map(&:author).map(&:name))
+    end
+  end
+end

data/lib/decidim/api/test/shared_examples/localizable_interface_examples.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+shared_examples_for "localizable interface" do
+  describe "address" do
+    let(:query) { "{ address }" }
+
+    it "returns the address of this proposal" do
+      expect(response["address"]).to eq(model.address)
+    end
+  end
+
+  describe "coordinates" do
+    let(:query) { "{ coordinates { latitude longitude } }" }
+
+    before do
+      model.latitude = 2
+      model.longitude = 40
+      model.save!
+    end
+    it "returns the meeting's address" do
+      expect(response["coordinates"]).to include(
+        "latitude" => model.latitude,
+        "longitude" => model.longitude
+      )
+    end
+  end
+end

data/lib/decidim/api/test/shared_examples/participatory_space_resourcable_interface_examples.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+shared_examples_for "participatory space resourcable interface" do
+  let!(:process1) { create(:participatory_process, organization: model.organization) }
+  let!(:process2) { create(:participatory_process, organization: model.organization) }
+  let!(:process3) { create(:participatory_process, organization: model.organization) }
+  let!(:model) { create(:assembly) }
+
+  context "when checks is has steps" do
+    describe "hasSteps" do
+      let(:query) { "{hasSteps}" }
+
+      it "has the field" do
+        expect(response["hasSteps"]).to be(false)
+      end
+    end
+
+    describe "allows_steps" do
+      let(:query) { "{allowsSteps}" }
+
+      it "has the field" do
+        expect(response["allowsSteps"]).to be(false)
+      end
+    end
+  end
+
+  context "when linked from the model" do
+    describe "linkedParticipatorySpaces" do
+      let(:query) { "{ linkedParticipatorySpaces { participatorySpace { id } } }" }
+
+      before do
+        model.link_participatory_space_resources([process1, process2], :included_participatory_processes)
+      end
+
+      it "includes the linked resources" do
+        ids = response["linkedParticipatorySpaces"].map { |l| l["participatorySpace"]["id"] }
+        expect(ids).to include(process1.id.to_s, process2.id.to_s)
+        expect(ids).not_to include(process3.id.to_s)
+      end
+    end
+  end
+
+  context "when linked towards the model" do
+    describe "linkedParticipatorySpaces" do
+      let(:query) { "{ linkedParticipatorySpaces { participatorySpace { id } } }" }
+
+      before do
+        process1.link_participatory_space_resources(model, :included_participatory_processes)
+        process2.link_participatory_space_resources(model, :included_participatory_processes)
+      end
+
+      it "includes the linked resources" do
+        ids = response["linkedParticipatorySpaces"].map { |l| l["participatorySpace"]["id"] }
+        expect(ids).to include(process1.id.to_s, process2.id.to_s)
+        expect(ids).not_to include(process3.id.to_s)
+      end
+    end
+  end
+end

data/lib/decidim/api/test/shared_examples/referable_interface_examples.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+shared_examples_for "referable interface" do
+  describe "reference" do
+    let(:query) { "{ reference }" }
+
+    it "includes the field" do
+      expect(response["reference"]).to eq(model.reference.to_s)
+    end
+  end
+end

data/lib/decidim/api/test/shared_examples/scopable_interface_examples.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+shared_examples_for "scopable interface" do
+  let!(:scope) { create(:scope, organization: model.participatory_space.organization) }
+
+  before do
+    model.update(scope:)
+  end
+
+  describe "scope" do
+    let(:query) { "{ scope { id } }" }
+
+    it "has a scope" do
+      expect(response).to include("scope" => { "id" => scope.id.to_s })
+    end
+  end
+end

data/lib/decidim/api/test/shared_examples/statistics_examples.rb

@@ -4,21 +4,21 @@ require "spec_helper"
 
 shared_examples "implements stats type" do
   context "when the space implements stats" do
-    let(:expected_data) do
-      {
-        "stats" => [
-          { "name" => "dummies_count_high", "value" => 0 },
-          { "name" => "pages_count", "value" => 0 },
-          { "name" => "proposals_count", "value" => 0 },
-          { "name" => "meetings_count", "value" => 0 },
-          { "name" => "budgets_count", "value" => 0 },
-          { "name" => "surveys_count", "value" => 0 },
-          { "name" => "results_count", "value" => 0 },
-          { "name" => "debates_count", "value" => 0 },
-          { "name" => "sortitions_count", "value" => 0 },
-          { "name" => "posts_count", "value" => 0 }
-        ]
-      }
+    before do
+      allow(Decidim::ParticipatoryProcesses::ParticipatoryProcessStatsPresenter).to receive(:new)
+        .and_return(double(collection: [
+                             { name: "dummies_count_high", data: [0], tooltip_key: "dummies_count_high_tooltip" },
+                             { name: "pages_count", data: [0], tooltip_key: "pages_count_tooltip" },
+                             { name: "proposals_count", data: [0], tooltip_key: "proposals_count_tooltip" },
+                             { name: "meetings_count", data: [0], tooltip_key: "meetings_count_tooltip" },
+                             { name: "projects_count", data: [0], tooltip_key: "budgets_count_tooltip" },
+                             { name: "surveys_count", data: [0], tooltip_key: "surveys_count_tooltip" },
+                             { name: "results_count", data: [0], tooltip_key: "results_count_tooltip" },
+                             { name: "debates_count", data: [0], tooltip_key: "debates_count_tooltip" },
+                             { name: "sortitions_count", data: [0], tooltip_key: "sortitions_count_tooltip" },
+                             { name: "posts_count", data: [0], tooltip_key: "posts_count_tooltip" },
+                             { name: "collaborative_texts_count", data: [0], tooltip_key: "collaborative_texts_count_tooltip" }
+                           ]))
     end
 
     it "executes successfully" do
@@ -26,7 +26,21 @@ shared_examples "implements stats type" do
     end
 
     it "returns the correct response" do
-      expect(stats_response).to match_array(expected_data["stats"])
+      expect(stats_response).to match_array(
+        [
+          { "name" => { "translation" => "Dummies high" }, "value" => 0 },
+          { "name" => { "translation" => "Pages" }, "value" => 0 },
+          { "name" => { "translation" => "Proposals" }, "value" => 0 },
+          { "name" => { "translation" => "Meetings" }, "value" => 0 },
+          { "name" => { "translation" => "Budgets" }, "value" => 0 },
+          { "name" => { "translation" => "Surveys" }, "value" => 0 },
+          { "name" => { "translation" => "Results" }, "value" => 0 },
+          { "name" => { "translation" => "Debates" }, "value" => 0 },
+          { "name" => { "translation" => "Sortitions" }, "value" => 0 },
+          { "name" => { "translation" => "Posts" }, "value" => 0 },
+          { "name" => { "translation" => "Collaborative texts" }, "value" => 0 }
+        ]
+      )
     end
   end
 end

data/lib/decidim/api/test/shared_examples/taxonomizable_interface_examples.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+shared_examples_for "taxonomizable interface" do
+  let!(:root_taxonomy) { create(:taxonomy, organization:) }
+  let!(:taxonomy) { create(:taxonomy, parent: root_taxonomy, organization:) }
+
+  before do
+    model.update(taxonomies: [taxonomy])
+  end
+
+  describe "taxonomies" do
+    let(:query) { "{ taxonomies { id } }" }
+
+    it "has taxonomies" do
+      expect(response).to include("taxonomies" => [{ "id" => taxonomy.id.to_s }])
+    end
+  end
+end

data/lib/decidim/api/test/shared_examples/timestamps_interface_examples.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+shared_examples_for "timestamps interface" do
+  describe "createdAt" do
+    let(:query) { "{ createdAt }" }
+
+    it "returns when was this query created at" do
+      expect(response["createdAt"]).to eq(model.created_at.to_time.iso8601)
+    end
+  end
+
+  describe "updatedAt" do
+    let(:query) { "{ updatedAt }" }
+
+    it "returns when was this query updated at" do
+      expect(response["updatedAt"]).to eq(model.updated_at.to_time.iso8601)
+    end
+  end
+end

data/lib/decidim/api/test/shared_examples/traceable_interface_examples.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+shared_examples_for "traceable interface" do
+  let(:field) { :title }
+
+  describe "traceable", versioning: true do
+    let(:version_author) { try(:author) || model.try(:creator_identity) || model.try(:normalized_author) }
+
+    before { Decidim.traceability.update!(model, version_author, field => { en: "test" }) }
+
+    context "when field createdAt" do
+      let(:query) { "{ versions { createdAt } }" }
+
+      it "returns created_at field of the version to iso format" do
+        dates = response["versions"].map { |version| version["createdAt"] }
+        expect(dates).to include(*model.versions.map { |version| version.created_at.to_time.iso8601 })
+      end
+    end
+
+    context "when field id" do
+      let(:query) { "{ versions { id } }" }
+
+      it "returns ID field of the version" do
+        ids = response["versions"].map { |version| version["id"].to_i }
+        expect(ids).to include(*model.versions.map(&:id))
+      end
+    end
+
+    context "when field editor" do
+      let(:query) { "{ versions { editor { name } } }" }
+
+      it "returns editor field of the versions" do
+        editors = response["versions"].map { |version| version["editor"]["name"] if version["editor"] }
+        expect(editors).to include(*model.versions.map { |version| version.editor.name if version.respond_to? :editor })
+      end
+    end
+
+    context "when field changeset" do
+      let(:query) { "{ versions { changeset } }" }
+
+      it "returns changeset field of the versions" do
+        changesets = response["versions"].map { |version| version["changeset"] }
+        expect(changesets).to include(*model.versions.map(&:changeset))
+      end
+    end
+  end
+end

data/lib/decidim/api/test/type_context.rb

@@ -4,11 +4,17 @@ shared_context "with a graphql class type" do
   let!(:current_organization) { create(:organization) }
   let!(:current_user) { create(:user, :confirmed, organization: current_organization) }
   let!(:current_component) { create(:component) }
+  let(:api_scopes) do
+    if current_user.present?
+      Doorkeeper::OAuth::Scopes.from_array(Doorkeeper.config.scopes.all)
+    else
+      Doorkeeper::OAuth::Scopes.from_string("api:read")
+    end
+  end
   let(:model) { OpenStruct.new({}) }
   let(:type_class) { described_class }
   let(:variables) { {} }
   let(:root_value) { model }
-  let(:can_introspect) { Decidim::Api.enable_anonymous_introspection || current_user&.admin? }
 
   let(:schema) do
     klass = type_class
@@ -22,20 +28,6 @@ shared_context "with a graphql class type" do
     execute_query query, variables.stringify_keys
   end
 
-  def raise_proper_error(error)
-    code = error.dig("extensions", "code")
-
-    # Matches the error code with the Error class
-    # For instance, if the error code is NOT_FOUND_ERROR then it will raise the "Decidim::Api::Errors::NotFoundError" class
-    raise "Decidim::Api::Errors::#{code.downcase.classify}".constantize, error["message"] if %w(
-      INTROSPECTION_DISABLED_ERROR
-      TOO_MANY_ALIASES_ERROR
-      RECURSION_LIMIT_EXCEEDED_ERROR
-    ).include?(code)
-
-    raise GraphQL::ExecutionError, error["message"]
-  end
-
   def execute_query(query, variables)
     result = schema.execute(
       query,
@@ -44,92 +36,17 @@ shared_context "with a graphql class type" do
         current_organization:,
         current_user:,
         current_component:,
-        can_introspect:
+        scopes: api_scopes
       },
       variables:
     )
 
-    raise_proper_error(result["errors"].first) if result["errors"]
+    raise StandardError, result["errors"].map { |e| e["message"] }.join(", ") if result["errors"]
 
     result["data"]
   end
 end
 
-shared_examples "when the introspection is disabled" do
-  shared_examples "check introspection behavior" do
-    context "and the user is not authenticated" do
-      let!(:current_user) { nil }
-
-      it "raises an Decidim::Api::Errors::IntrospectionDisabledError" do
-        expect { response }.to raise_error(Decidim::Api::Errors::IntrospectionDisabledError, "Introspection is disabled for this request")
-      end
-    end
-
-    context "and the user is not an admin" do
-      let!(:current_user) { create(:user, :confirmed, organization: current_organization) }
-
-      it "raises an Decidim::Api::Errors::IntrospectionDisabledError" do
-        expect { response }.to raise_error(Decidim::Api::Errors::IntrospectionDisabledError, "Introspection is disabled for this request")
-      end
-    end
-
-    context "and the user is an admin" do
-      let!(:current_user) { create(:user, :confirmed, :admin, organization: current_organization) }
-
-      it "runs successfully" do
-        expect { response }.not_to raise_error
-      end
-    end
-
-    context "and the setting is true" do
-      before do
-        allow(Decidim::Api).to receive(:enable_anonymous_introspection).and_return(true)
-      end
-
-      it "runs successfully" do
-        expect { response }.not_to raise_error
-      end
-    end
-
-    context "and the setting is false" do
-      before do
-        allow(Decidim::Api).to receive(:enable_anonymous_introspection).and_return(false)
-      end
-      it "raises an Decidim::Api::Errors::IntrospectionDisabledError" do
-        expect { response }.to raise_error(Decidim::Api::Errors::IntrospectionDisabledError, "Introspection is disabled for this request")
-      end
-    end
-  end
-
-  context "when requesting the schema introspection" do
-    let(:query) do
-      %( query { __schema { types { fields { type { fields { type { name } } } } } } } )
-    end
-
-    it_behaves_like "check introspection behavior"
-  end
-
-  context "when requesting the type introspection" do
-    let(:query) do
-      %( query CircularIntrospection {
-  __type(name: "User") {
-    fields {
-      type {
-        fields {
-          type {
-            name
-          }
-        }
-      }
-    }
-  }
-} )
-    end
-
-    it_behaves_like "check introspection behavior"
-  end
-end
-
 shared_context "with a graphql scalar class type" do
   include_context "with a graphql class type"