releaf-core 2.0.0 → 2.0.1

data/spec/lib/releaf/resource_fields_spec.rb

@@ -1,12 +0,0 @@
-require "rails_helper"
-
-describe Releaf::ResourceFields do
-  subject{ described_class.new(Book) }
-
-  describe "#excluded_attributes" do
-    it "returns array with excluded attributes" do
-      expect(subject.excluded_attributes)
-        .to eq(%w(id created_at updated_at password password_confirmation encrypted_password))
-    end
-  end
-end

data/spec/lib/releaf/resource_params_spec.rb

@@ -1,115 +0,0 @@
-require "rails_helper"
-
-describe Releaf::ResourceParams do
-  subject{ described_class.new(Book) }
-
-  describe "#file_attributes" do
-    it "returns list with file attributes" do
-      expect(subject.file_attributes).to eq(["cover_image_uid"])
-
-      subject.resource_class = Node
-      expect(subject.file_attributes).to eq([])
-    end
-  end
-
-  describe "#file_attribute?" do
-    context "when given attribute exists within file attributes" do
-      it "returns true" do
-        allow(subject).to receive(:file_attributes).and_return(["color"])
-        expect(subject.file_attribute?("color")).to be true
-      end
-    end
-
-    context "when given attribute does not exist within file attributes" do
-      it "returns false" do
-        allow(subject).to receive(:file_attributes).and_return(["size"])
-        expect(subject.file_attribute?("color")).to be false
-      end
-    end
-  end
-
-  describe "#file_attribute_params" do
-    it "returns array with dragonfly specific attributes" do
-      expect(subject.file_attribute_params("cover_image_uid"))
-        .to eq(["cover_image", "retained_cover_image", "remove_cover_image"])
-    end
-  end
-
-  describe "#localized_attributes" do
-    it "returns array of all localized attributes params" do
-      allow(subject.resource_class).to receive(:translated_attribute_names).and_return(["title", "summary"])
-      allow(subject).to receive(:localized_attribute_params).with("title").and_return(["t1", "t2"])
-      allow(subject).to receive(:localized_attribute_params).with("summary").and_return(["s1", "s2"])
-      expect(subject.localized_attributes).to eq(["t1", "t2", "s1", "s2"])
-
-      allow(subject.resource_class).to receive(:translated_attribute_names).and_return([])
-      subject.instance_variable_set("@localized_attributes", nil) # reset cached values
-      expect(subject.localized_attributes).to eq([])
-    end
-  end
-
-  describe "#localized_attribute_params" do
-    it "returns array with localized attribute within all specified locales" do
-      expect(subject.localized_attribute_params(:description)).to eq(["description_en", "description_lv"])
-
-      allow(subject.resource_class).to receive(:globalize_locales).and_return(["de"])
-      expect(subject.localized_attribute_params(:description)).to eq(["description_de"])
-    end
-  end
-
-  describe "#base_attributes" do
-    it "returns array with base and file attributes" do
-      allow(subject.resource_class).to receive(:column_names).and_return(["a", "b", "c"])
-      allow(subject).to receive(:file_attribute?).and_return(false)
-      expect(subject.base_attributes).to eq(["a", "b", "c"])
-
-      allow(subject).to receive(:file_attribute?).with("b").and_return(true)
-      allow(subject).to receive(:file_attribute_params).with("b").and_return(["b1", "b2"])
-      expect(subject.base_attributes).to eq(["a", "b1", "b2", "c"])
-    end
-  end
-
-  describe "#values" do
-    before do
-      allow(subject).to receive(:associations_attributes).and_return(["x", "y"])
-    end
-
-    it "returns resource params array alongside associations params" do
-      allow(subject).to receive(:base_attributes).and_return(["a", "b"])
-      allow(subject).to receive(:localized_attributes?).and_return(false)
-      expect(subject.values).to eq(["a", "b", "x", "y"])
-    end
-
-    context "when resource has localized attributes" do
-      it "returns resource params array alongside localized attributes" do
-        allow(subject).to receive(:base_attributes).and_return(["a", "b"])
-        allow(subject).to receive(:localized_attributes?).and_return(true)
-        allow(subject).to receive(:localized_attributes).and_return(["c", "d"])
-        expect(subject.values).to eq(["a", "b", "c", "d", "x", "y"])
-      end
-    end
-  end
-
-  describe "#associations_attributes" do
-    it "returns array with associations params within hashes" do
-      association_1 = subject.resource_class.reflections["chapters"]
-      association_2 = subject.resource_class.reflections["sequels"]
-
-      allow(subject).to receive(:associations).and_return([association_1, association_2])
-      allow(subject).to receive(:association_attributes).with(association_1).and_return(["a", "b"])
-      allow(subject).to receive(:association_attributes).with(association_2).and_return(["c", "d"])
-
-      expect(subject.associations_attributes).to eq([{"chapters_attributes"=>["a", "b"]}, {"sequels_attributes"=>["c", "d"]}])
-    end
-  end
-
-  describe "#association_attributes" do
-    it "returns association params with `id` and `_destroy` params and without `foreign_key` param" do
-      association = subject.resource_class.reflections["chapters"]
-      allow(association).to receive(:foreign_key).and_return("b")
-      allow(described_class).to receive(:new).with(association.klass).and_call_original
-      allow_any_instance_of(described_class).to receive(:values).and_return(["a", "b", "c"])
-      expect(subject.association_attributes(association)).to eq(["a", "c", "id", "_destroy"])
-    end
-  end
-end

data/spec/lib/releaf/resource_table_fields_spec.rb

@@ -1,20 +0,0 @@
-require "rails_helper"
-
-describe Releaf::ResourceTableFields do
-  subject{ described_class.new(Book) }
-
-  describe "#excluded_attributes" do
-    it "returns attributes to exclude from table alongside parent method list" do
-      allow(subject).to receive(:table_excluded_attributes).and_return(%w(xxx yyy))
-      expect(subject.excluded_attributes).to include("id", "created_at", "xxx", "yyy")
-    end
-  end
-
-  describe "#table_excluded_attributes" do
-    it "returns array with all base and localized attributes matching *_html and *_uid pattern" do
-      allow(subject).to receive(:localized_attributes).and_return(["color", "body_html", "some_uid"])
-      allow(subject).to receive(:base_attributes).and_return(["image_uid", "title", "price", "description_html"])
-      expect(subject.table_excluded_attributes).to eq(%w(image_uid description_html body_html some_uid))
-    end
-  end
-end

data/spec/lib/releaf/resource_utilities_spec.rb

@@ -1,87 +0,0 @@
-require "rails_helper"
-
-describe Releaf::ResourceUtilities do
-  let(:resource){ Releaf::Permissions::Role.new }
-  let(:users_association){ resource.class.reflect_on_association(:users) }
-  let(:permissions_association){ resource.class.reflect_on_association(:permissions) }
-
-  describe ".restricted_associations" do
-    it "returns hash with restricted association objects and controller" do
-      allow(described_class).to receive(:restricted_associations).with(resource).and_return([permissions_association, users_association])
-      allow(described_class).to receive(:association_controller).with(users_association).and_return("aa")
-      allow(described_class).to receive(:association_controller).with(permissions_association).and_return("bb")
-      resource.users.build
-      resource.permissions.build
-
-      expect(described_class.restricted_relations(resource)).to eq(
-        users: {objects: resource.users, controller: "aa"},
-        permissions: {objects: resource.permissions, controller: "bb"},
-      )
-    end
-  end
-
-  describe ".association_controller" do
-    it "returns guessed controller from given association name" do
-      expect(described_class.association_controller(users_association)).to eq("users")
-    end
-
-    context "when no controller guessed" do
-      it "returns nil" do
-        expect(described_class.association_controller(permissions_association)).to be nil
-      end
-    end
-  end
-
-  describe ".restricted_associations" do
-    it "returns array with restricted associations" do
-      allow(described_class).to receive(:restricted_association?).with(resource, users_association).and_return(false)
-      allow(described_class).to receive(:restricted_association?).with(resource, permissions_association).and_return(true)
-      expect(described_class.restricted_associations(resource)).to eq([permissions_association])
-    end
-  end
-
-  describe ".restricted_association?" do
-    context "when associations with dependent option `restrict_with_exception` given" do
-      let(:association){ resource.class.reflect_on_association(:users) }
-
-      context "when association object(-s) exists" do
-        it "returns true" do
-          resource.users.build
-          users = resource.users
-          allow(resource).to receive(:users).and_return(users)
-          allow(users).to receive(:exists?).and_return(true)
-          expect(described_class.restricted_association?(resource, association)).to be true
-        end
-      end
-
-      context "when association object(-s) does not exist" do
-        it "returns false" do
-          expect(described_class.restricted_association?(resource, association)).to be false
-        end
-      end
-    end
-
-    context "when associations with dependent option other than `restrict_with_exception` given" do
-      it "returns false" do
-        association = resource.class.reflect_on_association(:permissions)
-        expect(described_class.restricted_association?(resource, association)).to be false
-      end
-    end
-  end
-
-  describe ".destroyable?" do
-    context "when no restricted association" do
-      it "returns true" do
-        allow(described_class).to receive(:restricted_associations).with(resource).and_return([])
-        expect(described_class.destroyable?(resource)).to be true
-      end
-    end
-
-    context "when restricted association exist" do
-      it "returns false" do
-        allow(described_class).to receive(:restricted_associations).with(resource).and_return([:a])
-        expect(described_class.destroyable?(resource)).to be false
-      end
-    end
-  end
-end

data/spec/lib/releaf/responders/access_denied_responder_spec.rb

@@ -1,12 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Responders::AccessDeniedResponder, type: :controller do
-  controller{}
-  subject{ described_class.new(controller, []) }
-
-  describe "#status_code" do
-    it "returns 404" do
-      expect(subject.status_code).to eq(403)
-    end
-  end
-end

data/spec/lib/releaf/responders/after_save_responder_spec.rb

@@ -1,88 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Responders::AfterSaveResponder, type: :controller do
-  let(:controller){ Releaf::ActionController.new }
-  let(:resource){ Book.new}
-  subject{ described_class.new(controller, [resource]) }
-
-  describe "#json_resource_errors" do
-    it "returns resource errors hash built with `Releaf::BuildErrorsHash`" do
-      allow(Releaf::BuildErrorsHash).to receive(:call).with(resource: resource, field_name_prefix: :resource)
-        .and_return(a: "b")
-      expect(subject.json_resource_errors).to eq(errors: {a: "b"})
-    end
-  end
-
-  describe "#render_notification?" do
-    before do
-      allow(subject).to receive(:has_errors?).and_return(true)
-      allow(subject).to receive(:format).and_return(:json)
-    end
-
-    context "when request format is other json" do
-      it "returns true" do
-        allow(subject).to receive(:format).and_return(:html)
-        expect(subject.render_notification?).to be true
-      end
-    end
-
-    context "when object has no errors" do
-      it "returns true" do
-        allow(subject).to receive(:has_errors?).and_return(false)
-        expect(subject.render_notification?).to be true
-      end
-    end
-
-    context "when request format is json and object has errors" do
-      it "returns false" do
-        expect(subject.render_notification?).to be false
-      end
-    end
-  end
-
-  describe "#respond" do
-    before do
-      allow(subject).to receive(:to_html)
-    end
-
-    context "when render notifications return `true`" do
-      it "renders notification with success value true/false whether resource has errors" do
-        allow(subject).to receive(:render_notification?).and_return(true)
-        allow(subject).to receive(:has_errors?).and_return(true)
-        expect(subject.controller).to receive(:render_notification).with(false)
-        subject.respond
-
-        allow(subject).to receive(:has_errors?).and_return(false)
-        expect(subject.controller).to receive(:render_notification).with(true)
-        subject.respond
-      end
-    end
-
-    context "when render notifications return `false`" do
-      it "does not render notification" do
-        allow(subject).to receive(:render_notification?).and_return(false)
-        expect(subject.controller).to_not receive(:render_notification)
-        subject.respond
-      end
-    end
-  end
-
-  describe "#to_json" do
-    context "when resource has errors" do
-      it "calls `display_errors`" do
-        allow(subject).to receive(:has_errors?).and_return(true)
-        expect(subject).to receive(:display_errors)
-        subject.to_json
-      end
-    end
-
-    context "when resource has no errors" do
-      it "redirects to resource location with status code `303`" do
-        allow(subject).to receive(:resource_location).and_return("some_url")
-        allow(subject).to receive(:has_errors?).and_return(false)
-        expect(subject).to receive(:redirect_to).with("some_url", status: 303, turbolinks: false)
-        subject.to_json
-      end
-    end
-  end
-end

data/spec/lib/releaf/responders/confirm_destroy_responder_spec.rb

@@ -1,26 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Responders::ConfirmDestroyResponder, type: :controller do
-  let(:controller){ Releaf::ActionController.new }
-  let(:resource){ Book.new}
-  subject{ described_class.new(controller, [resource]) }
-
-  describe "#to_html" do
-    context "when options has key :destroyable with `true` value" do
-      it "renders default view" do
-        allow(subject).to receive(:options).and_return(destroyable: true)
-        expect(subject).to receive(:default_render)
-        subject.to_html
-      end
-    end
-
-    context "when options has key :destroyable with `false` value" do
-      it "renders `refused_destroy` template" do
-        allow(subject).to receive(:options).and_return(destroyable: false)
-        expect(subject).to receive(:render).with("refused_destroy")
-        subject.to_html
-      end
-    end
-  end
-end
-

data/spec/lib/releaf/responders/destroy_responder_spec.rb

@@ -1,30 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Responders::DestroyResponder, type: :controller do
-  let(:controller){ Releaf::ActionController.new }
-  let(:resource){ Book.new}
-  subject{ described_class.new(controller, [resource]) }
-
-  describe "#to_html" do
-    before do
-      allow(controller).to receive(:request).and_return(request)
-      allow(controller).to receive(:formats).and_return([:html])
-      allow(subject).to receive(:default_render)
-    end
-
-    context "when resource has been successfully destroyed" do
-      it "renders success notification" do
-        resource.destroy
-        expect(subject.controller).to receive(:render_notification).with(true, failure_message_key: "cant destroy, because relations exists")
-        subject.to_html
-      end
-    end
-
-    context "when resource has not been destroyed" do
-      it "renders failure notification" do
-        expect(subject.controller).to receive(:render_notification).with(false, failure_message_key: "cant destroy, because relations exists")
-        subject.to_html
-      end
-    end
-  end
-end

data/spec/lib/releaf/responders/error_responder_spec.rb

@@ -1,26 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Responders::ErrorResponder, type: :controller do
-  class Releaf::Responders::DummyErrorResponder < ActionController::Responder
-    include Releaf::Responders::ErrorResponder
-    def status_code
-      401
-    end
-  end
-
-  controller{}
-  subject{ Releaf::Responders::DummyErrorResponder.new(controller, []) }
-
-  describe "#template" do
-    it "returns template based on class name" do
-      expect(subject.template).to eq("dummy_error")
-    end
-  end
-
-  describe "#to_html" do
-    it "renders error template with class status code" do
-      expect(subject).to receive(:render).with("releaf/error_pages/dummy_error", status: 401)
-      subject.to_html
-    end
-  end
-end

data/spec/lib/releaf/responders/feature_disabled_responder_spec.rb

@@ -1,12 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Responders::FeatureDisabledResponder, type: :controller do
-  controller{}
-  subject{ described_class.new(controller, []) }
-
-  describe "#status_code" do
-    it "returns 404" do
-      expect(subject.status_code).to eq(403)
-    end
-  end
-end

data/spec/lib/releaf/responders/page_not_found_responder_spec.rb

@@ -1,12 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Responders::PageNotFoundResponder, type: :controller do
-  controller{}
-  subject{ described_class.new(controller, []) }
-
-  describe "#status_code" do
-    it "returns 404" do
-      expect(subject.status_code).to eq(404)
-    end
-  end
-end