decidim-department_admin 0.7.2 → 0.8.1

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

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

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

data/spec/features/check_overrides_spec.rb

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

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

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

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

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

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

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

data/spec/system/admin_invite_department_admin_spec.rb

@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-#
-# To "downgrade" an admin to department_admin, it must first be removed from admins
-# create a new admin as department_admin.
-#
-describe "Admin invite user", type: :system do
-  let!(:area) { create(:area) }
-
-  let(:organization) { create(:organization) }
-
-  let!(:admin) { create(:user, :admin, :confirmed, organization: organization) }
-  let(:user_manager) { create(:user, :user_manager, :confirmed, organization: organization) }
-
-  let(:department_admin) do
-    user = create(:user, :confirmed, organization: organization)
-    user.roles << "department_admin"
-    user.areas << area
-    user.save!
-    user
-  end
-
-  before do
-    switch_to_host(organization.host)
-    login_as admin, scope: :user
-    visit decidim_admin.new_user_path
-  end
-
-  it "admin is able to create department admins" do
-    fill_the_form_for_department_admin("Cabello Loco", "my@email.net")
-    submit_form
-    check_succeess
-    user = check_is_department_admin("my@email.net")
-    check_assigned_area(user, area)
-  end
-
-  it "admin is able to add department_admin role to existing user" do
-    fill_the_form_for_department_admin(user_manager.name, user_manager.email)
-    submit_form
-    check_succeess
-    check_is_department_admin(user_manager.email)
-    check_assigned_area(user_manager, area)
-  end
-
-  context "when departments are reorganized" do
-    let!(:new_area) { create(:area) }
-
-    before do
-      department_admin
-      visit decidim_admin.new_user_path
-    end
-
-    it "admin is able to change department_admin's area/department" do
-      fill_the_form_for_department_admin(department_admin.name, department_admin.email, new_area)
-      submit_form
-      check_succeess
-      check_is_department_admin(department_admin.email)
-      check_assigned_area(department_admin, new_area)
-    end
-  end
-
-  context "when a department_admin is promoted to Admin" do
-    it "no longer has the `department_admin` role" do
-      department_admin
-      fill_the_form_for_admin(department_admin.name, department_admin.email)
-      submit_form
-      check_succeess
-      check_is_admin(department_admin.email)
-    end
-  end
-
-  def fill_the_form_for_department_admin(name, email, selected_area = area)
-    within "form.new_user" do
-      fill_in :user_name, with: name
-      fill_in :user_email, with: email
-      find("#user_role").find("option[value='department_admin']").select_option
-      expect(page).to have_css("#user_area_id")
-      find("#user_area_id").find("option[value='#{selected_area.id}']").select_option
-    end
-  end
-
-  def fill_the_form_for_admin(name, email, _selected_area = area)
-    within "form.new_user" do
-      fill_in :user_name, with: name
-      fill_in :user_email, with: email
-      find("#user_role").find("option[value='admin']").select_option
-    end
-  end
-
-  def submit_form
-    find("*[name=commit][type=submit]").click
-  end
-
-  def check_succeess
-    expect(page).to have_content("Participant successfully invited.")
-    expect(page).to have_current_path "/admin/users"
-  end
-
-  def check_is_admin(email)
-    user = Decidim::User.find_by(email: email).reload
-    expect(user).to be_admin
-    expect(user.roles).not_to include("department_admin")
-    expect(user.areas).to be_empty
-  end
-
-  def check_is_department_admin(email)
-    user = Decidim::User.find_by(email: email)
-    expect(user.roles).to include("department_admin")
-    user
-  end
-
-  def check_assigned_area(user, area)
-    expect(user.areas.last).to eq(area)
-    expect(user.areas.size).to eq(1)
-  end
-end