releaf-core 2.0.0 → 2.0.1

data/spec/lib/releaf/responders_spec.rb

@@ -1,61 +0,0 @@
-require "rails_helper"
-
-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::Responders::AfterSaveResponder)
-      allow(subject).to receive(:request).and_return(request)
-      allow(subject).to receive(:content_type).and_return(:html)
-      allow(subject).to receive(:action_name).and_return(:save)
-    end
-
-    context "when no responder defined within options" do
-      it "adds active responder to `responder` options" do
-        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::Responders::AfterSaveResponder).to_not receive(:call)
-        expect(Releaf::Responders::PageNotFoundResponder).to receive(:call)
-        subject.respond_with(nil, responder: Releaf::Responders::PageNotFoundResponder)
-      end
-    end
-  end
-
-  describe "#action_responders" do
-    it "returns hash with action to responders matching" do
-      hash = {
-        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
-  end
-
-  describe "#action_responder" do
-    it "returns matching responder for given action" do
-      allow(subject).to receive(:action_responders).and_return(a: "x")
-      expect(subject.action_responder(:a)).to eq("x")
-      allow(subject).to receive(:action_responders).and_return(b: "x")
-      expect(subject.action_responder(:a)).to be nil
-    end
-  end
-
-  describe "#active_responder" do
-    it "returns currect action matching responder" do
-      allow(subject).to receive(:action_name).and_return(:save)
-      allow(subject).to receive(:action_responder).with(:save).and_return("x")
-      expect(subject.active_responder).to eq("x")
-    end
-  end
-end

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

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

@@ -1,44 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Root::DefaultControllerResolver do
-  let(:controller) { Releaf::RootController.new }
-  #let(:request) { instance_double(ActionDispatch::Request) }
-  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 definition path" do
-      controller_a_definition = Releaf::ControllerDefinition.new("a")
-      controller_b_definition = Releaf::ControllerDefinition.new("b")
-      allow(controller_a_definition).to receive(:path).and_return("aa_path")
-      allow(controller_b_definition).to receive(:path).and_return("bb_path")
-
-      allow(Releaf.application.config).to receive(:controllers).and_return(
-        "a" => controller_a_definition,
-        "b" => controller_b_definition,
-      )
-      allow(subject).to receive(:controllers).and_return(["a", "b"])
-
-      expect(subject.call).to eq("aa_path")
-    end
-
-    context "when no controller path is available" do
-      it "returns nil" do
-        allow(subject).to receive(:controllers).and_return([])
-        expect(subject.call).to be nil
-      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

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

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

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

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

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

@@ -1,56 +0,0 @@
-require "rails_helper"
-
-class DummyModel
-  include ActiveModel::Validations
-  attr_accessor :name, :surname, :age
-  validates :name, presence: {error_code: :no_name}
-  validates :surname, presence: true
-end
-
-describe "Extend ActiveModel validation error with error_code attribute" do
-  let(:item) do
-    item = DummyModel.new
-    item.valid?
-    item
-  end
-
-  it "adds ActiveModel::ErrorMessage as error instead of String" do
-    expect(item.errors[:name].first.class).to eq(ActiveModel::ErrorMessage)
-  end
-
-  it "does not owerwrite default error message behaviour" do
-    expect(item.errors[:name].first).to eq("can't be blank")
-  end
-
-  context "when validation have :error_code option" do
-    it "adds :error_code value as error_code" do
-      expect(item.errors[:name].first.error_code).to eq(:no_name)
-    end
-  end
-
-  context "when validation message is symbol" do
-    it "adds message as error_code" do
-      expect(item.errors[:surname].first.error_code).to eq(:blank)
-    end
-  end
-
-  context "when validation message is not symbol and don't have :error_code option" do
-    it "adds :invalid as error_code" do
-      item.errors.add(:age, "no age")
-      expect(item.errors[:age].first.error_code).to eq(:invalid)
-    end
-  end
-
-  context "when error with :strict option added" do
-    it "raises ActiveModel::StrictValidationFailed error" do
-      expect { item.errors.add(:age, :invalid, strict: true) }.to raise_error(ActiveModel::StrictValidationFailed)
-    end
-  end
-
-  context "when error with :data option is added" do
-    it "stores data" do
-      item.errors.add(:age, :invalid, data: {foo: :bar})
-      expect( item.errors[:age].first.data ).to eq(foo: :bar)
-    end
-  end
-end