releaf-permissions 2.0.0 → 2.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa31bd6692140be7d800598e94aff5d1ce8276fc96bff80a4c1b3756d18ac05d
-  data.tar.gz: 3508caf658624203c8a6ea595421fe306740874f9a3e764a4750def9d5dd9169
+  metadata.gz: 377558e18e84941c82966437a3b4579e8f394a500ea4bb1305d46b646f74e25e
+  data.tar.gz: a96e27ff24c657b4d15fcc6895b450b70bcc65684c7169a33af982fefaf8c446
 SHA512:
-  metadata.gz: 24a3c172b366c01960f213fc29508b125cd7ec5c0d3dff1acbc3957056b3559a5bafceafd046eed8b2fbd21de550cf90065667562d9636ff44e7ad26da6eb3f9
-  data.tar.gz: 74b8a2740261d062c12ab5d7a30d5d1b80dfaa2a2d4ed92e70ac690f1ec797fd2057197f2b4c13a3b1e66962e91f13dff387f3a44e46b75ca46d455b1853bc41
+  metadata.gz: f0232e12958d869feaf99e3814867f8374a356b4f49019df73b1346dbe254c0c6809c41bb0c17195f2c903aafb2c7c3a0383771005805fbc383c8e2fae8105a7
+  data.tar.gz: 271549d0755d34b369c3696cf30b706972d57d0dcf199d73f6e098a3a1a6e8d92bcf75bcde0cf47857bdb1178ec539f21929f2f28c6f11004444cbf85b8891d1

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: releaf-permissions
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.2
 platform: ruby
 authors:
 - CubeSystems
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-29 00:00:00.000000000 Z
+date: 2021-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: releaf-core
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: 2.1.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: 2.1.2
 - !ruby/object:Gem::Dependency
   name: devise
   requirement: !ruby/object:Gem::Requirement
@@ -74,30 +74,6 @@ files:
 - lib/releaf/permissions/roles.rb
 - lib/releaf/permissions/settings_manager.rb
 - lib/releaf/permissions/users.rb
-- spec/builders/releaf/permissions/page/header_builder_spec.rb
-- spec/builders/releaf/permissions/page/layout_builder_spec.rb
-- spec/builders/releaf/permissions/page/menu_builder_spec.rb
-- spec/builders/releaf/permissions/profile/form_builder_spec.rb
-- spec/builders/releaf/permissions/roles/form_builder_spec.rb
-- spec/builders/releaf/permissions/roles/table_builder_spec.rb
-- spec/builders/releaf/permissions/users/form_builder_spec.rb
-- spec/builders/releaf/permissions/users/table_builder_spec.rb
-- spec/controllers/permissions/profile_controller_spec.rb
-- spec/controllers/permissions/users_controller_spec.rb
-- spec/features/profile_updating_spec.rb
-- spec/features/roles_spec.rb
-- spec/features/users_spec.rb
-- spec/lib/access_control_spec.rb
-- spec/lib/releaf/permissions/configuration_spec.rb
-- spec/lib/releaf/permissions/controller_support_spec.rb
-- spec/lib/releaf/permissions/default_controller_resolver_spec.rb
-- spec/lib/releaf/permissions/layout_spec.rb
-- spec/lib/releaf/permissions/profile_spec.rb
-- spec/lib/releaf/permissions/roles_spec.rb
-- spec/lib/releaf/permissions/settings_manager_spec.rb
-- spec/lib/releaf/permissions/users_spec.rb
-- spec/models/permissions/role_spec.rb
-- spec/models/permissions/user_spec.rb
 homepage: https://github.com/cubesystems/releaf
 licenses:
 - MIT
@@ -117,32 +93,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
+rubygems_version: 3.2.6
 signing_key:
 specification_version: 4
 summary: Built-in admin and role support for releaf
-test_files:
-- spec/builders/releaf/permissions/page/menu_builder_spec.rb
-- spec/builders/releaf/permissions/page/layout_builder_spec.rb
-- spec/builders/releaf/permissions/page/header_builder_spec.rb
-- spec/builders/releaf/permissions/roles/table_builder_spec.rb
-- spec/builders/releaf/permissions/roles/form_builder_spec.rb
-- spec/builders/releaf/permissions/profile/form_builder_spec.rb
-- spec/builders/releaf/permissions/users/table_builder_spec.rb
-- spec/builders/releaf/permissions/users/form_builder_spec.rb
-- spec/features/roles_spec.rb
-- spec/features/profile_updating_spec.rb
-- spec/features/users_spec.rb
-- spec/models/permissions/user_spec.rb
-- spec/models/permissions/role_spec.rb
-- spec/lib/releaf/permissions/settings_manager_spec.rb
-- spec/lib/releaf/permissions/configuration_spec.rb
-- spec/lib/releaf/permissions/roles_spec.rb
-- spec/lib/releaf/permissions/layout_spec.rb
-- spec/lib/releaf/permissions/controller_support_spec.rb
-- spec/lib/releaf/permissions/profile_spec.rb
-- spec/lib/releaf/permissions/users_spec.rb
-- spec/lib/releaf/permissions/default_controller_resolver_spec.rb
-- spec/lib/access_control_spec.rb
-- spec/controllers/permissions/users_controller_spec.rb
-- spec/controllers/permissions/profile_controller_spec.rb
+test_files: []

data/spec/builders/releaf/permissions/page/header_builder_spec.rb

@@ -1,86 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Permissions::Page::HeaderBuilder, type: :class do
-  class PageHeaderBuilderTestHelper < ActionView::Base
-    include Rails.application.routes.url_helpers
-    include FontAwesome::Rails::IconHelper
-
-    def protect_against_forgery?
-      true
-    end
-
-    def form_authenticity_token(_)
-      "xxx"
-    end
-
-    def request_forgery_protection_token
-      "yyy"
-    end
-  end
-
-  subject { described_class.new(template) }
-  let(:template){ PageHeaderBuilderTestHelper.new(ActionView::LookupContext.new(nil), {}, nil) }
-
-  describe "#items" do
-    it "returns array of home link, profile block and logout form content" do
-      allow(subject).to receive(:home_link).and_return("a")
-      allow(subject).to receive(:profile_block).and_return("b")
-      allow(subject).to receive(:sign_out_form).and_return("c")
-      expect(subject.items).to eq(["a", "b", "c"])
-    end
-  end
-
-  describe "#profile_path" do
-    it "returns profile edit url for defined profile controller" do
-      expect(subject.profile_path).to eq("/admin/profile")
-    end
-  end
-
-  describe "#profile_block" do
-    it "returns profile block with content" do
-      allow(subject).to receive(:profile_user_name).and_return("neim")
-      allow(subject).to receive(:profile_path).and_return("url_b")
-      content = '<a class="button profile" href="url_b"><span class="name">neim</span></a>'
-      expect(subject.profile_block).to eq(content)
-    end
-  end
-
-  describe "#user" do
-    it "returns permissions manager user" do
-      controller = Releaf::RootController.new
-      allow(subject).to receive(:controller).and_return(controller)
-      allow(controller).to receive(:user).and_return("x")
-      expect(subject.user).to eq("x")
-    end
-  end
-
-  describe "#profile_user_name" do
-    it "returns title for user instance" do
-      user = Releaf::Permissions::User.new(name: "a", surname: "b")
-      allow(subject).to receive(:user).and_return(user)
-      allow(subject).to receive(:resource_title).with(user).and_return("x t")
-      expect(subject.profile_user_name).to eq("x t")
-    end
-  end
-
-  describe "#sign_out_path" do
-    it "returns sign out url" do
-      expect(subject.sign_out_path).to eq("/admin/sign_out")
-    end
-  end
-
-  describe "#sign_out_form" do
-    it "returns sign out form" do
-      allow(subject).to receive(:sign_out_path).and_return("url_a")
-      content = %Q[
-        <form class="sign-out" action="url_a" accept-charset="UTF-8" method="post">
-          <input type="hidden" name="_method" value="delete" />
-          <input type="hidden" name="yyy" value="xxx" />
-          <button class="button only-icon" type="submit" title="Sign out">
-            <i class="fa fa-power-off fa-icon-header"></i>
-          </button>
-      </form>]
-      expect(subject.sign_out_form).to match_html( content )
-    end
-  end
-end

data/spec/builders/releaf/permissions/page/layout_builder_spec.rb

@@ -1,60 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Permissions::Page::LayoutBuilder, type: :class do
-  class PermissionsLayoutBuilderView < ActionView::Base; end
-
-  let(:controller){ Releaf::RootController.new }
-  let(:template){ PermissionsLayoutBuilderView.new(ActionView::LookupContext.new(nil), {}, nil) }
-  subject { described_class.new(template) }
-
-  before do
-    allow(subject).to receive(:controller).and_return(controller)
-  end
-
-  it "inherits Releaf::Builders::Page::LayoutBuilder" do
-    expect(described_class.superclass).to eq(Releaf::Builders::Page::LayoutBuilder)
-  end
-
-  describe "#header_builder" do
-    it "returns `Releaf::Permissions::Page::HeaderBuilder` class" do
-      expect(subject.header_builder).to eq(Releaf::Permissions::Page::HeaderBuilder)
-    end
-  end
-
-  describe "#menu_builder" do
-    it "returns `Releaf::Permissions::Page::MenuBuilder` class" do
-      expect(subject.menu_builder).to eq(Releaf::Permissions::Page::MenuBuilder)
-    end
-  end
-
-  describe "#body_content_blocks" do
-    before do
-      allow(subject).to receive(:header).and_return("_header")
-      allow(subject).to receive(:menu).and_return("_menu")
-      allow(subject).to receive(:notifications).and_return("_notifications")
-      allow(subject).to receive(:assets).and_return("_assets_")
-    end
-
-    context "when controller responds to `authorized?` and `authorized?` call return true" do
-      it "returns `super` content" do
-        allow(controller).to receive(:authorized?).and_return(true)
-        expect(subject.body_content_blocks{ "x" }).to eq(["_header", "_menu", "<main id=\"main\">x</main>",
-                                                          "_notifications", "_assets_"])
-      end
-    end
-
-    context "when controller responds to `authorized?` and `authorized?` call return false" do
-      it "returns given block content" do
-        allow(controller).to receive(:authorized?).and_return(false)
-        expect(subject.body_content_blocks{ "x" }).to eq(["x"])
-      end
-    end
-
-    context "when controller does not responds to `authorized?`" do
-      it "returns given block content" do
-        allow(controller).to receive(:respond_to?).with(:authorized?).and_return(false)
-        expect(subject.body_content_blocks{ "x" }).to eq(["x"])
-      end
-    end
-  end
-end

data/spec/builders/releaf/permissions/page/menu_builder_spec.rb

@@ -1,112 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Permissions::Page::MenuBuilder, type: :class do
-  class MenuBuilderTestHelper < ActionView::Base
-    include FontAwesome::Rails::IconHelper
-  end
-
-  let(:user){ Releaf::Permissions::User.new }
-  let(:controller){ Releaf::ActionController.new }
-  let(:template){ MenuBuilderTestHelper.new(ActionView::LookupContext.new(nil), {}, nil) }
-  let(:group_item){ Releaf::ControllerGroupDefinition.new(name: "x", items: []) }
-  let(:controller_item){ Releaf::ControllerDefinition.new(name: "y", controller: "_controller_") }
-  subject { described_class.new(template) }
-
-  before do
-    allow(template).to receive(:controller).and_return(controller)
-  end
-
-  it "inherits `Releaf::Builders::Page::MenuBuilder`" do
-    expect(described_class.ancestors).to include(Releaf::Builders::Page::MenuBuilder)
-  end
-
-  describe "#menu_item" do
-    before do
-      allow(subject).to receive(:item_attributes).and_return({})
-      allow(subject).to receive(:menu_item_group).and_return("_content_")
-    end
-
-    context "when item is permitted" do
-      it "returns parent method content" do
-        allow(subject).to receive(:menu_item_permitted?).with(group_item).and_return(true)
-        expect(subject.menu_item(group_item)).to eq("<li>_content_</li>")
-      end
-    end
-
-    context "when item is not permitted" do
-      it "returns nil" do
-        allow(subject).to receive(:menu_item_permitted?).with(group_item).and_return(false)
-        expect(subject.menu_item(group_item)).to be nil
-      end
-    end
-  end
-
-  describe "#menu_item_permitted?" do
-    context "when item is instance of `Releaf::ControllerGroupDefinition`" do
-      before do
-        allow(group_item).to receive(:controllers).and_return([
-          Releaf::ControllerDefinition.new(name: "a1", controller: "c1"),
-          Releaf::ControllerDefinition.new(name: "a2", controller: "c2"),
-          Releaf::ControllerDefinition.new(name: "a3", controller: "c3"),
-        ])
-      end
-
-      context "when any of group item controller is allowed" do
-        it "returns true" do
-          allow(subject).to receive(:controller_permitted?).with("c1").and_return(false)
-          allow(subject).to receive(:controller_permitted?).with("c2").and_return(true)
-          expect(subject).to_not receive(:controller_permitted?).with("c3")
-          expect(subject.menu_item_permitted?(group_item)).to be true
-        end
-      end
-
-      context "when none of group item controller is allowed" do
-        it "returns false" do
-          allow(subject).to receive(:controller_permitted?).with("c1").and_return(false)
-          allow(subject).to receive(:controller_permitted?).with("c2").and_return(false)
-          allow(subject).to receive(:controller_permitted?).with("c3").and_return(false)
-          expect(subject.menu_item_permitted?(group_item)).to be false
-        end
-      end
-    end
-
-    context "when item is instance of `Releaf::ControllerDefinition`" do
-      context "when item controller is allowed" do
-        it "returns true" do
-          allow(subject).to receive(:controller_permitted?).with("_controller_").and_return(true)
-          expect(subject.menu_item_permitted?(controller_item)).to be true
-        end
-      end
-
-      context "when item controller is not allowed" do
-        it "returns false" do
-          allow(subject).to receive(:controller_permitted?).with("_controller_").and_return(false)
-          expect(subject.menu_item_permitted?(controller_item)).to be false
-        end
-      end
-    end
-  end
-
-  describe "#controller_permitted?" do
-    it "returns access controller controller permission query result for given controller name" do
-      access_control = Releaf::Permissions::AccessControl.new(user: user)
-      allow(subject).to receive(:access_control).and_return(access_control)
-      allow(access_control).to receive(:controller_permitted?).with("kjasdasd").and_return("_true")
-
-      expect(subject.controller_permitted?("kjasdasd")).to eq("_true")
-    end
-  end
-
-  describe "#access_control" do
-    it "returns cached access control instance" do
-      allow(controller).to receive(:user).and_return("x")
-      access_control = Releaf::Permissions::AccessControl.new(user: user)
-
-      allow(Releaf.application.config.permissions.access_control).to receive(:new).with(user: "x").and_return(access_control)
-      expect(subject.access_control).to eq access_control
-
-      expect(Releaf.application.config.permissions.access_control).to_not receive(:new)
-      expect(subject.access_control).to eq access_control
-    end
-  end
-end

data/spec/builders/releaf/permissions/profile/form_builder_spec.rb

@@ -1,18 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Permissions::Profile::FormBuilder, type: :class do
-  class FormBuilderTestHelper < ActionView::Base; end
-  let(:template){ FormBuilderTestHelper.new(ActionView::LookupContext.new(nil), {}, nil) }
-  let(:object){ Releaf::Permissions::User.new }
-  let(:subject){ described_class.new(:resource, object, template, {}) }
-
-  it "inherits Releaf::Permissions::Users::FormBuilder" do
-    expect(described_class.superclass).to eq(Releaf::Permissions::Users::FormBuilder)
-  end
-
-  describe "#field_names" do
-    it "returns name, surname, locale, email, password and password_confirmation as field names array" do
-      expect(subject.field_names).to eq(%w(name surname locale email password password_confirmation))
-    end
-  end
-end

data/spec/builders/releaf/permissions/roles/form_builder_spec.rb

@@ -1,56 +0,0 @@
-require 'rails_helper'
-
-describe Releaf::Permissions::Roles::FormBuilder, type: :class do
-  class FormBuilderTestHelper < ActionView::Base; end
-  let(:template){ FormBuilderTestHelper.new(ActionView::LookupContext.new(nil), {}, nil) }
-  let(:object){ Releaf::Permissions::Role.new }
-  let(:subject){ described_class.new(:resource, object, template, {}) }
-
-  before do
-    allow(Releaf.application.config).to receive(:available_controllers)
-      .and_return(["releaf/content/nodes", "admin/chapters"])
-
-    definition_1 = Releaf::ControllerDefinition.new("xx")
-    allow(definition_1).to receive(:localized_name).and_return("controller 1")
-    allow(definition_1).to receive(:controller_name).and_return("admin/controller_1")
-
-    definition_2 = Releaf::ControllerDefinition.new("xx")
-    allow(definition_2).to receive(:localized_name).and_return("controller 2")
-    allow(definition_2).to receive(:controller_name).and_return("admin/controller_2")
-
-    allow(Releaf::ControllerDefinition).to receive(:for).with("releaf/content/nodes").and_return(definition_1)
-    allow(Releaf::ControllerDefinition).to receive(:for).with("admin/chapters").and_return(definition_2)
-  end
-
-  describe "#render_default_controller" do
-    it "pass localized controller options to releaf item field" do
-      translated_controllers = {
-        "controller 1" => "admin/controller_1",
-        "controller 2" => "admin/controller_2"
-      }
-
-      allow(subject).to receive(:releaf_item_field)
-        .with(:default_controller, options: {select_options: translated_controllers})
-        .and_return("x")
-      expect(subject.render_default_controller).to eq("x")
-    end
-  end
-
-  describe "#render_permissions" do
-    it "returns associated set field" do
-      options = {association: {items: "x", field: :permission}}
-      allow(subject).to receive(:permission_items).and_return("x")
-      allow(subject).to receive(:releaf_associated_set_field).with(:permissions, options: options).and_return("y")
-      expect(subject.render_permissions).to eq("y")
-    end
-  end
-
-  describe "#permission_items" do
-    it "returns scoped and translated controller values" do
-      expect(subject.permission_items).to eq(
-        "controller.admin/controller_1" => "controller 1",
-        "controller.admin/controller_2" => "controller 2"
-      )
-    end
-  end
-end

data/spec/builders/releaf/permissions/roles/table_builder_spec.rb

@@ -1,41 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Permissions::Roles::TableBuilder, type: :class do
-  class TableBuilderTestHelper < ActionView::Base; end
-  let(:template){ TableBuilderTestHelper.new(ActionView::LookupContext.new(nil), {}, nil) }
-  let(:resource_class){ Releaf::Permissions::Role }
-  let(:subject){ described_class.new([], resource_class, template, {}) }
-
-  describe "#column_names" do
-    it "returns name and default_controller as column names array" do
-      expect(subject.column_names).to eq([:name, :default_controller])
-    end
-  end
-
-  describe "#default_controller_content" do
-    context "when given resource default controller definition exists" do
-      it "returns localized controller name from definitioned followed by application name" do
-        definition = Releaf::ControllerDefinition.new("xx")
-        allow(definition).to receive(:localized_name).and_return("x")
-        allow(Releaf::ControllerDefinition).to receive(:for).with("contr").and_return(definition)
-        expect(subject.default_controller_content(resource_class.new(default_controller: "contr"))).to eq("x")
-      end
-    end
-
-    context "when given resource default controller definition does not exist" do
-      it "returns dash" do
-        definition = Releaf::ControllerDefinition.new("xx")
-        allow(definition).to receive(:localized_name).and_return("x")
-        allow(Releaf::ControllerDefinition).to receive(:for).with("contr").and_return(nil)
-        expect(subject.default_controller_content(resource_class.new(default_controller: "contr"))).to eq("-")
-      end
-    end
-
-    context "when default controller is not defined for given resource" do
-      it "returns dash" do
-        expect(Releaf::ControllerDefinition).to_not receive(:for)
-        expect(subject.default_controller_content(resource_class.new)).to eq("-")
-      end
-    end
-  end
-end

data/spec/builders/releaf/permissions/users/form_builder_spec.rb

@@ -1,23 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Permissions::Users::FormBuilder, type: :class do
-  class FormBuilderTestHelper < ActionView::Base; end
-  let(:template){ FormBuilderTestHelper.new(ActionView::LookupContext.new(nil), {}, nil) }
-  let(:object){ Releaf::Permissions::Role.new }
-  let(:subject){ described_class.new(:resource, object, template, {}) }
-
-  describe "#field_names" do
-    it "returns name, surname, locale, role_id, email, password and password_confirmation as field names array" do
-      expect(subject.field_names).to eq(%w(name surname locale role_id email password password_confirmation))
-    end
-  end
-
-  describe "#render_locale" do
-    it "pass localized controller options to releaf item field" do
-      allow(Releaf.application.config).to receive(:available_admin_locales).and_return(["de", "ze"])
-      allow(subject).to receive(:locale_options).with(["de", "ze"]).and_return(["xx", "yy"])
-      allow(subject).to receive(:releaf_item_field).with(:locale, options: {select_options: ["xx", "yy"]}).and_return("x")
-      expect(subject.render_locale).to eq("x")
-    end
-  end
-end

data/spec/builders/releaf/permissions/users/table_builder_spec.rb

@@ -1,21 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Permissions::Users::TableBuilder, type: :class do
-  class TableBuilderTestHelper < ActionView::Base; end
-  let(:template){ TableBuilderTestHelper.new(ActionView::LookupContext.new(nil), {}, nil) }
-  let(:resource_class){ Releaf::Permissions::User }
-  let(:subject){ described_class.new([], resource_class, template, {}) }
-
-  describe "#column_names" do
-    it "returns name, surname, role, email and locale as column names array" do
-      expect(subject.column_names).to eq([:name, :surname, :role, :email, :locale])
-    end
-  end
-
-  describe "#locale_content" do
-    it "returns translated locale" do
-      allow(subject).to receive(:translate_locale).with("de").and_return("deutch")
-      expect(subject.locale_content(resource_class.new(locale: "de"))).to eq("deutch")
-    end
-  end
-end

data/spec/controllers/permissions/profile_controller_spec.rb

@@ -1,40 +0,0 @@
-require 'rails_helper'
-
-describe Releaf::Permissions::ProfileController do
-  let(:another_role){ FactoryBot.create(:content_role) }
-  let(:user){ subject.current_releaf_permissions_user }
-  login_as_user :user
-
-  describe "#resource_class" do
-    it "returns current releaf user user class" do
-      expect(described_class.new.resource_class).to eq(Releaf::Permissions::User)
-    end
-  end
-
-  describe "PATCH update" do
-    context 'when attributes contain role_id' do
-      it "does not update it" do
-        expect{ patch :update, params: {resource: {role_id: another_role.id}} }.to_not change{ user.role_id }
-      end
-    end
-
-    context 'with allowed attributes' do
-      it "saves new attributes" do
-        attributes = ActionController::Parameters.new({
-          "name" => "new name",
-          "surname" => "new surname",
-          "email" => "new.email@example.com",
-          "locale" => "lv"
-        })
-        attributes.permit!
-
-        # This is needed in order to get same instance as we expect.
-        # Otherwise we'll get same record, but different instance and test will fail
-        allow( user ).to receive(:becomes).with(Releaf::Permissions::User).and_return(user)
-
-        expect(user).to receive(:update).with(attributes)
-        patch :update, params: {resource: attributes}
-      end
-    end
-  end
-end

data/spec/controllers/permissions/users_controller_spec.rb

@@ -1,28 +0,0 @@
-require 'rails_helper'
-
-# use Admin::BooksController as it inherit Releaf::ActionController and
-# have no extra methods or overrides
-describe Releaf::Permissions::UsersController do
-  before do
-    sign_in FactoryBot.create(:user)
-  end
-
-  describe "GET #new" do
-    it "assigns default role" do
-      get :new
-      expect(assigns(:resource).role).to eq(Releaf::Permissions::Role.first)
-    end
-  end
-
-  describe "GET #index" do
-    before do
-      FactoryBot.create(:content_user, name: "John")
-      FactoryBot.create(:content_user, name: "Bill", surname: "Green", email: "another@example.com")
-    end
-
-    it "searches by name, surname and email" do
-      get :index, params: {search: "bill green another@example"}
-      expect(assigns(:collection).count).to eq(1)
-    end
-  end
-end

data/spec/features/profile_updating_spec.rb

@@ -1,35 +0,0 @@
-require 'rails_helper'
-feature "User profile" do
-  background do
-    auth_as_user(false, FactoryBot.create(:user, email: "email@example.com"))
-    visit releaf_permissions_user_profile_path
-  end
-
-  scenario "name, surname and locale" do
-    fill_in 'Name',    with: "Edward"
-    fill_in 'Surname', with: "Bat"
-    select "Lv", from: "Locale"
-    click_button 'Save'
-
-    expect(page).to have_css('header .profile .name', text: "Edward Bat")
-  end
-
-  scenario "password and email" do
-    # update
-    fill_in 'Email', with:  "new.email@example.com"
-    fill_in 'Password', with:  "newpassword123", match: :prefer_exact
-    fill_in 'Password confirmation', with:  "newpassword123", match: :prefer_exact
-    click_button 'Save'
-
-    # logout
-    find('body > header form.sign-out button').click
-
-    # login
-    visit releaf_root_path
-    fill_in 'Email',    with:  "new.email@example.com"
-    fill_in 'Password', with:  "newpassword123"
-    click_button 'Sign in'
-
-    expect(page).to have_css('.sign-out')
-  end
-end

data/spec/features/roles_spec.rb

@@ -1,64 +0,0 @@
-require 'rails_helper'
-feature "Roles management", js: true do
-  background do
-    auth_as_user
-    @role = Releaf::Permissions::Role.first
-  end
-
-  scenario "Role search", focus: true do
-    create(:admin_role, name: 'super role')
-    visit releaf_permissions_roles_path
-    expect(page).to have_content @role.name
-    expect(page).to have_content 'super role'
-    search "super"
-    expect(page).to have_no_content @role.name
-    expect(page).to have_content 'super role'
-  end
-
-  scenario "User creates a new role" do
-    visit releaf_permissions_roles_path
-    create_resource do
-      fill_in("Name", with: "second role")
-      select('Admin/nodes', from: 'Default controller')
-    end
-    visit releaf_permissions_roles_path
-    expect(page).to have_content "second role"
-  end
-
-  scenario "User updates an existing role" do
-    visit releaf_permissions_roles_path
-    click_link @role.name
-    update_resource do
-      fill_in("Name", with: "new name")
-    end
-
-    visit releaf_permissions_roles_path
-    expect(page).to have_content "new name"
-  end
-
-  scenario "User changes the default controller of a role" do
-    visit releaf_permissions_roles_path
-    click_link @role.name
-    update_resource do
-      select('Admin/books', from: 'Default controller')
-    end
-
-    expect(page).to have_select('Default controller', selected: 'Admin/books')
-  end
-
-  scenario "User changes permissions of a role controller" do
-    visit releaf_permissions_roles_path
-    click_link @role.name
-    update_resource do
-      uncheck('Admin/books')
-    end
-
-    Releaf.application.config.available_controllers.each do |controller|
-      if controller == "admin/books"
-        expect(page).to have_unchecked_field(I18n.t(controller))
-      else
-        expect(page).to have_checked_field(I18n.t(controller))
-      end
-    end
-  end
-end

data/spec/features/users_spec.rb

@@ -1,107 +0,0 @@
-require 'rails_helper'
-feature "Users", js: true do
-  let!(:user){ create(:user, email: "admin@example.com") }
-  let!(:simple_user){ create(:content_user, email: "simple@example.com") }
-
-  describe "users CRUD" do
-    background do
-      visit "/admin"
-      within("form.login") do
-        fill_in 'Email', with: user.email
-        fill_in 'Password', with: user.password
-      end
-      click_button 'Sign in'
-      expect(page).to have_css('body > header form.sign-out button')
-    end
-
-    scenario "new user creation", js: true do
-      visit releaf_permissions_users_path
-      create_resource do
-        fill_in 'Name', with: "John"
-        fill_in 'Surname', with: "Appleseed"
-        fill_in 'Email', with: "john@example.com"
-        fill_in 'Password', with: "password", match: :prefer_exact
-        fill_in 'Password confirmation', with: "password", match: :prefer_exact
-
-        expect(page).to have_select('Locale', options: ["", "En", "Lv"])
-        select 'En', from: 'Locale'
-      end
-
-      expect(page).to have_content 'John Appleseed'
-      visit '/admin/users'
-      expect(page).to have_content 'john@example.com'
-
-      visit (releaf_permissions_users_path)
-      open_toolbox_dialog("Delete", Releaf::Permissions::User.last)
-      click_button 'Yes'
-      expect(page).not_to have_content 'john@example.com'
-    end
-
-    scenario "user search" do
-      visit '/admin/users'
-      expect(page).to have_content 'simple@example.com'
-      search "admin@example.com"
-      expect(page).not_to have_content 'simple@example.com'
-    end
-  end
-
-  describe "login as user procedure" do
-    background do
-      visit "/admin"
-      within("form.login") do
-        fill_in 'Email', with: user.email
-        fill_in 'Password', with: user.password
-      end
-      click_button 'Sign in'
-    end
-
-    scenario "user page content" do
-      expect(page).to have_css('body > header form.sign-out button')
-      expect(page).to have_content 'Admin/nodes'
-      expect(page).to have_content 'Permissions'
-      expect(page).to have_content 'Releaf/i18n database/translations'
-      # admin/users index view
-      expect(page).to have_content 'admin@example.com'
-      expect(page).to have_content 'simple@example.com'
-    end
-
-    scenario "logout sequence" do
-      find('body > header form.sign-out button').click
-
-      expect(page).to have_content 'Welcome to Releaf'
-
-      visit "/admin"
-      expect(page).to have_content 'Sign in'
-    end
-  end
-
-  describe "login as simple user procedure" do
-    background do
-      visit "/admin"
-      within("form.login") do
-        fill_in 'Email', with: simple_user.email
-        fill_in 'Password', with: simple_user.password
-      end
-      click_button 'Sign in'
-    end
-
-    scenario "user page content" do
-      expect(page).to have_css('body > header form.sign-out button')
-      expect(page).to have_content 'Admin/nodes'
-    end
-
-    scenario "translations module access denied" do
-      visit "/admin/translations"
-      expect(page).to have_content 'You are not authorized to access translations'
-    end
-
-    scenario "logout sequence" do
-      find('body > header form.sign-out button').click
-
-      expect(page).to have_content 'Welcome to Releaf'
-
-      visit "/admin"
-      expect(page).to have_content 'Sign in'
-    end
-  end
-end

data/spec/lib/access_control_spec.rb

@@ -1,66 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Permissions::AccessControl do
-  let(:role){ Releaf::Permissions::Role.new }
-  let(:user){ Releaf::Permissions::User.new(role: role) }
-  subject{ described_class.new(user: user) }
-
-
-  describe "#controller_permitted?" do
-    context "when allowed controllers contains given controller" do
-      it "returns true" do
-        allow(subject).to receive(:allowed_controllers).and_return(["a", "b"])
-        expect(subject.controller_permitted?("a")).to be true
-      end
-    end
-
-    context "when allowed controllers does not contain given controller" do
-      it "returns false" do
-        allow(subject).to receive(:allowed_controllers).and_return(["c", "b"])
-        expect(subject.controller_permitted?("a")).to be false
-      end
-    end
-  end
-
-  describe "#allowed_controllers" do
-    it "returns array with permanent allowed controllers and role allowed controllers" do
-      allow(subject).to receive(:permanent_allowed_controllers).and_return(["a", "b"])
-      allow(subject).to receive(:role_allowed_controllers).and_return(["c", "d"])
-      expect(subject.allowed_controllers).to eq(%w(a b c d))
-    end
-  end
-
-  describe "#permanent_allowed_controllers" do
-    it "returns array with permanent allowed controllers" do
-      allow(Releaf.application.config.permissions).to receive(:permanent_allowed_controllers).and_return("x")
-      expect(subject.permanent_allowed_controllers).to eq("x")
-    end
-  end
-
-  describe "#role_allowed_controllers" do
-    it "returns array of roles allowed controllers" do
-      role.permissions.build(permission: "controller.a")
-      role.permissions.build(permission: "controller.x")
-      role.permissions.build(permission: "export.some_data")
-      allow(subject).to receive(:controller_name_from_permission).with("controller.a").and_return(nil)
-      allow(subject).to receive(:controller_name_from_permission).with("controller.x").and_return("asd")
-      allow(subject).to receive(:controller_name_from_permission).with("export.some_data").and_return("fd")
-
-      expect(subject.role_allowed_controllers).to match_array(["asd", "fd"])
-    end
-  end
-
-  describe "#controller_name_from_permission" do
-    context "when given permission contains `controller`" do
-      it "returns name" do
-        expect(subject.controller_name_from_permission("controller.a")).to eq("a")
-      end
-    end
-
-    context "when given permission does not contain `controller`" do
-      it "returns nil" do
-        expect(subject.controller_name_from_permission("aasd.a")).to be nil
-      end
-    end
-  end
-end

data/spec/lib/releaf/permissions/configuration_spec.rb

@@ -1,38 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Permissions::Configuration do
-  subject{ described_class.new(devise_for: "asd", access_control: "X", permanent_allowed_controllers: [1, 2]) }
-
-  it do
-    is_expected.to have_attributes(devise_for: "asd")
-    is_expected.to have_attributes(access_control: "X")
-    is_expected.to have_attributes(permanent_allowed_controllers: [1, 2])
-  end
-
-  describe "#devise_model_name" do
-    it "returns devise model name with slashes replaced by underscores" do
-      subject.devise_for = "releaf/permissions/user"
-      expect(subject.devise_model_name).to eq("releaf_permissions_user")
-    end
-  end
-
-  describe "#devise_model_class" do
-    it "returns devise model class" do
-      subject.devise_for = "releaf/permissions/role"
-      expect(subject.devise_model_class).to eq(Releaf::Permissions::Role)
-    end
-  end
-
-  describe ".configure_component" do
-    it "adds `Releaf::Permissions::Configuration` configuration with devise, access_control and permanent allowed controllers configured" do
-      allow(Releaf::Permissions::Configuration).to receive(:new)
-        .with(
-          devise_for: "releaf/permissions/user",
-          access_control: Releaf::Permissions::AccessControl,
-          permanent_allowed_controllers: ["releaf/root"]
-      ).and_return("_new")
-      expect(Releaf.application.config).to receive(:add_configuration).with("_new")
-      described_class.configure_component
-    end
-  end
-end

data/spec/lib/releaf/permissions/controller_support_spec.rb

@@ -1,76 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Permissions::ControllerSupport do
-  let(:user){ Releaf::Permissions::User.new(locale: "de") }
-
-  class AcessControllDummyController < Releaf::ActionController
-    include Releaf::Permissions::ControllerSupport
-  end
-
-  subject{ AcessControllDummyController.new }
-
-  before do
-    allow(subject).to receive(:current_releaf_permissions_user).and_return(user)
-  end
-
-  describe "before filters" do
-    it "prepends `:authenticate!, :verify_controller_access!, :set_locale` before filters" do
-      all_before_actions = subject._process_action_callbacks.select{|f| f.kind == :before}.map{|f| f.filter }
-      expect(all_before_actions).to start_with(:authenticate!, :verify_controller_access!, :set_locale)
-    end
-  end
-
-  describe "#set_locale" do
-    it "assigns user locale to I18n locale" do
-      expect(I18n).to receive(:locale=).with("de")
-      subject.set_locale
-    end
-  end
-
-  describe "#verify_controller_access!" do
-    let(:access_control){ Releaf::Permissions::AccessControl.new(user: user) }
-
-    before do
-      allow(subject).to receive(:short_name).and_return("some_controller")
-      allow(Releaf.application.config.permissions.access_control).to receive(:new)
-        .with(user: user).and_return(access_control)
-    end
-
-    context "when controller is not permitted" do
-      it "raises `Releaf::AccessDenied exception`" do
-        allow(access_control).to receive(:controller_permitted?).with("some_controller").and_return(false)
-        expect{ subject.verify_controller_access! }.to raise_error(Releaf::AccessDenied)
-      end
-    end
-
-    context "when controller is permitted" do
-      it "does not raise `Releaf::AccessDenied exception`" do
-        allow(access_control).to receive(:controller_permitted?).with("some_controller").and_return(true)
-        expect{ subject.verify_controller_access! }.to_not raise_error
-      end
-    end
-  end
-
-  describe "#user" do
-    it "returns current controller devise user instance" do
-      expect(subject.user).to eq(user)
-    end
-  end
-
-  describe "#authorized?" do
-    it "returns whether devise has signed in current user" do
-      allow(subject).to receive(:releaf_permissions_user_signed_in?).and_return(true)
-      expect(subject.authorized?).to be true
-
-      allow(subject).to receive(:releaf_permissions_user_signed_in?).and_return(false)
-      expect(subject.authorized?).to be false
-    end
-  end
-
-  describe "#authenticate!" do
-    it "returns whether devise has signed in current user" do
-      expect(subject).to receive(:authenticate_releaf_permissions_user!)
-      subject.authenticate!
-    end
-  end
-end

data/spec/lib/releaf/permissions/default_controller_resolver_spec.rb

@@ -1,49 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Permissions::DefaultControllerResolver do
-  subject{ described_class.new(current_controller: Releaf::RootController.new) }
-
-  it "inherit `Releaf::Root::DefaultControllerResolver`" do
-    expect(described_class.ancestors.include?(Releaf::Root::DefaultControllerResolver)).to be true
-  end
-
-  describe ".configure_component" do
-    it "adds itself as default controller resolver" do
-      expect(Releaf.application.config.root).to receive(:default_controller_resolver=).with(described_class)
-      described_class.configure_component
-    end
-  end
-
-  describe "#controllers" do
-    it "returns user available controllers with role default controller as first" do
-      role = Releaf::Permissions::Role.new(default_controller: "a")
-      user = Releaf::Permissions::User.new(role: role)
-      allow(Releaf.application.config).to receive(:available_controllers).and_return(["a", "b", "c"])
-      allow(subject).to receive(:user).and_return(user)
-
-      allow(subject).to receive(:allowed_controllers).and_return(["a", "c", "d"])
-      expect(subject.controllers).to eq(["a", "c"])
-
-      allow(subject).to receive(:allowed_controllers).and_return(["c", "d"])
-      expect(subject.controllers).to eq(["c"])
-    end
-  end
-
-  describe "#allowed_controllers" do
-    it "returns allowed controllers from access contro for given user" do
-      allow(subject).to receive(:user).and_return("_user")
-      access_control = Releaf::Permissions::AccessControl.new(user: Releaf::Permissions::User.new)
-      allow(access_control).to receive(:allowed_controllers).and_return(["a", "d"])
-      allow(Releaf.application.config.permissions.access_control).to receive(:new).with(user: "_user").and_return(access_control)
-
-      expect(subject.allowed_controllers).to eq(["a", "d"])
-    end
-  end
-
-  describe "#user" do
-    it "returns controller user" do
-      allow(subject.current_controller).to receive(:user).and_return("_user")
-      expect(subject.user).to eq("_user")
-    end
-  end
-end

data/spec/lib/releaf/permissions/layout_spec.rb

@@ -1,10 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Permissions::Layout do
-  describe ".configure_component" do
-    it "changes layout_builder_class_name to `Releaf::Permissions::Page::LayoutBuilder`" do
-      expect(Releaf.application.config).to receive(:layout_builder_class_name=).with("Releaf::Permissions::Page::LayoutBuilder")
-      described_class.configure_component
-    end
-  end
-end

data/spec/lib/releaf/permissions/profile_spec.rb

@@ -1,11 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Permissions::Profile do
-  describe ".configure_component" do
-    it "adds `releaf/permissions/profile` to additional controllers" do
-      expect(Releaf.application.config).to receive(:additional_controllers).and_return(["a", "b"])
-      expect(Releaf.application.config).to receive(:additional_controllers=).with(["a", "b", "releaf/permissions/profile"])
-      described_class.configure_component
-    end
-  end
-end

data/spec/lib/releaf/permissions/roles_spec.rb

@@ -1,10 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Permissions::Roles do
-  describe ".draw_component_routes" do
-    it "register roles resource route" do
-      expect(described_class).to receive(:resource_route).with("_router", :permissions, :roles)
-      described_class.draw_component_routes("_router")
-    end
-  end
-end

data/spec/lib/releaf/permissions/settings_manager_spec.rb

@@ -1,38 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Permissions::SettingsManager do
-  let(:controller){ Releaf::RootController.new }
-  let(:user){ Releaf::Permissions::User.new }
-
-  before do
-    allow(user.settings).to receive(:[]).with("asd.a").and_return("lalal")
-    allow(controller).to receive(:user).and_return(user)
-  end
-
-  describe ".configure_component" do
-    it "registers itself as settings manager" do
-      expect(Releaf.application.config).to receive(:settings_manager=).and_return(described_class)
-      described_class.configure_component
-    end
-  end
-
-  describe ".read" do
-    it "returns user settings for given key" do
-      expect(described_class.read(controller: controller, key: "asd.a")).to eq("lalal")
-    end
-
-    context "when controller has no user method" do
-      it "returns nil" do
-        allow(controller).to receive(:respond_to?).with(:user).and_return(false)
-        expect(described_class.read(controller: controller, key: "asd.a")).to be nil
-      end
-    end
-  end
-
-  describe ".write" do
-    it "writes user settings for given key and value" do
-      expect(user.settings).to receive(:[]=).with("asd.a", "op")
-      described_class.write(controller: controller, key: "asd.a", value: "op")
-    end
-  end
-end

data/spec/lib/releaf/permissions/users_spec.rb

@@ -1,17 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Permissions::Users do
-  describe ".configure_component" do
-    it "sets `releaf/permissions/user` as devise model" do
-      expect(Releaf.application.config.permissions).to receive(:devise_for=).with("releaf/permissions/user")
-      described_class.configure_component
-    end
-  end
-
-  describe ".draw_component_routes" do
-    it "register users resource route" do
-      expect(described_class).to receive(:resource_route).with("_router", :permissions, :users)
-      described_class.draw_component_routes("_router")
-    end
-  end
-end

data/spec/models/permissions/role_spec.rb

@@ -1,13 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Permissions::Role do
-  describe 'validations' do
-    it { is_expected.to validate_presence_of(:name) }
-    it { is_expected.to validate_presence_of(:default_controller) }
-    it { subject.name = "x"; is_expected.to validate_uniqueness_of(:name).case_insensitive }
-  end
-
-  describe 'associations' do
-    it { is_expected.to have_many(:users).dependent(:restrict_with_exception) }
-  end
-end

data/spec/models/permissions/user_spec.rb

@@ -1,53 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Permissions::User do
-  describe 'validations' do
-    it { is_expected.to validate_presence_of(:name) }
-    it { is_expected.to validate_presence_of(:surname) }
-    it { is_expected.to validate_presence_of(:role) }
-    it { is_expected.to validate_presence_of(:locale) }
-    it { is_expected.to validate_presence_of(:email) }
-    it { create(:user); is_expected.to validate_uniqueness_of(:email).case_insensitive }
-  end
-
-  describe 'associations' do
-    it { is_expected.to belong_to(:role) }
-  end
-
-  describe "#releaf_title" do
-    it "returns concated name and surname" do
-      subject.name = "John"
-      subject.surname = "Baum"
-      expect(subject.releaf_title).to eq("John Baum")
-    end
-  end
-
-  describe "#password_required?" do
-    context "when existing record" do
-      before do
-        allow(subject).to receive(:new_record?).and_return(false)
-      end
-
-      context "when new password is blank" do
-        it "returns true" do
-          allow(subject).to receive(:encrypted_password).and_return("")
-          expect(subject.password_required?).to be true
-        end
-      end
-
-      context "when new password is not blank" do
-        it "returns false" do
-          allow(subject).to receive(:encrypted_password).and_return("asdasd")
-          expect(subject.password_required?).to be false
-        end
-      end
-    end
-
-    context "when new record" do
-      it "returns true" do
-        allow(subject).to receive(:new_record?).and_return(true)
-        expect(subject.password_required?).to be true
-      end
-    end
-  end
-end