releaf-core 1.1.21 → 2.1.1

data/spec/misc/factories_spec.rb

@@ -1,31 +0,0 @@
-require "rails_helper"
-
-describe "FactoryGirl factories" do
-
-  describe "admin factory" do
-    it "creates new user" do
-      expect { create(:user) }.to change { Releaf::Permissions::User.count }.by(1)
-    end
-  end
-
-  describe "role factory" do
-    it "creates new role" do
-      expect { create(:admin_role) }.to change { Releaf::Permissions::Role.count }.by(1)
-    end
-  end
-
-  describe "node factory" do
-    it "creates new content node" do
-      expect { create(:node) }.to change { Node.count }.by(1)
-    end
-
-    it "creates new HomePage content node" do
-      expect { create(:home_page_node) }.to change { HomePage.count }.by(1)
-    end
-
-    it "creates new TextPage content node" do
-      parent = create(:home_page_node)
-      expect { create(:text_page_node, parent: parent) }.to change { TextPage.count }.by(1)
-    end
-  end
-end

data/spec/models/settings_spec.rb

@@ -1,100 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Settings do
-
-  describe ":registered scope" do
-    it "returns only registed settings ordered by `var`" do
-      registered = described_class.where(var: "x")
-      allow(described_class).to receive(:registered_keys).and_return([:a, :b])
-      allow(described_class).to receive(:where).with(var: [:a, :b]).and_return(registered)
-      allow(registered).to receive(:order).with(:var).and_return(:c)
-      expect(described_class.registered).to eq(:c)
-    end
-
-    it "returns valid query" do
-      expect(described_class.registered.count).to be_instance_of(Fixnum)
-    end
-
-    it "returns instance of `Releaf::Settings::ActiveRecord_Relation`" do
-      expect(described_class.registered).to be_instance_of(Releaf::Settings::ActiveRecord_Relation)
-    end
-  end
-
-  describe "#releaf_title" do
-    it "returns var value" do
-      subject.var = "x"
-      expect(subject.releaf_title).to eq("x")
-    end
-  end
-
-  describe "#input_type" do
-    it "returns type from metadata" do
-      allow(subject).to receive(:metadata).and_return(type: "xx")
-      expect(subject.input_type).to eq("xx")
-    end
-
-    context "when type not defined in meta data" do
-      it "returns `:text` as default value" do
-        allow(subject).to receive(:metadata).and_return(type: nil)
-        expect(subject.input_type).to eq(:text)
-
-        allow(subject).to receive(:metadata).and_return(asdasd: "xx")
-        expect(subject.input_type).to eq(:text)
-      end
-    end
-  end
-
-  describe "#description" do
-    it "returns type from metadata" do
-      allow(subject).to receive(:metadata).and_return(description: "xxasd")
-      expect(subject.description).to eq("xxasd")
-    end
-  end
-
-  describe "#metadata" do
-    before do
-      subject.var = "xxx"
-    end
-
-    it "returns metadata values from settings registry fetched by object `var` value" do
-      allow(described_class).to receive(:registry).and_return("xxx" => {a: "b"})
-      expect(subject.metadata).to eq(a: "b")
-    end
-
-    context "when metadata does not exist" do
-      it "returns empty hash" do
-        allow(described_class).to receive(:registry).and_return("lasdh" => {a: "b"})
-        expect(subject.metadata).to eq({})
-      end
-    end
-  end
-
-  describe ".register_scoped" do
-    it "returns only register scoped settings" do
-      allow(described_class).to receive(:where).with(var: ["a", "b"]).and_return("x")
-      allow(described_class).to receive(:registered_keys).and_return(["a", "b"])
-
-      expect(described_class.register_scoped).to eq("x")
-    end
-
-    it "returns instance of `Releaf::Settings::ActiveRecord_Relation`" do
-      expect(described_class.register_scoped).to be_instance_of(Releaf::Settings::ActiveRecord_Relation)
-    end
-  end
-
-  describe ".register" do
-    it "calls `Releaf::Settings::Register` service with given arguments as array" do
-      expect(Releaf::Settings::Register).to receive(:call)
-        .with(settings: [{key: "a", type: "b"}, {key: "c", type: "d"}])
-      described_class.register({key: "a", type: "b"}, {key: "c", type: "d"})
-    end
-  end
-
-  describe ".supported_types" do
-    it "returns list of supported types as array with symbols" do
-      described_class.supported_types.each do|type|
-        expect(type).to be_instance_of Symbol
-      end
-    end
-  end
-end

data/spec/routing/route_mapper_spec.rb

@@ -1,185 +0,0 @@
-require "rails_helper"
-
-describe Releaf::RouteMapper do
-  after(:all) do
-    # reset dummy app routes
-    Dummy::Application.reload_routes!
-  end
-
-  describe "#mount_releaf_at" do
-    it "it assigns normalized mount location to Releaf.application.config.mount_location" do
-      expect{
-        routes.draw do
-          mount_releaf_at '/xxxx'
-        end
-      }.to change{ Releaf.application.config.mount_location }.to("xxxx")
-
-      expect{
-        routes.draw do
-          mount_releaf_at '/'
-        end
-      }.to change{ Releaf.application.config.mount_location }.to("")
-    end
-  end
-
-  describe "#releaf_resources" do
-    before do
-      routes.draw do
-        mount_releaf_at '/admin' do
-          releaf_resources :books
-        end
-      end
-    end
-
-    it "mounts resource toolbox route" do
-      expect(get: "/admin/books/1/toolbox").to route_to(
-        "action"=>"toolbox",
-        "controller"=>"admin/books",
-        "id"=>"1"
-      )
-    end
-
-    it "mounts resource destroy confirm route" do
-      expect(get: "/admin/books/1/confirm_destroy").to route_to(
-        "action"=>"confirm_destroy",
-        "controller"=>"admin/books",
-        "id"=>"1"
-      )
-    end
-
-    it "mounts resources index route" do
-      expect(get: "/admin/books/").to route_to(
-        "action"=>"index",
-        "controller"=>"admin/books",
-      )
-    end
-
-    it "mounts resource create route" do
-      expect(post: "/admin/books/").to route_to(
-        "action"=>"create",
-        "controller"=>"admin/books",
-      )
-    end
-
-    it "mounts resource new route" do
-      expect(get: "/admin/books/new").to route_to(
-        "action"=>"new",
-        "controller"=>"admin/books",
-      )
-    end
-
-    it "mounts resource edit route" do
-      expect(get: "/admin/books/1/edit").to route_to(
-        "action"=>"edit",
-        "controller"=>"admin/books",
-        "id"=>"1"
-      )
-    end
-
-    it "mounts resource show route" do
-      expect(get: "/admin/books/1").to route_to(
-        "action"=>"show",
-        "controller"=>"admin/books",
-        "id"=>"1"
-      )
-    end
-
-    it "mounts resource update route" do
-      expect(put: "/admin/books/1").to route_to(
-        "action"=>"update",
-        "controller"=>"admin/books",
-        "id"=>"1"
-      )
-    end
-
-    it "mounts resource destroy route" do
-      expect(delete: "/admin/books/1").to route_to(
-        "action"=>"destroy",
-        "controller"=>"admin/books",
-        "id"=>"1"
-      )
-    end
-
-    context "when toolbox route is disabled with except: option" do
-      before do
-        routes.draw do
-          mount_releaf_at '/admin' do
-            releaf_resources :books, except: [:toolbox]
-          end
-        end
-      end
-
-      it "route to page not found" do
-        expect(get: "/admin/books/1/toolbox")
-          .to route_to(controller: "releaf/root", action: "page_not_found", path: "books/1/toolbox")
-      end
-    end
-
-    context "when destroy route is skiped within with only: option" do
-      before do
-        routes.draw do
-          mount_releaf_at '/admin' do
-            releaf_resources :books, only: [:index]
-          end
-        end
-      end
-
-      it "route to page not found" do
-        expect(get: "/admin/books/1/toolbox")
-          .to route_to(controller: "releaf/root", action: "page_not_found", path: "books/1/toolbox")
-      end
-    end
-
-    context "when confirm destroy route is disabled with except: option" do
-      before do
-        routes.draw do
-          mount_releaf_at '/admin' do
-            releaf_resources :books, except: [:destroy]
-          end
-        end
-      end
-
-      it "does not mount destroy confirm route" do
-        expect(get: "/admin/books/1/confirm_destroy")
-          .to route_to(controller: "releaf/root", action: "page_not_found", path: "books/1/confirm_destroy")
-      end
-    end
-
-    context "when confirm destroy route is skiped within with only: option" do
-      before do
-        routes.draw do
-          mount_releaf_at '/admin' do
-            releaf_resources :books, only: [:index]
-          end
-        end
-      end
-
-      it "does not mount destroy confirm route" do
-        expect(get: "/admin/books/1/confirm_destroy")
-          .to route_to(controller: "releaf/root", action: "page_not_found", path: "books/1/confirm_destroy")
-      end
-    end
-
-    context "when custom block given" do
-      before do
-        routes.draw do
-          mount_releaf_at '/admin' do
-            releaf_resources :books, only: [:index] do
-              member do
-                get :download
-              end
-            end
-          end
-        end
-      end
-
-      it "calls it within resources method" do
-        expect(get: "/admin/books/1/download").to route_to(
-          "action"=>"download",
-          "controller"=>"admin/books",
-          "id"=>"1"
-        )
-      end
-    end
-  end
-end

data/spec/rspec_helpers/test_helpers_spec.rb

@@ -1,20 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Test::Helpers do
-  describe ".stub_settings" do
-    it "stubs given hash by key, value to Releaf::Settings" do
-      stub_settings("some.settings" => "x", "something" => "nothing")
-      expect(Releaf::Settings["some.settings"]).to eq("x")
-      expect(Releaf::Settings["something"]).to eq("nothing")
-    end
-
-    it "mergs multiple stub calls" do
-      stub_settings("some.settings" => "x")
-      stub_settings("another.settings" => "xx")
-
-      expect(Releaf::Settings["some.settings"]).to eq("x")
-      expect(Releaf::Settings["another.settings"]).to eq("xx")
-      expect(Releaf::Settings["unrelated.settings"]).to eq(nil)
-    end
-  end
-end

data/spec/rspec_helpers/test_spec.rb

@@ -1,14 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Test do
-  describe ".reset!" do
-    it "calls `Releaf::Content::RoutesReloader` reset" do
-      # initial there are two calls
-      expect(Releaf::Content::RoutesReloader).to receive(:reset!).twice
-      described_class.reset!
-
-      expect(Releaf::Content::RoutesReloader).to receive(:reset!).once
-      described_class.reset!
-    end
-  end
-end

data/spec/services/array/reorder_spec.rb

@@ -1,121 +0,0 @@
-require "rails_helper"
-
-describe Array::Reorder do
-  subject{ described_class.new(array: ["a", "b", "c", "d", {items: "xx"}, "e", "f", "g"],
-                               values: "c", options: :first) }
-
-  describe "#values=" do
-    context "when `values` is not array" do
-      it "wraps it within array before assigning" do
-        expect{ subject.values = :a }.to change{ subject.values }.to([:a])
-      end
-    end
-
-    context "when `values` is array" do
-      it "does not modify it before assigning" do
-        expect{ subject.values = [:a] }.to change{ subject.values }.to([:a])
-      end
-    end
-  end
-
-  describe "#call" do
-    it "deletes given values and insert deleted values in reversed order at reorder index" do
-      deleted_values = {a: "x", b: "y"}
-      subject.values = [:a, :b]
-      subject.options = :last
-
-      expect(subject).to receive(:delete).with([:a, :b]).ordered.and_return(deleted_values)
-      expect(subject).to receive(:reorder_index).with(:last).ordered.and_return(1)
-      expect{ subject.call }.to change{ subject.array }
-        .to(["a", "x", "y", "b", "c", "d", {items: "xx"}, "e", "f", "g"])
-    end
-
-    context "when given value is array" do
-      it "process unmodified given value" do
-        subject.values = [:a]
-        subject.options = :last
-        expect(subject).to receive(:delete).with([:a]).and_call_original
-        subject.call
-      end
-    end
-
-    context "when given value is not array" do
-      it "puts value within array" do
-        subject.values = [:a]
-        subject.options = :last
-        expect(subject).to receive(:delete).with([:a]).and_call_original
-        subject.call
-      end
-    end
-  end
-
-  describe "#reorder_index" do
-    context "when given options is :first" do
-      it "returns 0" do
-        expect(subject.reorder_index(:first)).to eq(0)
-      end
-    end
-
-    context "when given options is :last" do
-      it "returns size of array" do
-        expect(subject.reorder_index(:last)).to eq(8)
-        subject.array = [:a, :b]
-        expect(subject.reorder_index(:last)).to eq(2)
-      end
-    end
-
-    context "when given options is :before" do
-      it "returns index of given `before` value" do
-        allow(subject).to receive(:index).with(:items).and_return(4)
-        expect(subject.reorder_index(before: :items)).to eq(4)
-      end
-    end
-
-    context "when given options is :after" do
-      it "returns index of given `after` value increased by 1" do
-        allow(subject).to receive(:index).with(:items).and_return(4)
-        expect(subject.reorder_index(after: :items)).to eq(5)
-      end
-    end
-
-    context "when unknown option given" do
-      it "raises ArgumentError" do
-        expect{ subject.reorder_index(asdasd: :items) }.to raise_error(ArgumentError, "unknown reorder option")
-      end
-    end
-  end
-
-  describe "#index" do
-    it "returns value index by comparing array and given values casted to strings" do
-      expect(subject.index(:c)).to eq(2)
-      expect(subject.index("c")).to eq(2)
-      subject.array = ["a", :b, :c]
-      expect(subject.index("c")).to eq(2)
-    end
-
-    context "when array value is Hash" do
-      it "compares by hash first key casted to string" do
-        expect(subject.index(:items)).to eq(4)
-        expect(subject.index("items")).to eq(4)
-
-        subject.array = ["a", {"items" => "x"}]
-        expect(subject.index(:items)).to eq(1)
-        expect(subject.index("items")).to eq(1)
-      end
-    end
-  end
-
-  describe "#delete" do
-    before do
-      subject.array = [:a, :b, :c, :d, {items: "x"}]
-    end
-
-    it "deletes given values from array" do
-      expect{ subject.delete(["a", "b", "items"]) }.to change{ subject.array }.to([:c, :d])
-    end
-
-    it "returns hash with mapped deleted values" do
-      expect(subject.delete(["a", "b", "items"])).to eq("a" => :a, "b" => :b, "items" => {items: "x"})
-    end
-  end
-end