releaf-core 0.2.1 → 1.0.3

data/spec/misc/factories_spec.rb

@@ -14,18 +14,6 @@ describe "FactoryGirl factories" do
     end
   end
 
-  describe "translation factory" do
-    it "creates new translation" do
-      expect { create(:translation) }.to change { Releaf::I18nDatabase::Translation.count }.by(1)
-    end
-  end
-
-  describe "translation data factory" do
-    it "creates new translation data" do
-      expect { create(:translation_data) }.to change { Releaf::I18nDatabase::TranslationData.count }.by(1)
-    end
-  end
-
   describe "node factory" do
     it "creates new content node" do
       expect { create(:node) }.to change { Node.count }.by(1)

data/spec/models/settings_spec.rb

@@ -1,57 +1,99 @@
 require "rails_helper"
 
 describe Releaf::Settings do
-  let(:values){ [{key: "a", default: "x"}, {key: "b", default: "y"}] }
 
-  describe "#to_text" 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.to_text).to eq("x")
+      expect(subject.releaf_title).to eq("x")
     end
   end
 
-  describe ".registered_keys" do
-    it "returns all keys from `Releaf::Settings.registry` hash" do
-      described_class.registry = {}
-      described_class.registry["a"] = 1
-      described_class.registry["b"] = 1
-      described_class.registry["c"] = 1
-      expect(described_class.registered_keys.count).to eq(3)
-      expect(described_class.registered_keys).to include("a", "b", "c")
+  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 ".register" do
+  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
-      described_class.destroy_all
+      subject.var = "xxx"
     end
 
-    it "iterates through given array and assign item default value to default settings by overwriting existing values" do
-      described_class.defaults.delete("a")
-      described_class.defaults["b"] = "z"
-      expect{ described_class.register(values) }.to change{ [described_class.defaults["a"], described_class.defaults["b"]] }
-        .from([nil, "z"]).to(["x", "y"])
+    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"])
 
-    it "iterates through given array and assign items to registry by overwriting existing values" do
-      described_class.registry.delete("a")
-      described_class.registry["b"] = "xx"
-      expect{ described_class.register(values) }.to change{ [described_class.registry["a"], described_class.registry["b"]] }
-        .from([nil, "xx"]).to(values)
+      expect(described_class.register_scoped).to eq("x")
     end
 
-    it "iterates through given array and store default value to db if key does not exists in db" do
-      described_class.register(key: "a", default: "z")
+    it "returns instance of `Releaf::Settings::ActiveRecord_Relation`" do
+      expect(described_class.register_scoped).to be_instance_of(Releaf::Settings::ActiveRecord_Relation)
+    end
+  end
 
-      expect{ described_class.register(values) }.to change{ described_class.count  }.by(1)
-      expect(described_class.where(var: "a").first.value).to eq("z")
-      expect(described_class.where(var: "b").first.value).to eq("y")
+  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
 
-    context "when database table does not exists" do
-      it "does not store default values to db" do
-        allow(described_class).to receive(:table_exists?).and_return(false)
-        expect{ described_class.register(values) }.to_not change{ described_class.count  }
+  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

data/spec/routing/route_mapper_spec.rb

@@ -1,6 +1,6 @@
 require "rails_helper"
 
-describe Releaf::Core::RouteMapper do
+describe Releaf::RouteMapper do
   after(:all) do
     # reset dummy app routes
     Dummy::Application.reload_routes!
@@ -111,7 +111,7 @@ describe Releaf::Core::RouteMapper do
 
       it "route to page not found" do
         expect(get: "/admin/books/1/toolbox")
-          .to route_to(controller: "releaf/core/errors", action: "page_not_found", path: "books/1/toolbox")
+          .to route_to(controller: "releaf/errors", action: "page_not_found", path: "books/1/toolbox")
       end
     end
 
@@ -126,7 +126,7 @@ describe Releaf::Core::RouteMapper do
 
       it "route to page not found" do
         expect(get: "/admin/books/1/toolbox")
-          .to route_to(controller: "releaf/core/errors", action: "page_not_found", path: "books/1/toolbox")
+          .to route_to(controller: "releaf/errors", action: "page_not_found", path: "books/1/toolbox")
       end
     end
 
@@ -141,7 +141,7 @@ describe Releaf::Core::RouteMapper do
 
       it "does not mount destroy confirm route" do
         expect(get: "/admin/books/1/confirm_destroy")
-          .to route_to(controller: "releaf/core/errors", action: "page_not_found", path: "books/1/confirm_destroy")
+          .to route_to(controller: "releaf/errors", action: "page_not_found", path: "books/1/confirm_destroy")
       end
     end
 
@@ -156,7 +156,7 @@ describe Releaf::Core::RouteMapper do
 
       it "does not mount destroy confirm route" do
         expect(get: "/admin/books/1/confirm_destroy")
-          .to route_to(controller: "releaf/core/errors", action: "page_not_found", path: "books/1/confirm_destroy")
+          .to route_to(controller: "releaf/errors", action: "page_not_found", path: "books/1/confirm_destroy")
       end
     end
 

data/spec/rspec_helpers/test_helpers_spec.rb

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

data/spec/rspec_helpers/test_spec.rb

@@ -0,0 +1,14 @@
+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/{lib/releaf/core/item_orderer_spec.rb → services/array/reorder_spec.rb}

@@ -1,57 +1,50 @@
 require "rails_helper"
 
-describe Releaf::Core::ItemOrderer do
-  let(:list){ ["a", "b", "c", "d", {items: "xx"}, "e", "f", "g"] }
-  subject{ described_class.new(*list) }
-
-  describe "#initialize" do
-    it "assigns given arguments to list accessor" do
-      subject = described_class.new(:a, :b, :c)
-      expect(subject.list).to eq([:a, :b, :c])
-    end
-  end
-
-  describe "#result" do
-    it "returns list" do
-      expect(subject.result).to eq(list)
-      subject.reorder(:a, :last)
-      expect(subject.result).to eq(["b", "c", "d", {items: "xx"}, "e", "f", "g", "a"])
+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
-  end
 
-  describe "#to_a" do
-    it "returns result" do
-      allow(subject).to receive(:result).and_return(:x)
-      expect(subject.to_a).to eq(:x)
+    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 "#reorder" do
-    it "returns instance of itself" do
-      expect(subject.reorder(:a, :last)).to eq(subject)
-    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.reorder([:a, :b], :last) }.to change{ subject.list }
+      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.reorder([:a], :last)
+        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.reorder(:a, :last)
+        subject.call
       end
     end
   end
@@ -64,9 +57,9 @@ describe Releaf::Core::ItemOrderer do
     end
 
     context "when given options is :last" do
-      it "returns size of current list array" do
+      it "returns size of array" do
         expect(subject.reorder_index(:last)).to eq(8)
-        subject.list = [:a, :b]
+        subject.array = [:a, :b]
         expect(subject.reorder_index(:last)).to eq(2)
       end
     end
@@ -93,19 +86,19 @@ describe Releaf::Core::ItemOrderer do
   end
 
   describe "#index" do
-    it "returns value index by comparing list and given values casted to strings" 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.list = ["a", :b, :c]
+      subject.array = ["a", :b, :c]
       expect(subject.index("c")).to eq(2)
     end
 
-    context "when list value is Hash" do
+    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.list = ["a", {"items" => "x"}]
+        subject.array = ["a", {"items" => "x"}]
         expect(subject.index(:items)).to eq(1)
         expect(subject.index("items")).to eq(1)
       end
@@ -114,29 +107,15 @@ describe Releaf::Core::ItemOrderer do
 
   describe "#delete" do
     before do
-      subject.list = [:a, :b, :c, :d, {items: "x"}]
+      subject.array = [:a, :b, :c, :d, {items: "x"}]
     end
 
-    it "deletes given values from list" do
-      expect{ subject.delete(["a", "b", "items"]) }.to change{ subject.list }.to([:c, :d])
+    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
-
-  describe ".reorder" do
-    it "returns reordered array by given options" do
-      result = described_class.reorder(list,
-                      [:a, :b] => {after: :c},
-                      d: {before: :c},
-                      g: :first,
-                      [:e, :f] => {before: :g},
-                      c:  {after: :items},
-                      items: :first
-                     )
-      expect(result).to eq([{:items=>"xx"}, "e", "f", "g", "d", "a", "b", "c"])
-    end
-  end
 end