releaf-core 0.2.1 → 1.0.3

data/spec/lib/releaf/{core/resource_params_spec.rb → resource_params_spec.rb}

@@ -1,6 +1,6 @@
 require "rails_helper"
 
-describe Releaf::Core::ResourceParams do
+describe Releaf::ResourceParams do
   subject{ described_class.new(Book) }
 
   describe "#file_attributes" do
@@ -43,6 +43,7 @@ describe Releaf::Core::ResourceParams do
       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
@@ -57,7 +58,7 @@ describe Releaf::Core::ResourceParams do
   end
 
   describe "#base_attributes" do
-    it "returns array with non-excluded and file 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"])
@@ -65,9 +66,6 @@ describe Releaf::Core::ResourceParams do
       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"])
-
-      allow(subject).to receive(:excluded_attributes).and_return(["a"])
-      expect(subject.base_attributes).to eq(["b1", "b2", "c"])
     end
   end
 

data/spec/lib/releaf/resource_table_fields_spec.rb

@@ -0,0 +1,20 @@
+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/{core/resource_utilities_spec.rb → resource_utilities_spec.rb}

@@ -1,6 +1,6 @@
 require "rails_helper"
 
-describe Releaf::Core::ResourceUtilities do
+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) }

data/spec/lib/releaf/{core/responders → responders}/access_denied_responder_spec.rb

@@ -1,6 +1,6 @@
 require "rails_helper"
 
-describe Releaf::Core::Responders::AccessDeniedResponder, type: :controller do
+describe Releaf::Responders::AccessDeniedResponder, type: :controller do
   controller{}
   subject{ described_class.new(controller, []) }
 

data/spec/lib/releaf/{core/responders → responders}/after_save_responder_spec.rb

@@ -1,13 +1,14 @@
 require "rails_helper"
 
-describe Releaf::Core::Responders::AfterSaveResponder, type: :controller do
-  let(:controller){ Releaf::BaseController.new }
+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 formatted with `Releaf::Releaf::ErrorFormatter`" do
-      allow(Releaf::Core::ErrorFormatter).to receive(:format_errors).with(resource).and_return(a: "b")
+    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
@@ -82,17 +83,17 @@ describe Releaf::Core::Responders::AfterSaveResponder, type: :controller do
       end
 
       context "when options has :redirect key" do
-        it "calls `display_errors`" do
+        it "returns json with resource location url and status code `303`" do
           allow(subject).to receive(:options).and_return(redirect: true)
           expect(subject).to receive(:render).with(json: {url: "some_url"}, status: 303)
           subject.to_json
         end
       end
 
-      context "when options has key :destroyable with `false` value" do
-        it "renders `refused_destroy` template" do
+      context "when options has no :redirect key" do
+        it "redirects to resource location with status code `303`" do
           allow(subject).to receive(:options).and_return({})
-          expect(subject).to receive(:redirect_to).with("some_url", status: 303)
+          expect(subject).to receive(:redirect_to).with("some_url", status: 303, turbolinks: false)
           subject.to_json
         end
       end

data/spec/lib/releaf/{core/responders → responders}/confirm_destroy_responder_spec.rb

@@ -1,7 +1,7 @@
 require "rails_helper"
 
-describe Releaf::Core::Responders::ConfirmDestroyResponder, type: :controller do
-  let(:controller){ Releaf::BaseController.new }
+describe Releaf::Responders::ConfirmDestroyResponder, type: :controller do
+  let(:controller){ Releaf::ActionController.new }
   let(:resource){ Book.new}
   subject{ described_class.new(controller, [resource]) }
 

data/spec/lib/releaf/{core/responders → responders}/destroy_responder_spec.rb

@@ -1,7 +1,7 @@
 require "rails_helper"
 
-describe Releaf::Core::Responders::DestroyResponder, type: :controller do
-  let(:controller){ Releaf::BaseController.new }
+describe Releaf::Responders::DestroyResponder, type: :controller do
+  let(:controller){ Releaf::ActionController.new }
   let(:resource){ Book.new}
   subject{ described_class.new(controller, [resource]) }
 

data/spec/lib/releaf/{core/responders → responders}/error_responder_spec.rb

@@ -1,15 +1,15 @@
 require "rails_helper"
 
-describe Releaf::Core::Responders::ErrorResponder, type: :controller do
-  class Releaf::Core::Responders::DummyErrorResponder < ActionController::Responder
-    include Releaf::Core::Responders::ErrorResponder
+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::Core::Responders::DummyErrorResponder.new(controller, []) }
+  subject{ Releaf::Responders::DummyErrorResponder.new(controller, []) }
 
   describe "#template" do
     it "returns template based on class name" do

data/spec/lib/releaf/{core/responders → responders}/feature_disabled_responder_spec.rb

@@ -1,6 +1,6 @@
 require "rails_helper"
 
-describe Releaf::Core::Responders::FeatureDisabledResponder, type: :controller do
+describe Releaf::Responders::FeatureDisabledResponder, type: :controller do
   controller{}
   subject{ described_class.new(controller, []) }
 

data/spec/lib/releaf/{core/responders → responders}/page_not_found_responder_spec.rb

@@ -1,6 +1,6 @@
 require "rails_helper"
 
-describe Releaf::Core::Responders::PageNotFoundResponder, type: :controller do
+describe Releaf::Responders::PageNotFoundResponder, type: :controller do
   controller{}
   subject{ described_class.new(controller, []) }
 

data/spec/lib/releaf/{core/responders_spec.rb → responders_spec.rb}

@@ -1,27 +1,27 @@
 require "rails_helper"
 
-describe Releaf::Core::Responders, type: :controller do
-  subject{ Releaf::BaseController.new }
+describe Releaf::Responders, type: :controller do
+  subject{ Releaf::ActionController.new }
 
   describe "#respond_with" do
     before do
-      allow(subject).to receive(:active_responder).and_return(Releaf::Core::Responders::AfterSaveResponder)
+      allow(subject).to receive(:active_responder).and_return(Releaf::Responders::AfterSaveResponder)
       allow(subject).to receive(:request).and_return(request)
       allow(subject).to receive(:content_type).and_return(:html)
     end
 
     context "when no responder defined within options" do
       it "adds active responder to `responder` options" do
-        expect(Releaf::Core::Responders::AfterSaveResponder).to receive(:call)
+        expect(Releaf::Responders::AfterSaveResponder).to receive(:call)
         subject.respond_with(nil)
       end
     end
 
     context "when responder is defined within options" do
       it "adds active responder to `responder` options" do
-        expect(Releaf::Core::Responders::AfterSaveResponder).to_not receive(:call)
-        expect(Releaf::Core::Responders::PageNotFoundResponder).to receive(:call)
-        subject.respond_with(nil, responder: Releaf::Core::Responders::PageNotFoundResponder)
+        expect(Releaf::Responders::AfterSaveResponder).to_not receive(:call)
+        expect(Releaf::Responders::PageNotFoundResponder).to receive(:call)
+        subject.respond_with(nil, responder: Releaf::Responders::PageNotFoundResponder)
       end
     end
   end
@@ -29,13 +29,13 @@ describe Releaf::Core::Responders, type: :controller do
   describe "#action_responders" do
     it "returns hash with action to responders matching" do
       hash = {
-        create: Releaf::Core::Responders::AfterSaveResponder,
-        update: Releaf::Core::Responders::AfterSaveResponder,
-        confirm_destroy: Releaf::Core::Responders::ConfirmDestroyResponder,
-        destroy: Releaf::Core::Responders::DestroyResponder,
-        access_denied: Releaf::Core::Responders::AccessDeniedResponder,
-        feature_disabled: Releaf::Core::Responders::FeatureDisabledResponder,
-        page_not_found: Releaf::Core::Responders::PageNotFoundResponder,
+        create: Releaf::Responders::AfterSaveResponder,
+        update: Releaf::Responders::AfterSaveResponder,
+        confirm_destroy: Releaf::Responders::ConfirmDestroyResponder,
+        destroy: Releaf::Responders::DestroyResponder,
+        access_denied: Releaf::Responders::AccessDeniedResponder,
+        feature_disabled: Releaf::Responders::FeatureDisabledResponder,
+        page_not_found: Releaf::Responders::PageNotFoundResponder,
       }
       expect(subject.action_responders).to eq(hash)
     end

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

@@ -0,0 +1,9 @@
+require "rails_helper"
+
+describe Releaf::Root::Configuration do
+  subject{ described_class.new(default_controller_resolver: "asd") }
+
+  it do
+    is_expected.to have_attributes(default_controller_resolver: "asd")
+  end
+end

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

@@ -0,0 +1,108 @@
+require "rails_helper"
+
+describe Releaf::Root::DefaultControllerResolver do
+  let(:controller) { Releaf::RootController.new }
+  let(:request) { instance_double(ActionDispatch::Request, subdomain: nil) }
+  subject { described_class.new(current_controller: controller) }
+
+  before do
+    allow( controller ).to receive(:request).and_return(request)
+  end
+
+  it_behaves_like "an Releaf::Service includer"
+
+  describe "#call" do
+    it "returns first available controller index path" do
+      allow(subject).to receive(:controllers).and_return(["a", "b", "c"])
+      allow(subject).to receive(:controller_index_path).with("a").and_return(nil)
+      allow(subject).to receive(:controller_index_path).with("b").and_return("bb")
+      allow(subject).to receive(:controller_index_path).with("c").and_return("cc")
+
+      expect(subject.call).to eq("bb")
+    end
+
+    context "when no controller path is available" do
+      it "returns nil" do
+        allow(subject).to receive(:controllers).and_return(["a", "b"])
+        allow(subject).to receive(:controller_index_path).with("a").and_return(nil)
+        allow(subject).to receive(:controller_index_path).with("b").and_return(nil)
+
+        expect(subject.call).to be nil
+      end
+    end
+  end
+
+  describe "#controller_index_path" do
+    before do
+      allow(subject).to receive(:route_path).with(controller: "x", action: "index")
+        .and_return("_index_path_")
+      allow(subject).to receive(:route_path).with(controller: "x", action: "index", subdomain: "shop")
+        .and_return("_shop_index_path_")
+    end
+
+    context "when subdomain is not present" do
+      it "returns index path for given controller" do
+        allow(subject).to receive(:subdomain).and_return("")
+        expect(subject.controller_index_path("x")).to eq("_index_path_")
+      end
+    end
+
+    context "when subdomain is present" do
+      before do
+        allow(subject).to receive(:subdomain).and_return("shop")
+      end
+
+      context "when subdomain index exists" do
+        it "returns subdomain index path for given controller" do
+          expect(subject.controller_index_path("x")).to eq("_shop_index_path_")
+        end
+      end
+
+      context "when subdomain index does not exist" do
+        it "returns index path for given controller" do
+          allow(subject).to receive(:route_path).with(controller: "x", action: "index", subdomain: "shop")
+            .and_return(nil)
+          expect(subject.controller_index_path("x")).to eq("_index_path_")
+        end
+      end
+    end
+  end
+
+  describe "#route_path" do
+    context "when route exists" do
+      it "returns route path" do
+        allow(subject).to receive(:route_exists?).with(controller: "admin/books", action: "index").and_return(true)
+        expect(subject.route_path(controller: "admin/books", action: "index")).to eq("/admin/books")
+      end
+    end
+
+    context "when given route does not exist" do
+      it "returns nil" do
+        allow(subject).to receive(:route_exists?).with(controller: "admin/books", action: "index").and_return(false)
+        expect(subject.route_path(controller: "admin/books", action: "index")).to be nil
+      end
+    end
+  end
+
+  describe "#route_exists?" do
+    context "when given route exists" do
+      it "returns true" do
+        expect(subject.route_exists?(controller: "admin/books", action: "index")).to be true
+      end
+    end
+
+    context "when given route does not exist" do
+      it "returns false" do
+        expect(subject.route_exists?(controller: "releaf/permissions/profile", action: "index")).to be false
+        expect(subject.route_exists?(controller: "admin/asdasd", action: "index")).to be false
+      end
+    end
+  end
+
+  describe "#controllers" do
+    it "returns available controllers from Releaf config" do
+      allow(Releaf.application.config).to receive(:available_controllers).and_return("x")
+      expect(subject.controllers).to eq("x")
+    end
+  end
+end

data/spec/lib/releaf/root_spec.rb

@@ -0,0 +1,13 @@
+require "rails_helper"
+
+describe Releaf::Root do
+  describe ".configure_component" do
+    it "adds new `Releaf::Root::Configuration` configuration with default controller resolver and assigns settings manager" do
+      allow(Releaf::Root::Configuration).to receive(:new)
+        .with(default_controller_resolver: Releaf::Root::DefaultControllerResolver).and_return("_new")
+      expect(Releaf.application.config).to receive(:add_configuration).with("_new")
+      expect(Releaf.application.config).to receive(:settings_manager=).with(Releaf::Root::SettingsManager)
+      described_class.configure_component
+    end
+  end
+end

data/spec/lib/releaf/service_spec.rb

@@ -0,0 +1,20 @@
+require "rails_helper"
+
+describe Releaf::Service do
+  class DummyServiceIncluder
+    include Releaf::Service
+    attribute :some, String
+    attribute :thing, String
+
+    def call; end
+  end
+
+  describe ".call" do
+    it "initialize new service instance and return `#call` method value" do
+      subject = DummyServiceIncluder.new(some: "asd", thing: "asdasd")
+      allow(DummyServiceIncluder).to receive(:new).with(some: "x", thing: "y").and_return(subject)
+      allow(subject).to receive(:call).and_return("_x_")
+      expect(DummyServiceIncluder.call(some: "x", thing: "y")).to eq("_x_")
+    end
+  end
+end

data/spec/lib/releaf/settings/normalize_value_spec.rb

@@ -0,0 +1,103 @@
+require "rails_helper"
+
+describe Releaf::Settings::NormalizeValue do
+  let(:subject){ described_class.new(value: "x", input_type: :date) }
+
+  describe "#call" do
+    before do
+      allow(subject).to receive(:normalization_method).and_return("normalize_time")
+      allow(described_class).to receive(:normalize_time).and_return("a")
+    end
+
+    context "when normalization method exists for given input type" do
+      it "returns value normalize with normalization method" do
+        expect(subject.call).to eq("a")
+      end
+    end
+
+    context "when normalization method does not exist for given input type" do
+      it "returns non-normalized value" do
+        allow(described_class).to receive(:respond_to?).with("normalize_time").and_return(false)
+        expect(subject.call).to eq("x")
+      end
+    end
+  end
+
+  describe "#normalization_method" do
+    it "returns normalization method name built from given input type" do
+      expect(subject.normalization_method).to eq("normalize_date")
+    end
+  end
+
+  describe ".normalize_decimal" do
+    it "returns normalized decimal value" do
+      expect(described_class.normalize_decimal("1,12")).to eq(1.12.to_d)
+      expect(described_class.normalize_decimal("1.298")).to eq(1.298.to_d)
+    end
+  end
+
+  describe ".normalize_float" do
+    it "returns normalized float value" do
+      expect(described_class.normalize_float("1,12")).to eq(1.12.to_f)
+      expect(described_class.normalize_float("1.298")).to eq(1.298.to_f)
+    end
+  end
+
+  describe ".normalize_integer" do
+    it "returns normalized integer value" do
+      expect(described_class.normalize_integer("1,12")).to eq(1)
+      expect(described_class.normalize_integer("4,298")).to eq(4)
+    end
+  end
+
+  describe ".normalize_time" do
+    it "returns value normalized with `Time.parse`" do
+      allow(Time).to receive(:parse).with("a").and_return("b")
+      expect(described_class.normalize_time("a")).to eq("b")
+    end
+
+    context "when empty value given" do
+      it "returns nil" do
+        expect(described_class.normalize_time(" ")).to be nil
+        expect(described_class.normalize_time("")).to be nil
+      end
+    end
+  end
+
+  describe ".normalize_date" do
+    it "returns value normalized with `Date.parse`" do
+      allow(Date).to receive(:parse).with("a").and_return("b")
+      expect(described_class.normalize_date("a")).to eq("b")
+    end
+
+    context "when empty value given" do
+      it "returns nil" do
+        expect(described_class.normalize_date(" ")).to be nil
+        expect(described_class.normalize_date("")).to be nil
+      end
+    end
+  end
+
+  describe ".normalize_datetime" do
+    it "returns value normalized with `DateTime.parse`" do
+      allow(DateTime).to receive(:parse).with("a").and_return("b")
+      expect(described_class.normalize_datetime("a")).to eq("b")
+    end
+
+    context "when empty value given" do
+      it "returns nil" do
+        expect(described_class.normalize_datetime(" ")).to be nil
+        expect(described_class.normalize_datetime("")).to be nil
+      end
+    end
+  end
+
+  describe ".normalize_boolean" do
+    it "returns value compared against string value of `1`" do
+      expect(described_class.normalize_boolean("1")).to be true
+      expect(described_class.normalize_boolean("0")).to be false
+      expect(described_class.normalize_boolean("ewwqe")).to be false
+      expect(described_class.normalize_boolean("")).to be false
+    end
+  end
+end

data/spec/lib/releaf/settings/register_spec.rb

@@ -0,0 +1,135 @@
+require "rails_helper"
+
+describe Releaf::Settings::Register do
+  let(:subject){ described_class.new(settings: [{key: "a", type: "boolean"}, {key: "c", type: "text"}]) }
+
+  describe "#call" do
+    it "registers normalized settings items" do
+      allow(subject).to receive(:normalize).with(key: "a", type: "boolean").and_return("yy")
+      allow(subject).to receive(:normalize).with(key: "c", type: "text").and_return("zz")
+      expect(subject).to receive(:register).with("yy")
+      expect(subject).to receive(:register).with("zz")
+      subject.call
+    end
+  end
+
+  describe "#normalize" do
+    before do
+      allow(subject.settings_class).to receive(:supported_types).and_return([:boolean, :text])
+    end
+
+    it "normalizes type valey to symbol" do
+      expect(subject.normalize(key: "x", type: "boolean")).to eq(key: "x", type: :boolean)
+    end
+
+    context "when no type given" do
+      it "sets `:text` as default type" do
+        expect(subject.normalize(key: "x")).to eq(key: "x", type: :text)
+      end
+    end
+
+    context "when unsupported type given" do
+      it "raises `Releaf::Error`" do
+        allow(subject.settings_class).to receive(:supported_types).and_return([:mp3, :mp4])
+        expect{ subject.normalize(key: "x") }.to raise_error(Releaf::Error, "Unsupported settings type: text")
+      end
+    end
+
+    context "when dissallowed settings keys given" do
+      it "raises `Releaf::Error`" do
+        expect{ subject.normalize(key: "x", color: "red") }.to raise_error(Releaf::Error, "Dissallowed settings keys: [:color]")
+      end
+    end
+  end
+
+  describe "#register" do
+    before do
+      allow(subject.settings_class).to receive(:[]=)
+      allow(subject.settings_class.registry).to receive(:update)
+      allow(subject).to receive(:write_default?).with(key: "x", default: "_xx").and_return(true)
+    end
+
+    it "assigns item to settings registry" do
+      expect(subject.settings_class.registry).to receive(:update).with("x" => {key: "x", default: "_xx"})
+      subject.register(key: "x", default: "_xx")
+    end
+
+    it "stores value to cache and db" do
+      expect(subject.settings_class).to receive(:[]=).with("x", "_xx")
+      subject.register(key: "x", default: "_xx")
+    end
+
+    context "when default write is not permitted" do
+      it "does not store default value to db" do
+        allow(subject).to receive(:write_default?).with(key: "x").and_return(false)
+        expect(subject).to_not receive(:[]=)
+        subject.register(key: "x", default: "_xx")
+      end
+    end
+  end
+
+  describe "#allowed_keys" do
+    it "returns array with `key`, `default`, `type` and `description`" do
+      expect(subject.allowed_keys).to eq([:key, :default, :type, :description])
+    end
+  end
+
+  describe "#write_default?" do
+    before do
+      allow(subject).to receive(:table_exists?).and_return(true)
+      allow(subject.settings_class).to receive(:find_by).with(var: "xx").and_return(nil)
+    end
+
+    context "when database table exists and key does not exist in database" do
+      it "returns true" do
+        expect(subject.write_default?(key: "xx")).to be true
+      end
+    end
+
+    context "when database table exists and key does exist in database" do
+      it "returns false" do
+        allow(subject.settings_class).to receive(:find_by).with(var: "xx").and_return(Author.new)
+        expect(subject.write_default?(key: "xx")).to be false
+      end
+    end
+
+    context "when database table does not exists and key does not exist in database" do
+      it "returns false" do
+        allow(subject).to receive(:table_exists?).and_return(false)
+        expect(subject.write_default?(key: "xx")).to be false
+      end
+    end
+  end
+
+  describe "#table_exists?" do
+    before do
+      allow(subject.settings_class).to receive(:table_exists?).and_return(true)
+    end
+
+    context "when `ActiveRecord::NoDatabaseError` database does not exist" do
+      it "returns false" do
+        allow(subject.settings_class).to receive(:table_exists?).and_raise(ActiveRecord::NoDatabaseError, "x")
+        expect(subject.table_exists?).to be false
+      end
+    end
+
+    context "when table does not exist" do
+      it "returns false" do
+        allow(subject.settings_class).to receive(:table_exists?).and_return(false)
+        expect(subject.table_exists?).to be false
+      end
+    end
+
+    context "when table exists" do
+      it "returns true" do
+        expect(subject.table_exists?).to be true
+      end
+    end
+  end
+
+  describe "#settings_class" do
+    it "returns `Releaf::Settings` class" do
+      expect(subject.settings_class).to eq(Releaf::Settings)
+    end
+  end
+end

data/spec/lib/releaf/settings_manager_spec.rb

@@ -0,0 +1,22 @@
+require "rails_helper"
+
+describe  Releaf::Root::SettingsManager do
+  let(:controller){ Releaf::RootController.new }
+  let(:cookies){ {"asd.a" => "lalal"} }
+
+  before do
+    allow(controller).to receive(:send).with(:cookies).and_return(cookies)
+  end
+
+  describe ".read" do
+    it "returns cookies settings for given key" do
+      expect(described_class.read(controller: controller, key: "asd.a")).to eq("lalal")
+    end
+  end
+
+  describe ".write" do
+    it "writes user settings for given key and value" do
+      expect{ described_class.write(controller: controller, key: "asd.a", value: "op") }.to change{ cookies["asd.a"] }.to("op")
+    end
+  end
+end

data/spec/lib/validation_error_codes_spec.rb

@@ -19,7 +19,7 @@ describe "Extend ActiveModel validation error with error_code attribute" do
   end
 
   it "does not owerwrite default error message behaviour" do
-    expect(item.errors.get(:name).first).to eq("Blank")
+    expect(item.errors.get(:name).first).to eq("can't be blank")
   end
 
   context "when validation have :error_code option" do