decidim-api 0.30.2 → 0.31.0.rc1

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,6 +4,13 @@ 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) { {} }
@@ -28,7 +35,8 @@ shared_context "with a graphql class type" do
       context: {
         current_organization:,
         current_user:,
-        current_component:
+        current_component:,
+        scopes: api_scopes
       },
       variables:
     )

data/lib/decidim/api/test.rb

@@ -1,3 +1,25 @@
 # frozen_string_literal: true
 
+require "decidim/api/test/component_context"
+require "decidim/api/test/shared_examples/amendable_interface_examples"
+require "decidim/api/test/shared_examples/amendable_proposals_interface_examples"
+require "decidim/api/test/shared_examples/attachable_interface_examples"
+require "decidim/api/test/shared_examples/authorable_interface_examples"
+require "decidim/api/test/shared_examples/categories_container_examples"
+require "decidim/api/test/shared_examples/categorizable_interface_examples"
+require "decidim/api/test/shared_examples/coauthorable_interface_examples"
+require "decidim/api/test/shared_examples/commentable_interface_examples"
+require "decidim/api/test/shared_examples/fingerprintable_interface_examples"
+require "decidim/api/test/shared_examples/followable_interface_examples"
+require "decidim/api/test/shared_examples/input_filter_examples"
+require "decidim/api/test/shared_examples/input_sort_examples"
+require "decidim/api/test/shared_examples/likeable_interface_examples"
+require "decidim/api/test/shared_examples/localizable_interface_examples"
+require "decidim/api/test/shared_examples/participatory_space_resourcable_interface_examples"
+require "decidim/api/test/shared_examples/referable_interface_examples"
+require "decidim/api/test/shared_examples/scopable_interface_examples"
 require "decidim/api/test/shared_examples/statistics_examples"
+require "decidim/api/test/shared_examples/taxonomizable_interface_examples"
+require "decidim/api/test/shared_examples/timestamps_interface_examples"
+require "decidim/api/test/shared_examples/traceable_interface_examples"
+require "decidim/api/test/type_context"

data/lib/decidim/api/types/base_mutation.rb

@@ -4,9 +4,13 @@ module Decidim
   module Api
     module Types
       class BaseMutation < GraphQL::Schema::RelayClassicMutation
+        include Decidim::Api::GraphqlPermissions
+
         object_class BaseObject
-        field_class BaseField
+        field_class Types::BaseField
         input_object_class BaseInputObject
+
+        required_scopes "api:read", "api:write"
       end
     end
   end