decidim-department_admin 0.7.2

data/spec/commands/decidim/admin/deliver_newsletter_spec.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module Decidim::Admin
+  describe DeliverNewsletter do
+    describe "call" do
+      let(:organization) { create(:organization) }
+      let(:newsletter) do
+        create(:newsletter,
+               organization: organization,
+               author: current_user)
+      end
+      let(:area) { create(:area, organization: organization) }
+      let(:current_user) { create(:department_admin, :confirmed, organization: organization, area: area) }
+      let(:send_to_all_users) { false }
+      let(:send_to_followers) { false }
+      let(:send_to_participants) { false }
+      let(:participatory_space_types) { [] }
+      let(:scope_ids) { [] }
+
+      let(:form_params) do
+        {
+          send_to_all_users: send_to_all_users,
+          send_to_followers: send_to_followers,
+          send_to_participants: send_to_participants,
+          participatory_space_types: participatory_space_types,
+          scope_ids: scope_ids,
+        }
+      end
+
+      let(:form) do
+        SelectiveNewsletterForm.from_params(
+          form_params
+        ).with_context(
+          current_organization: organization,
+          current_user: current_user
+        )
+      end
+
+      let(:command) { described_class.new(newsletter, form, current_user) }
+
+      shared_examples_for "selective newsletter" do
+        context "when everything is ok" do
+          it "updates the counters and delivers to the right users" do
+            clear_emails
+            expect(emails.length).to eq(0)
+
+            perform_enqueued_jobs { command.call }
+
+            expect(emails.length).to eq(deliverable_users.count)
+
+            newsletter.reload
+            expect(newsletter.total_deliveries).to eq(deliverable_users.count)
+            expect(newsletter.total_recipients).to eq(deliverable_users.count)
+          end
+
+          it "logs the action", versioning: true do
+            expect(Decidim.traceability)
+              .to receive(:perform_action!)
+              .with("deliver", newsletter, current_user)
+              .and_call_original
+
+            expect do
+              perform_enqueued_jobs { command.call }
+            end.to change(Decidim::ActionLog, :count)
+
+            action_log = Decidim::ActionLog.last
+            expect(action_log.version).to be_present
+            expect(action_log.version.event).to eq "update"
+          end
+        end
+      end
+
+      context "when the user is a department admin" do
+        let!(:participatory_process) { create(:participatory_process, organization: organization, area: area) }
+        let!(:component) { create(:dummy_component, organization: newsletter.organization, participatory_space: participatory_process) }
+
+        context "when no spaces selected" do
+          it "is not valid" do
+            expect { command.call }.to broadcast(:invalid)
+          end
+        end
+
+        context "when spaces selected" do
+          let(:participatory_space_types) do
+            [
+              { "id" => nil,
+                "manifest_name" => "participatory_processes",
+                "ids" => [component.participatory_space.id.to_s] },
+              { "id" => nil,
+                "manifest_name" => "assemblies",
+                "ids" => [] },
+              { "id" => nil,
+                "manifest_name" => "conferences",
+                "ids" => [] },
+              { "id" => nil,
+                "manifest_name" => "consultations",
+                "ids" => [] },
+              { "id" => nil,
+                "manifest_name" => "initiatives",
+                "ids" => [] },
+            ]
+          end
+
+          context "when sending to followers" do
+            let(:send_to_followers) { true }
+
+            let!(:deliverable_users) do
+              create_list(:user, rand(2..9), :confirmed, organization: organization, newsletter_notifications_at: Time.current)
+            end
+
+            let!(:undeliverable_users) do
+              create_list(:user, rand(2..9), :confirmed, organization: organization, newsletter_notifications_at: Time.current)
+            end
+
+            before do
+              deliverable_users.each do |follower|
+                create(:follow, followable: participatory_process, user: follower)
+              end
+            end
+
+            it_behaves_like "selective newsletter"
+          end
+
+          context "when sending to all space participants" do
+            let(:send_to_participants) { true }
+            let!(:deliverable_users) do
+              create_list(:user, rand(2..9), :confirmed, organization: organization, newsletter_notifications_at: Time.current)
+            end
+
+            before do
+              deliverable_users.each do |participant|
+                create(:dummy_resource, component: component, author: participant, published_at: Time.current)
+              end
+            end
+
+            it_behaves_like "selective newsletter"
+          end
+
+          context "when sending to followers and participants" do
+            let(:send_to_participants) { true }
+            let(:send_to_followers) { true }
+
+            let!(:participant_users) do
+              create_list(:user, rand(2..9), :confirmed, organization: organization, newsletter_notifications_at: Time.current)
+            end
+
+            let!(:follower_users) do
+              create_list(:user, rand(2..9), :confirmed, organization: organization, newsletter_notifications_at: Time.current)
+            end
+
+            let!(:deliverable_users) { participant_users + follower_users }
+
+            let!(:undeliverable_users) do
+              create_list(:user, rand(2..9), :confirmed, organization: organization, newsletter_notifications_at: Time.current)
+            end
+
+            before do
+              participant_users.each do |participant|
+                create(:dummy_resource, component: component, author: participant, published_at: Time.current)
+              end
+
+              follower_users.each do |follower|
+                create(:follow, followable: component.participatory_space, user: follower)
+              end
+            end
+
+            it_behaves_like "selective newsletter"
+          end
+        end
+      end
+    end
+  end
+end

data/spec/commands/decidim/invite_user_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module Decidim
+  describe InviteUser do
+    describe "call" do
+      let(:organization) { create(:organization) }
+
+      let(:current_user) { create(:admin, :confirmed, organization: organization) }
+
+      let(:form_params) do
+        {
+          name: "user_name",
+          email: "user_name@example.org",
+          organization: organization,
+        }
+      end
+
+      let(:form) do
+        InviteUserForm.from_params(
+          form_params
+        ).with_context(
+          current_organization: organization,
+          current_user: current_user
+        )
+      end
+
+      let(:command) { described_class.new(form, current_user) }
+
+      shared_examples_for "inviting_users" do
+        context "when everything is ok" do
+          it "invites the user with no area" do
+            invite_user
+            user = Decidim::User.find_by(email: "user_name@example.org")
+            expect(user).to exist
+          end
+        end
+      end
+    end
+  end
+end

data/spec/controllers/decidim/admin/users_controller_spec.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module Decidim::Admin
+  describe UsersController, type: :controller do
+    # routes { Decidim::Core::Engine.routes }
+    routes { Decidim::Admin::Engine.routes }
+
+    let!(:admin_user) { create(:user, :admin, :confirmed) }
+    let!(:current_user) { admin_user }
+    let(:organization) { admin_user.organization }
+
+    before do
+      request.env["decidim.current_organization"] = organization
+      sign_in current_user, scope: :user
+    end
+
+    describe "role filter" do
+      let!(:participant) { create(:user, :confirmed, organization: organization) }
+      let!(:department_admin_user) { create(:department_admin, :confirmed, organization: organization) }
+      let!(:user_manager) { create(:user, :confirmed, organization: organization, roles: ["user_manager"]) }
+      let!(:process_admin) { create(:user, :confirmed, organization: organization) }
+      let!(:participatory_process) { create(:participatory_process, organization: organization, title: { en: "A Process space" }) }
+      let!(:process_admin_rel) { Decidim::ParticipatoryProcessUserRole.create(role: "admin", user: process_admin, participatory_process: participatory_process) }
+      let!(:assembly_admin) { create(:user, :confirmed, organization: organization) }
+      let!(:assembly) { create(:assembly, organization: organization, title: { en: "An Assembly space" }) }
+      let!(:assembly_admin_rel) { Decidim::AssemblyUserRole.create(role: "admin", user: assembly_admin, assembly: assembly) }
+
+      subject { controller.filtered_collection }
+
+      context "when not filtering" do
+        it "lists all kind of admin users" do
+          get :index, params: {}
+
+          expect(subject).to include(admin_user, department_admin_user, user_manager, assembly_admin, process_admin)
+          expect(subject).not_to include(participant)
+          expect(response).to render_template(:index)
+        end
+      end
+
+      context "when filtering by process admin email in user term" do
+        it "lists the process admin user" do
+          get :index, params: { q: { name_or_nickname_or_email_cont: process_admin.email.split("@").first } }
+
+          expect(subject).to include(process_admin)
+          expect(subject).not_to include(admin_user, department_admin_user, user_manager, assembly_admin, participant)
+          expect(response).to render_template(:index)
+        end
+      end
+
+      context "when filtering by space name" do
+        it "lists the space_admins in spaces matching the given term" do
+          get :index, params: { q: { name_or_nickname_or_email_cont: "space" }, filter_search: "by_process_name" }
+
+          expect(subject).to include(process_admin, assembly_admin)
+          expect(subject).not_to include(admin_user, department_admin_user, user_manager, participant)
+          expect(response).to render_template(:index)
+        end
+      end
+
+      context "when filtering by admin role" do
+        let(:params) do
+          { role: "admin" }
+        end
+
+        it "lists only users with role admin" do
+          get :index, params: params
+
+          expect(subject).to include(admin_user)
+          expect(subject).not_to include(department_admin_user, user_manager, process_admin, assembly_admin, participant)
+          expect(response).to render_template(:index)
+        end
+      end
+
+      context "when filtering by department_admin role" do
+        let(:params) do
+          { role: "department_admin" }
+        end
+
+        it "lists only users with role department_admin" do
+          get :index, params: params
+
+          expect(subject).to include(department_admin_user)
+          expect(subject).not_to include(admin_user, user_manager, process_admin, assembly_admin, participant)
+          expect(response).to render_template(:index)
+        end
+      end
+
+      context "when filtering by user_manager role" do
+        let(:params) do
+          { role: "user_manager" }
+        end
+
+        it "lists only users with role user_manager" do
+          get :index, params: params
+
+          expect(subject).to include(user_manager)
+          expect(subject).not_to include(admin_user, department_admin_user, process_admin, assembly_admin, participant)
+          expect(response).to render_template(:index)
+        end
+      end
+
+      context "when filtering by space_admin role" do
+        let(:params) do
+          { role: "space_admin" }
+        end
+
+        it "lists only users with role space_admin" do
+          get :index, params: params
+
+          expect(subject).to include(process_admin, assembly_admin)
+          expect(subject).not_to include(admin_user, department_admin_user, user_manager, participant)
+          expect(response).to render_template(:index)
+        end
+      end
+    end
+  end
+end

data/spec/factories.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "decidim/department_admin/test/factories"
+require "decidim/conferences/test/factories"

data/spec/features/check_overrides_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Overrides" do
+  it "check failing tests in Decidim v0.28" do
+    # Make test succeed spec/system/department_admin_should_be_able_to_manage_assemblies_spec.rbL73
+    # expect(page).to have_current_path decidim_admin_assemblies.assemblies_path(q: { parent_id_eq: parent_assembly&.id })
+    expect(Decidim.version).to be < "0.28"
+  end
+end

data/spec/i18n_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "i18n/tasks"
+
+RSpec.describe "I18n" do
+  let(:i18n) { I18n::Tasks::BaseTask.new }
+  let(:missing_keys) { i18n.missing_keys }
+  let(:unused_keys) { i18n.unused_keys }
+
+  # All keys from overriding templates come from Decidim so we're having many false positives
+  # Probably it will be best tot remove this spec rather than having all keys ignored.
+  # it "does not have missing keys" do
+  #   expect(missing_keys).to be_empty,
+  #                           "Missing #{missing_keys.leaves.count} i18n keys, run `i18n-tasks missing' to show them"
+  # end
+
+  it "does not have unused keys" do
+    expect(unused_keys).to be_empty,
+                           "#{unused_keys.leaves.count} unused i18n keys, run `i18n-tasks unused' to show them"
+  end
+
+  it "files are normalized" do
+    non_normalized = i18n.non_normalized_paths
+    error_message = "The following files need to be normalized:\n" \
+                    "#{non_normalized.map { |path| "  #{path}" }.join("\n")}\n" \
+                    "Please run `i18n-tasks normalize` to fix"
+    expect(non_normalized).to be_empty, error_message
+  end
+end

data/spec/models/decidim/area_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module Decidim
+  describe Area do
+    subject(:area) { create(:area) }
+
+    context "when depending participatory process exist" do
+      let!(:department_admin) do
+        user = create(:user, :confirmed, organization: area.organization)
+        user.roles << "department_admin"
+        user.areas << area
+        user.save!
+        user
+      end
+
+      it "can not be deleted" do
+        expect(area.destroy).to be false
+      end
+    end
+  end
+end

data/spec/permissions/decidim/department_admin/department_admin_permissions_spec.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module Decidim
+  module DepartmentAdmin
+    describe Permissions do
+      let(:area) { create(:area) }
+      let!(:user) do
+        create(:department_admin, :confirmed, organization: area.organization, area: area)
+      end
+
+      def should_allow_action(scope, action, subject)
+        action = PermissionAction.new(scope: scope, action: action, subject: subject)
+        permissions = DepartmentAdmin::Permissions.new(user, action)
+        expect(permissions.permissions).to be_allowed
+      end
+
+      def should_allow_action_with_ctx(scope, action, subject, ctx)
+        action = PermissionAction.new(scope: scope, action: action, subject: subject)
+        permissions = DepartmentAdmin::Permissions.new(user, action, ctx)
+        expect(permissions.permissions).to be_allowed
+      end
+
+      context "when user role is department_admin" do
+        context "with simple permission actions" do
+          it "allows accepted actions" do
+            should_allow_action(:admin, :read, :admin_dashboard)
+            should_allow_action(:admin, :read, :process_list)
+            should_allow_action(:admin, :create, :process)
+            should_allow_action(:admin, :read, :process_step)
+            should_allow_action(:admin, :create, :process_step)
+            should_allow_action(:admin, :read, :assembly_list)
+            should_allow_action(:admin, :read, :assembly_user_role)
+            should_allow_action(:admin, :create, :assembly)
+            should_allow_action(:admin, :index, :newsletter)
+            should_allow_action(:admin, :create, :newsletter)
+            should_allow_action(:admin, :create, :attachment_collection)
+            should_allow_action(:admin, :read, :conference_list)
+            should_allow_action(:admin, :read, :conference_user_role)
+            should_allow_action(:admin, :create, :conference)
+          end
+
+          it "does not allow non accepted actions" do
+            action = PermissionAction.new(scope: :admin, action: :write, subject: :admin_dashboard)
+            permissions = DepartmentAdmin::Permissions.new(user, action)
+            expect { permissions.permissions.allowed? }.to raise_error(Decidim::PermissionAction::PermissionNotSetError)
+          end
+        end
+
+        context "with permission actions with context" do
+          context "when acction is allowed and context is space_name" do
+            it "allows accepted actions with expected context" do
+              should_allow_action_with_ctx(:admin, :enter, :space_area, space_name: :processes)
+              should_allow_action_with_ctx(:admin, :enter, :space_area, space_name: :assemblies)
+              should_allow_action_with_ctx(:admin, :enter, :space_area, space_name: :conferences)
+            end
+
+            it "does not allow accepted actions with unexpected context" do
+              action = PermissionAction.new(scope: :admin, action: :enter, subject: :space_area)
+              permissions = DepartmentAdmin::Permissions.new(user, action, space_name: :custom_module)
+              expect { permissions.permissions.allowed? }.to raise_error(Decidim::PermissionAction::PermissionNotSetError)
+            end
+          end
+
+          context "when acction is allowed and context is process" do
+            context "when process has same area as department_admin" do
+              let(:process) { create(:participatory_process, organization: area.organization, area: area) }
+              let(:assembly) { create(:assembly, organization: area.organization, area: area) }
+              let(:conference) { create(:conference, organization: area.organization, area: area) }
+
+              it "allows accepted actions with expected context" do
+                should_allow_action_with_ctx(:admin, :read, :participatory_space, current_participatory_space: process)
+                should_allow_action_with_ctx(:admin, :update, :process, process: process)
+                pps = ParticipatoryProcessStep.new(participatory_process: process)
+                should_allow_action_with_ctx(:admin, :update, :process_step, process_step: pps)
+                should_allow_action_with_ctx(:admin, :destroy, :process_step, process_step: pps)
+                should_allow_action_with_ctx(:admin, :update, :assembly, assembly: assembly)
+                should_allow_action_with_ctx(:admin, :update, :conference, conference: conference)
+                # -> {permission_for?(requested_action, :admin, :read, :newsletter, restricted_rsrc: context[:newsletter])},
+              end
+
+              context "when meeting has same area as department_admin" do
+                let(:meeting) { create(:meeing, participatory_space: process, area: area) }
+
+                it "allows accepted actions with expected context" do
+                  should_allow_action(:admin, :create, :attachment)
+                end
+              end
+            end
+
+            context "when process has different area as department_admin" do
+              let(:process) { create(:participatory_process, organization: area.organization) }
+
+              it "does not allow accepted actions with unexpected context" do
+                action = PermissionAction.new(scope: :admin, action: :update, subject: :process)
+                permissions = DepartmentAdmin::Permissions.new(user, action, process: process)
+                expect { permissions.permissions.allowed? }.to raise_error(Decidim::PermissionAction::PermissionNotSetError)
+              end
+            end
+          end
+
+          # context "when acction is allowed and context is component" do
+          # context "when component has same area as department_admin" do
+          # TODO: complete the test implementation
+          # let(:process) { create(:participatory_process, organization: area.organization, area: area) }
+          # let(:component) { create(:survey, participatory_space: process) }
+
+          # it "should allow accepted actions" # do
+          #   should_allow_action(:admin, :read, :component)
+          #   should_allow_action(:admin, :create, :component)
+          #   should_allow_action_with_ctx(:admin, :export, :component_data, current_participatory_space: process)
+          # end
+          # end
+          # end
+        end
+      end
+    end
+  end
+end

data/spec/queries/parent_assemblies_for_select_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module Decidim::Assemblies
+  describe ParentAssembliesForSelect do
+    subject { described_class.for(organization, assembly) }
+
+    let(:organization) { create(:organization) }
+    let!(:assembly) { create(:assembly, organization: organization) }
+    let!(:assemblies) { create_list(:assembly, 3, organization: organization) }
+    let!(:child_assembly) { create(:assembly, :with_parent, parent: assembly, organization: organization) }
+    let!(:grand_child_assembly) { create(:assembly, :with_parent, parent: child_assembly, organization: organization) }
+
+    describe "query" do
+      context "when current_user is nil" do
+        it "returns assemblies that can be parent" do
+          expect(subject.count).to eq(3)
+          expect(subject).to match_array(assemblies)
+        end
+      end
+
+      context "when current_user is present" do
+        subject { described_class.for(organization, assembly, current_user) }
+
+        let!(:current_user) do
+          create(:department_admin, :confirmed, organization: area.organization, area: area)
+        end
+        let(:area) { create(:area) }
+        let!(:assemblies_with_area) { create_list(:assembly, 3, organization: organization, area: area) }
+
+        it "returns assemblies that can be parent with same current user area" do
+          expect(subject.count).to eq(3)
+          expect(subject).to match_array(assemblies_with_area)
+        end
+      end
+
+      context "when assembly is nil" do
+        let(:assembly) { nil }
+
+        it "returns all assemblies" do
+          expected = assemblies
+          expected << child_assembly
+          expected << grand_child_assembly
+
+          expect(subject.count).to eq(5)
+          expect(subject).to match_array(expected)
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "decidim/dev"
+
+ENV["ENGINE_ROOT"] = File.dirname(__dir__)
+
+# require "decidim/admin"
+# require "decidim/core"
+# require "decidim/core/test"
+
+Decidim::Dev.dummy_app_path = File.expand_path(File.join("spec", "decidim_dummy_app"))
+
+require "decidim/dev/test/base_spec_helper"
+
+require "decidim/department_admin"
+
+if ENV["SIMPLECOV"]
+  require "simplecov"
+  SimpleCov.start do
+    # `ENGINE_ROOT` holds the name of the engine we're testing.
+    # This brings us to the main Decidim folder.
+    root File.expand_path(".", ENV.fetch("ENGINE_ROOT", nil))
+
+    # We make sure we track all Ruby files, to avoid skipping unrequired files
+    # We need to include the `../` section, otherwise it only tracks files from the
+    # `ENGINE_ROOT` folder for some reason.
+    # track_files "../**/*.rb"
+
+    # We ignore some of the files because they are never tested
+    add_filter "/config/"
+    add_filter "/db/"
+    add_filter "/vendor/"
+    add_filter "/spec/"
+    add_filter "/test/"
+    add_filter %r{^/decidim-[^/]*/lib/decidim/[^/]*/engine.rb}
+    add_filter %r{^/decidim-[^/]*/lib/decidim/[^/]*/admin-engine.rb}
+    add_filter %r{^/decidim-[^/]*/lib/decidim/[^/]*/component.rb}
+    add_filter %r{^/decidim-[^/]*/lib/decidim/[^/]*/participatory_space.rb}
+  end
+
+  SimpleCov.merge_timeout 1800
+
+  if ENV["CI"]
+    require "simplecov-cobertura"
+    SimpleCov.formatter = SimpleCov::Formatter::CoberturaFormatter
+  end
+end

data/spec/system/admin_explores_processes_spec.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe "Admin explores processes", type: :system do
+  let(:organization) { create(:organization) }
+  let!(:area) { create(:area, organization: organization) }
+  let!(:process) { create(:participatory_process, organization: organization, area: area) }
+
+  let!(:admin) { create(:user, :admin, :confirmed, organization: organization) }
+
+  before do
+    switch_to_host(organization.host)
+    login_as admin, scope: :user
+  end
+
+  describe "when there are admins of all types" do
+    let!(:department_admin) do
+      user = create(:user, :confirmed, organization: organization)
+      user.roles << "department_admin"
+      user.areas << area
+      user.save!
+      user
+    end
+
+    context "when visiting the list of participatory processes" do
+      before do
+        visit decidim_admin_participatory_processes.participatory_processes_path
+      end
+
+      it "renders a new column for the process department (aka area)" do
+        check_column_header_exists(position: 2, content: "Department/Area")
+        check_column_data_exists(position: 2, content: area.name["en"])
+        check_column_data_exists(position: 3, content: department_admin.name)
+      end
+
+      it "renders a new column for the department admins in the process"
+      it "renders a new column for the process admins in the process"
+    end
+  end
+
+  def check_column_header_exists(position: 1, content: "")
+    within "#processes .card-section .table-scroll table thead th:nth-child(#{position})" do
+      expect(page).to have_content(content)
+    end
+  end
+
+  def check_column_data_exists(position: 1, content: "")
+    within "#processes .card-section .table-scroll table tbody td:nth-child(#{position})" do
+      expect(page).to have_content(content)
+    end
+  end
+end