releaf-content 1.1.20 → 2.1.0

data/spec/lib/releaf/content/acts_as_node_spec.rb

@@ -1,90 +0,0 @@
-require "rails_helper"
-
-class ContactFormController < ActionController::Base
-  acts_as_node
-end
-
-describe ActsAsNode do
-  before do
-    Book.acts_as_node
-  end
-
-  describe ".classes" do
-    it "returns all registerd classes" do
-      expect(ActsAsNode.classes).to include("ContactFormController", "Book")
-    end
-  end
-
-  describe ".acts_as_node" do
-    it "have configuration options for params and fields available through acts_as_node_configuration class method" do
-      expect(Book.acts_as_node_configuration).to eq(params: nil, fields: nil)
-
-      Book.acts_as_node params: ["x"], fields: ["a"]
-      expect(Book.acts_as_node_configuration).to eq(params: ["x"], fields: ["a"])
-    end
-
-    it "has hard typed configuration options" do
-      expect{ Book.acts_as_node xxxx: ["x"] }.to raise_error(ArgumentError, "unknown keyword: xxxx")
-    end
-  end
-
-  describe ActiveRecord::Acts::Node do
-    context "when model acts as node" do
-      it "has name included within ActsAsNode.classes" do
-        expect(ActsAsNode.classes.include?(Book.to_s)).to be true
-      end
-    end
-
-    context ".acts_as_node_params" do
-      before do
-        allow_any_instance_of(Releaf::ResourceParams).to receive(:values).and_return(["a", "b"])
-      end
-
-      context "when `params` configuration is nil" do
-        it "returns model params with `id` param" do
-          allow(Book).to receive(:acts_as_node_configuration).and_return(params: nil)
-          expect(Releaf::ResourceParams).to receive(:new).with(Book).and_call_original
-          expect(Book.acts_as_node_params).to eq(["a", "b", :id])
-        end
-      end
-
-      context "when `params` configuration is not nil" do
-        it "returns configuration values with `id` param" do
-          allow(Book).to receive(:acts_as_node_configuration).and_return(params: ["c", "d"])
-          expect(Book.acts_as_node_params).to eq(["c", "d", :id])
-        end
-      end
-    end
-
-    context ".acts_as_node_fields" do
-      before do
-        allow_any_instance_of(Releaf::ResourceFields).to receive(:values).and_return(["a", "b"])
-      end
-
-      context "when `fields` configuration is nil" do
-        it "returns model fields" do
-          allow(Book).to receive(:acts_as_node_configuration).and_return(fields: nil)
-          expect(Releaf::ResourceFields).to receive(:new).with(Book).and_call_original
-          expect(Book.acts_as_node_fields).to eq(["a", "b"])
-        end
-      end
-
-      context "when `fields` configuration is not nil" do
-        it "returns configuration values" do
-          allow(Book).to receive(:acts_as_node_configuration).and_return(fields: ["c", "d"])
-          expect(Book.acts_as_node_fields).to eq(["c", "d"])
-        end
-      end
-    end
-
-  end
-
-  describe ActionController::Acts::Node do
-    context "when controller acts as node" do
-      it "has name included within ActsAsNode.classes" do
-        expect(ActsAsNode.classes.include?(ContactFormController.to_s)).to be true
-      end
-    end
-
-  end
-end

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

@@ -1,159 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Content::Configuration do
-  class ContentConfigurationDummyNode; end;
-  class ContentConfigurationDummyNodesController; end;
-  subject{ described_class.new(resources: {}) }
-
-  describe "#verify_resources_config" do
-    context "when valid config" do
-      it "does no raise an error" do
-        config = {'Node' => { controller: 'Releaf::Content::NodesController'}}
-        expect{  subject.verify_resources_config(config) }.to_not raise_error
-      end
-    end
-
-    context "when config is not a hash" do
-      it "raises an error" do
-        config = :foo
-        expect{  subject.verify_resources_config(config) }.to raise_error Releaf::Error, "Releaf.application.config.content.resources must be a Hash"
-      end
-    end
-
-    context "when any of the hash keys are not strings" do
-      it "raises an error" do
-        config = {Node => { controller: 'Releaf::Content::NodesController', foo: "wat"}}
-        expect{ subject.verify_resources_config(config) }.to raise_error Releaf::Error, "Releaf.application.config.content.resources must have string keys"
-      end
-    end
-
-    context "when any of the entries does not have a hash as a value" do
-      it "raises an error" do
-        config = {'Node' => :foo}
-        expect{ subject.verify_resources_config(config) }.to raise_error Releaf::Error, "Node in Releaf.application.config.content.resources must have a hash value"
-      end
-    end
-
-    context "when any of the entries does not have controller class name set" do
-      it "raises an error" do
-        config = {'Node' => { foo: "wat" }}
-        expect{ subject.verify_resources_config(config) }.to raise_error Releaf::Error, "Node in Releaf.application.config.content.resources must have controller class specified as a string"
-      end
-    end
-
-    context "when any of the entries does not have a string for the controller class name" do
-      it "raises an error" do
-        config = {'Node' => { controller: Releaf::Content::NodesController, foo: "wat" }}
-        expect{ subject.verify_resources_config(config) }.to raise_error Releaf::Error, "Node in Releaf.application.config.content.resources must have controller class specified as a string"
-      end
-    end
-  end
-
-  describe "#models" do
-    it "returns an array of node model classes" do
-      expect(subject).to receive(:model_names).and_return(['ContentConfigurationDummyNode', 'Object'])
-      expect(subject.models).to eq [ContentConfigurationDummyNode, Object]
-    end
-  end
-
-  describe "#model_names" do
-    it "returns an array of defined node class names" do
-      expect(subject).to receive(:resources).and_return(
-       'ContentConfigurationDummyNode' => { controller: 'Releaf::Content::NodesController' }
-      )
-      expect(subject.model_names).to eq [ 'ContentConfigurationDummyNode' ]
-    end
-
-    it "caches the result" do
-      expect(subject).to receive(:resources).once.and_call_original
-      subject.model_names
-      subject.model_names
-    end
-  end
-
-  describe "#default_model" do
-    it "returns the first model from #models" do
-      expect(subject).to receive(:models).and_return [ :foo, :bar ]
-      expect(subject.default_model).to eq :foo
-    end
-  end
-
-  describe "#controllers" do
-    it "returns an array of node controller classes" do
-      expect(subject).to receive(:controller_names).and_return([
-        'Releaf::Content::NodesController', 'Admin::OtherSite::OtherNodesController'
-      ])
-      expect(subject.controllers).to eq [Releaf::Content::NodesController, Admin::OtherSite::OtherNodesController]
-    end
-  end
-
-  describe "#controller_names" do
-    it "returns an array of defined node controller class names" do
-      allow(subject).to receive(:resources).and_return(
-        'Node' => { controller: 'Releaf::Content::NodesController' },
-        'ContentConfigurationDummyNode' => { controller: 'ContentConfigurationDummyNodesController' }
-      )
-      expect(subject.controller_names).to eq [ 'Releaf::Content::NodesController', 'ContentConfigurationDummyNodesController' ]
-    end
-
-    it "caches the result" do
-      expect(subject).to receive(:resources).once.and_call_original
-      subject.controller_names
-      subject.controller_names
-    end
-  end
-
-  describe ".routing" do
-    it "returns a hash with all node class names as string keys" do
-      allow(subject).to receive(:resources).and_return(
-        'Node' => { controller: 'Releaf::Content::NodesController' },
-        'ContentConfigurationDummyNode' => { controller: 'ContentConfigurationDummyNodesController' }
-      )
-      result = subject.routing
-      expect( result ).to be_a Hash
-      expect( result.keys ).to eq ['Node', 'ContentConfigurationDummyNode' ]
-    end
-
-    context "when node has no routing defined" do
-      it "returns routing hash with site and constraints set to nil" do
-        allow(subject).to receive(:resources).and_return(
-          'Node' => { controller: 'Releaf::Content::NodesController' }
-        )
-        expect(subject.routing).to eq 'Node' => { site: nil, constraints: nil }
-      end
-    end
-
-    context "when node has nil values for site and constraints in routing config" do
-      it "returns routing hash with site and constraints set to nil" do
-        allow(subject).to receive(:resources).and_return(
-          'Node' => {controller: 'Releaf::Content::NodesController', routing: { site: nil, constraints: nil }}
-        )
-        expect(subject.routing).to eq 'Node' => { site: nil, constraints: nil }
-      end
-    end
-
-    context "when node has site defined in routing config" do
-      it "returns the defined value in routing hash" do
-        allow(subject).to receive(:resources).and_return(
-          'Node' => {controller: 'Releaf::Content::NodesController', routing: { site: "foo" }}
-        )
-        expect(subject.routing).to eq 'Node' => { site: "foo", constraints: nil }
-      end
-    end
-
-    context "when node has constraints defined in routing config" do
-      it "returns the defined value in routing hash" do
-        allow(subject).to receive(:resources).and_return(
-          'Node' => {controller: 'Releaf::Content::NodesController', routing: { constraints: { host: /foo/ }}}
-        )
-        expect(subject.routing).to eq 'Node' => { site: nil, constraints: { host: /foo/ } }
-      end
-    end
-
-    it "caches the result" do
-      expect(subject).to receive(:resources).once.and_call_original
-      subject.routing
-      subject.routing
-    end
-  end
-end

data/spec/lib/releaf/content/engine_spec.rb

@@ -1,149 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Content do
-  let(:configuration){ Releaf::Content::Configuration.new(resources: {}) }
-
-  describe ".configure_component" do
-    it "adds new `Releaf::Content::Configuration` configuration with default resources" do
-      allow(Releaf::Content::Configuration).to receive(:new)
-        .with(resources: { 'Node' => { controller: 'Releaf::Content::NodesController' } }).and_return("_new")
-      expect(Releaf.application.config).to receive(:add_configuration).with("_new")
-      described_class.configure_component
-    end
-  end
-
-  describe ".configuration" do
-    it "returns a configuration instance" do
-      expect(Releaf.application.config).to receive(:content).and_return(:ok)
-      expect(described_class.configuration).to eq :ok
-    end
-  end
-
-  [ :resources, :models, :default_model, :controllers, :routing ].each do |method|
-    describe ".#{method}" do
-      it "returns the method result from the configuration instance" do
-        allow(described_class).to receive(:configuration).and_return(configuration)
-        allow(configuration).to receive(method).and_return(:ok)
-        expect(described_class.send(method)).to eq :ok
-      end
-    end
-  end
-
-  describe ".draw_component_routes", type: :routing do
-    before do
-      allow(described_class).to receive(:configuration).and_return(configuration)
-      allow(configuration).to receive(:resources).and_return(
-        'Node' => { controller: 'Releaf::Content::NodesController' },
-        'OtherSite::OtherNode' => { controller: 'Admin::OtherSite::OtherNodesController' }
-      )
-      Dummy::Application.reload_routes!
-    end
-
-    after(:all) do
-      Dummy::Application.reload_routes!
-    end
-
-    context "draws named admin routes for all defined content node controllers" do
-
-      it "draws #index route" do
-        expect( releaf_content_nodes_path ).to eq "/admin/nodes"
-        expect( admin_other_site_other_nodes_path ).to eq "/admin/other_nodes"
-        expect(get: "/admin/nodes").to route_to("releaf/content/nodes#index")
-        expect(get: "/admin/other_nodes").to route_to("admin/other_site/other_nodes#index")
-      end
-
-      it "draws #new route" do
-        expect( new_releaf_content_node_path ).to eq "/admin/nodes/new"
-        expect( new_admin_other_site_other_node_path ).to eq "/admin/other_nodes/new"
-        expect(get: "/admin/nodes/new").to route_to("releaf/content/nodes#new")
-        expect(get: "/admin/other_nodes/new").to route_to("admin/other_site/other_nodes#new")
-      end
-
-      it "draws #create route" do
-        expect(post: "/admin/nodes").to route_to("releaf/content/nodes#create")
-        expect(post: "/admin/other_nodes").to route_to("admin/other_site/other_nodes#create")
-      end
-
-      it "draws #content_type_dialog route" do
-        expect( content_type_dialog_releaf_content_nodes_path ).to eq "/admin/nodes/content_type_dialog"
-        expect( content_type_dialog_admin_other_site_other_nodes_path ).to eq "/admin/other_nodes/content_type_dialog"
-        expect(get: "/admin/nodes/content_type_dialog").to route_to("releaf/content/nodes#content_type_dialog")
-        expect(get: "/admin/other_nodes/content_type_dialog").to route_to("admin/other_site/other_nodes#content_type_dialog")
-      end
-
-      it "draws #generate_url route" do
-        expect( generate_url_releaf_content_nodes_path ).to eq "/admin/nodes/generate_url"
-        expect( generate_url_admin_other_site_other_nodes_path ).to eq "/admin/other_nodes/generate_url"
-        expect(get: "/admin/nodes/generate_url").to route_to("releaf/content/nodes#generate_url")
-        expect(get: "/admin/other_nodes/generate_url").to route_to("admin/other_site/other_nodes#generate_url")
-      end
-
-      it "draws #edit route" do
-        expect( edit_releaf_content_node_path(1) ).to eq "/admin/nodes/1/edit"
-        expect( edit_admin_other_site_other_node_path(1) ).to eq "/admin/other_nodes/1/edit"
-        expect(get: "/admin/nodes/1/edit").to route_to("releaf/content/nodes#edit", "id" => "1")
-        expect(get: "/admin/other_nodes/1/edit").to route_to("admin/other_site/other_nodes#edit", "id" => "1")
-      end
-
-      it "draws #update route" do
-        expect(patch: "/admin/nodes/1").to route_to("releaf/content/nodes#update", "id" => "1")
-        expect(patch: "/admin/other_nodes/1").to route_to("admin/other_site/other_nodes#update", "id" => "1")
-      end
-
-      it "draws #copy_dialog route" do
-        expect( copy_dialog_releaf_content_node_path(1) ).to eq "/admin/nodes/1/copy_dialog"
-        expect( copy_dialog_admin_other_site_other_node_path(1) ).to eq "/admin/other_nodes/1/copy_dialog"
-        expect(get: "/admin/nodes/1/copy_dialog").to route_to("releaf/content/nodes#copy_dialog", "id" => "1")
-        expect(get: "/admin/other_nodes/1/copy_dialog").to route_to("admin/other_site/other_nodes#copy_dialog", "id" => "1")
-      end
-
-      it "draws #copy route" do
-        expect( copy_releaf_content_node_path(1) ).to eq "/admin/nodes/1/copy"
-        expect( copy_admin_other_site_other_node_path(1) ).to eq "/admin/other_nodes/1/copy"
-        expect(post: "/admin/nodes/1/copy").to route_to("releaf/content/nodes#copy", "id" => "1")
-        expect(post: "/admin/other_nodes/1/copy").to route_to("admin/other_site/other_nodes#copy", "id" => "1")
-      end
-
-      it "draws #move_dialog route" do
-        expect( move_dialog_releaf_content_node_path(1) ).to eq "/admin/nodes/1/move_dialog"
-        expect( move_dialog_admin_other_site_other_node_path(1) ).to eq "/admin/other_nodes/1/move_dialog"
-        expect(get: "/admin/nodes/1/move_dialog").to route_to("releaf/content/nodes#move_dialog", "id" => "1")
-        expect(get: "/admin/other_nodes/1/move_dialog").to route_to("admin/other_site/other_nodes#move_dialog", "id" => "1")
-      end
-
-      it "draws #move route" do
-        expect( move_releaf_content_node_path(1) ).to eq "/admin/nodes/1/move"
-        expect( move_admin_other_site_other_node_path(1) ).to eq "/admin/other_nodes/1/move"
-        expect(post: "/admin/nodes/1/move").to route_to("releaf/content/nodes#move", "id" => "1")
-        expect(post: "/admin/other_nodes/1/move").to route_to("admin/other_site/other_nodes#move", "id" => "1")
-      end
-
-      it "draws #toolbox route" do
-        expect( toolbox_releaf_content_node_path(1) ).to eq "/admin/nodes/1/toolbox"
-        expect( toolbox_admin_other_site_other_node_path(1) ).to eq "/admin/other_nodes/1/toolbox"
-        expect(get: "/admin/nodes/1/toolbox").to route_to("releaf/content/nodes#toolbox", "id" => "1")
-        expect(get: "/admin/other_nodes/1/toolbox").to route_to("admin/other_site/other_nodes#toolbox", "id" => "1")
-      end
-
-      it "draws #confirm_destroy route" do
-        expect( confirm_destroy_releaf_content_node_path(1) ).to eq "/admin/nodes/1/confirm_destroy"
-        expect( confirm_destroy_admin_other_site_other_node_path(1) ).to eq "/admin/other_nodes/1/confirm_destroy"
-        expect(get: "/admin/nodes/1/confirm_destroy").to route_to("releaf/content/nodes#confirm_destroy", "id" => "1")
-        expect(get: "/admin/other_nodes/1/confirm_destroy").to route_to("admin/other_site/other_nodes#confirm_destroy", "id" => "1")
-      end
-
-      it "draws #destroy route" do
-        expect(delete: "/admin/nodes/1").to route_to("releaf/content/nodes#destroy", "id" => "1")
-        expect(delete: "/admin/other_nodes/1").to route_to("admin/other_site/other_nodes#destroy", "id" => "1")
-      end
-
-      it "does not draw #show route" do
-        expect(get: "/admin/nodes/1").to route_to("releaf/root#page_not_found", "path" => "nodes/1")
-        expect(get: "/admin/other_nodes/1").to route_to("releaf/root#page_not_found", "path" => "other_nodes/1")
-      end
-
-    end
-
-  end
-
-end

data/spec/lib/releaf/content/node_spec.rb

@@ -1,591 +0,0 @@
-require "rails_helper"
-
-describe Node do
-  class PlainNode < ActiveRecord::Base
-    include Releaf::Content::Node
-    self.table_name = "nodes"
-  end
-
-  let(:plain_subject){ PlainNode.new }
-
-  it { is_expected.to accept_nested_attributes_for(:content) }
-  it { is_expected.to belong_to(:content) }
-
-  it "includes Releaf::Content::Node module" do
-    expect( Node.included_modules ).to include Releaf::Content::Node
-  end
-
-  describe "validations" do
-    it { is_expected.to validate_presence_of(:name) }
-    it { is_expected.to validate_presence_of(:slug) }
-    it { is_expected.to validate_presence_of(:content_type) }
-    it { is_expected.to validate_uniqueness_of(:slug).scoped_to(:parent_id) }
-    it { is_expected.to validate_length_of(:name).is_at_most(255) }
-    it { is_expected.to validate_length_of(:slug).is_at_most(255) }
-  end
-
-  describe "after save" do
-    it "sets node update to current time" do
-      expect( Node ).to receive(:updated).once
-      create(:node)
-    end
-  end
-
-  describe ".active (scope)" do
-    it "returns active nodes" do
-      expect( Node ).to receive(:where).with(active: true).and_return('foo')
-      expect( Node.active ).to eq 'foo'
-    end
-  end
-
-  describe "#content_class" do
-    context 'when #content_type is nil' do
-      it 'returns nil' do
-        subject.content_type = nil
-        expect( subject.content_class ).to be nil
-      end
-    end
-
-    context "when #content_type is blank string" do
-      it 'returns nil' do
-        subject.content_type = ""
-        expect( subject.content_class ).to be nil
-      end
-    end
-
-    context "when #content_type is not blank" do
-      it "constantizes it" do
-        subject.content_type = "Node"
-        expect( subject.content_class ).to eq Node
-      end
-    end
-  end
-
-  describe "#to_s" do
-    it "returns name" do
-      expect(subject.to_s).to eq(subject.name)
-    end
-  end
-
-  describe "#locale" do
-    before do
-      root = create(:node, locale: "lv")
-      parent = create(:text_page_node, locale: nil, parent_id: root.id)
-      @child1 = create(:text_page_node, locale: nil, parent_id: parent.id)
-      @child2 = create(:text_page_node, parent_id: parent.id, locale: "en")
-    end
-
-    context "when node locale is nil" do
-      it "uses closest parent locale" do
-        expect(@child1.locale).to eq("lv")
-      end
-    end
-
-    context "when object node have locale" do
-      it "uses closest parent locale" do
-        expect(@child2.locale).to eq("en")
-      end
-    end
-  end
-
-  describe "#destroy" do
-    context "when content object class exists" do
-      let!(:node) { create(:home_page_node) }
-
-      it "deletes record" do
-        expect { node.destroy }.to change { Node.count }.by(-1)
-      end
-
-      it "deletes associated record" do
-        expect { node.destroy }.to change { HomePage.count }.by(-1)
-      end
-    end
-
-    context "when content object class doesn't exists" do
-      let!(:node) { create(:home_page_node) }
-      before do
-        node.update_columns(content_type: 'NonExistingTestModel')
-      end
-
-      it "deletes record" do
-        expect { node.destroy }.to change { Node.count }.by(-1)
-      end
-    end
-
-    it "sets node update to current time" do
-      node = create(:node)
-      expect( Node ).to receive(:updated).once
-      node.destroy
-    end
-  end
-
-  describe "#attributes_to_not_copy" do
-    it "returns array with attributes" do
-      subject.locale = "lv"
-      expect( subject.attributes_to_not_copy ).to match_array %w[content_id depth id item_position lft rgt created_at updated_at]
-    end
-
-    context "when locale is blank" do
-      it "includes locale within returned list" do
-        expect( subject.attributes_to_not_copy ).to match_array %w[content_id depth id item_position lft rgt created_at updated_at locale]
-      end
-    end
-  end
-
-  describe "#attributes_to_copy" do
-    it "returns object attributes excluding #attributes_to_not_copy" do
-      node = Node.new
-      allow( node ).to receive(:attributes_to_not_copy).and_return(%w[lft rgt])
-      expect( node.attributes_to_copy ).to eq(Node.column_names - %w[lft rgt])
-    end
-  end
-
-  describe "#reasign_slug" do
-    it "updates slug" do
-      node = create(:node)
-      old_slug = node.slug
-      node.name = 'woo hoo'
-      expect { node.reasign_slug }.to change { node.slug }.from(old_slug).to('woo-hoo')
-    end
-  end
-
-  describe "#assign_attributes_from" do
-    let(:source_node) { create(:node, active: false) }
-
-    it "copies #attributes_to_copy attributes" do
-
-      allow( source_node ).to receive(:attributes_to_copy).and_return(['name'])
-
-      expect( source_node ).to receive(:name).and_call_original
-      expect( source_node ).to_not receive(:parent_id)
-      expect( source_node ).to_not receive(:content_type)
-      expect( source_node ).to_not receive(:active)
-
-      new_node = Node.new
-
-      new_node.assign_attributes_from source_node
-
-      expect( new_node.parent_id ).to be nil
-      expect( new_node.content_type ).to be nil
-      expect( new_node.active ).to be true
-    end
-  end
-
-  describe ".children_max_item_position" do
-    before do
-      @home_page_node   = create(:home_page_node, item_position: 1, locale: "lv")
-      @home_page_node_2 = create(:home_page_node, item_position: 2, locale: "en")
-      @text_page_node_3 = create(:text_page_node, parent_id: @home_page_node_2.id, item_position: 1)
-      @text_page_node_4 = create(:text_page_node, parent_id: @home_page_node_2.id, item_position: 2)
-
-      # it is important to reload nodes, otherwise associations will return empty set
-      @home_page_node.reload
-      @home_page_node_2.reload
-      @text_page_node_3.reload
-      @text_page_node_4.reload
-    end
-
-    context "when passing nil" do
-      it "returns max item_position of root nodes" do
-        expect( Node.children_max_item_position(nil) ).to eq 2
-      end
-    end
-
-    context "when passing node with children" do
-      it "returns max item_position of node children" do
-        expect( Node.children_max_item_position(@home_page_node_2) ).to eq 2
-      end
-    end
-
-    context "when passing node without children" do
-      it "returns 0" do
-        expect( Node.children_max_item_position(@text_page_node_4) ).to eq 0
-      end
-    end
-  end
-
-  describe "#move" do
-    it "calls Node move service" do
-      expect(Releaf::Content::Node::Move).to receive(:call).with(node: subject, parent_id: 12)
-      subject.move(12)
-    end
-  end
-
-  describe "#maintain_name" do
-    let(:root) { create(:home_page_node) }
-    let(:node) { create(:text_page_node, parent_id: root.id, name:  "Test node") }
-    let(:sibling) { create(:text_page_node, parent_id: root.id, name:  "Test node(1)") }
-
-    context "when node don't have sibling/s with same name" do
-      it "does not changes node's name" do
-        new_node = Node.new(name:  "another name", parent_id: root.id)
-        expect{ new_node.maintain_name }.to_not change{new_node.name}
-      end
-    end
-
-    context "when node have sibling/s with same name" do
-      it "changes node's name" do
-        new_node = Node.new(name:  node.name, parent_id: root.id)
-        expect{ new_node.maintain_name }.to change{new_node.name}.from(node.name).to("#{node.name}(1)")
-      end
-
-      it "increments node's name number" do
-        sibling
-        new_node = Node.new(name:  node.name, parent_id: root.id)
-        expect{ new_node.maintain_name }.to change{new_node.name}.from(node.name).to("#{node.name}(2)")
-      end
-    end
-  end
-
-  describe "#maintain_slug" do
-    let(:root) { create(:home_page_node) }
-    let(:node) { create(:text_page_node, parent_id: root.id, name:  "Test node", slug: "test-node") }
-    let(:sibling) { create(:text_page_node, parent_id: root.id, name:  "Test node(1)", slug: "test-node-1") }
-
-    context "when node don't have sibling/s with same name" do
-      it "does not changes node's slug" do
-        new_node = Node.new(name:  "another name", parent_id: root.id)
-        expect{ new_node.maintain_slug }.to_not change{new_node.slug}
-      end
-    end
-
-    context "when node have sibling/s with same slug" do
-      it "changes node's slug" do
-        new_node = Node.new(name:  node.name, slug: node.slug, parent_id: root.id)
-        expect{ new_node.maintain_slug }.to change{new_node.slug}.from(node.slug).to("#{node.slug}-1")
-      end
-
-      it "increments node's slug number" do
-        sibling
-        new_node = Node.new(name:  node.name, slug: node.slug, parent_id: root.id)
-        expect{ new_node.maintain_slug }.to change{new_node.slug}.from(node.slug).to("#{node.slug}-2")
-      end
-    end
-  end
-
-  describe ".updated_at" do
-    it "returns last node update time" do
-      expect( Releaf::Settings ).to receive(:[]).with('releaf.content.nodes.updated_at').and_return('test')
-      expect( Node.updated_at ).to eq 'test'
-    end
-  end
-
-  describe ".updated" do
-    it "returns last node update time" do
-      allow(Time).to receive(:now).and_return("asd")
-      expect( Releaf::Settings ).to receive(:[]=).with('releaf.content.nodes.updated_at', "asd")
-      Node.updated
-    end
-  end
-
-  describe "#available?" do
-    let(:root) { create(:home_page_node, active: true) }
-    let(:node_ancestor) { create(:text_page_node, parent_id: root.id, active: true) }
-    let(:node) { create(:text_page_node, parent_id: node_ancestor.id, active: true) }
-
-    context "when object and all its ancestors are active" do
-      it "returns true" do
-        expect( node ).to be_available
-      end
-    end
-
-    context "when object itself is not active" do
-      it "returns false" do
-        node.update_attribute(:active, false)
-        expect( node ).to_not be_available
-      end
-    end
-
-    context "when any of object ancestors are not active" do
-      it "returns false" do
-        node_ancestor.update_attribute(:active, false)
-        expect( node ).to_not be_available
-      end
-    end
-  end
-
-  describe ".valid_node_content_classes" do
-    it "returns array of constantized .valid_node_content_class_names" do
-      expect( Node ).to receive(:valid_node_content_class_names).with(42).and_return(['TextPage', 'HomePagesController'])
-      expect( Node.valid_node_content_classes(42) ).to eq [TextPage, HomePagesController]
-    end
-  end
-
-  describe ".valid_node_content_class_names" do
-    it "returns class names for Node#content_type that can be used to create valid node" do
-      expect( ActsAsNode ).to receive(:classes).and_return(%w[BadNode GoodNode])
-
-      node_1 = double('BadNode')
-      allow(node_1).to receive(:valid?)
-      node_1_errors = double("Node 1 Errors object")
-      expect( node_1_errors ).to receive(:[]).with(:content_type).and_return(['some error'])
-      allow(node_1).to receive(:errors).and_return(node_1_errors)
-
-      node_2 = double('GoodNode')
-      allow(node_2).to receive(:valid?)
-      node_2_errors = double("Node 2 Errors object")
-      expect( node_2_errors ).to receive(:[]).with(:content_type).and_return(nil)
-      allow(node_2).to receive(:errors).and_return(node_2_errors)
-
-      expect( Node ).to receive(:new).with(hash_including(parent_id: 52, content_type: 'BadNode')).and_return(node_1)
-      expect( Node ).to receive(:new).with(hash_including(parent_id: 52, content_type: 'GoodNode')).and_return(node_2)
-
-      expect( Node.valid_node_content_class_names(52) ).to eq %w[GoodNode]
-    end
-
-  end
-
-  describe "#locale_selection_enabled?" do
-    it "returns false" do
-      expect( plain_subject.locale_selection_enabled? ).to be false
-    end
-  end
-
-  describe "#build_content" do
-    it "builds new content and assigns to #content" do
-      subject.content_type = 'TextPage'
-      params = {text_html: 'test'}
-      expect( TextPage ).to receive(:new).with(params).and_call_original
-      subject.build_content(params)
-      expect( subject.content ).to be_an_instance_of TextPage
-      expect( subject.content.text_html ).to eq 'test'
-    end
-  end
-
-  describe "#validate_root_locale_uniqueness?" do
-    before do
-      allow( subject ).to receive(:root?).and_return(true)
-      allow( subject ).to receive(:locale_selection_enabled?).and_return(true)
-    end
-
-    context "when #locale_selection_enabled? and #root? both are true" do
-      it "returns true" do
-        expect( subject.send(:validate_root_locale_uniqueness?) ).to be_truthy
-      end
-    end
-
-    context "when #locale_selection_enabled? is false" do
-      it "returns false" do
-        allow( subject ).to receive(:locale_selection_enabled?).and_return(false)
-        expect( subject.send(:validate_root_locale_uniqueness?) ).to be_falsy
-      end
-    end
-
-    context "when #root? is false" do
-      it "returns false" do
-        allow( subject ).to receive(:root?).and_return(false)
-        expect( subject.send(:validate_root_locale_uniqueness?) ).to be_falsy
-      end
-    end
-  end
-
-  describe "#validate_slug" do
-    it "is called during validations" do
-      expect( subject ).to receive(:validate_slug)
-      subject.valid?
-    end
-
-    context "when invalid slug" do
-      it "adds format error on slug" do
-        allow(subject).to receive(:invalid_slug_format?).and_return(true)
-        expect{ subject.send(:validate_slug) }.to change{ subject.errors[:slug] }.to(["is invalid"])
-      end
-    end
-
-    context "when valid slug" do
-      it "does not add format error on slug" do
-        allow(subject).to receive(:invalid_slug_format?).and_return(false)
-        expect{ subject.send(:validate_slug) }.to_not change{ subject.errors[:slug] }.from([])
-      end
-    end
-  end
-
-  describe "#invalid_slug_format?" do
-    context "when slug value converted to url differs" do
-      it "returns true" do
-        subject.slug = "asd xx"
-        expect(subject.invalid_slug_format?).to be true
-      end
-    end
-
-    context "when slug value converted to url is same" do
-      it "returns false" do
-        subject.slug = "asd-xx"
-        expect(subject.invalid_slug_format?).to be false
-      end
-    end
-
-    context "when slug value is nil" do
-      it "returns false" do
-        subject.slug = nil
-        expect(subject.invalid_slug_format?).to be false
-      end
-    end
-  end
-
-  describe "#validate_parent_node_is_not_self" do
-    let(:node1) { create(:node, locale: "lv") }
-
-    it "is called during validations" do
-      expect( subject ).to receive(:validate_parent_node_is_not_self)
-      subject.valid?
-    end
-
-    context "when #parent_id matches #id" do
-      it "adds error on #parent_id" do
-        node1.parent_id = node1.id
-        node1.send(:validate_parent_node_is_not_self)
-        expect( node1.errors[:parent_id] ).to include "can't be parent to itself"
-      end
-    end
-
-    context "when parent is nil" do
-      it "does nothing" do
-        node1.parent_id = nil
-        node1.send(:validate_parent_node_is_not_self)
-        expect( node1.errors[:parent_id] ).to be_blank
-      end
-    end
-
-    context "#id matches #parent_id" do
-      it "does nothing" do
-        node2 = create(:node, locale: "en")
-        node1.parent_id = node2.id
-        node1.send(:validate_parent_is_not_descendant)
-        expect( node1.errors[:parent_id] ).to be_blank
-      end
-    end
-
-
-  end
-
-  describe "#validate_parent_is_not_descendant" do
-    before with_tree: true do
-      @node1 = create(:home_page_node, locale: "en")
-      @node2 = create(:text_page_node, parent: @node1)
-      @node3 = create(:text_page_node, parent: @node2)
-      @node4 = create(:home_page_node, locale: "lv")
-
-      @node1.reload
-      @node2.reload
-      @node3.reload
-    end
-
-    it "is called during validations" do
-      expect( subject ).to receive(:validate_parent_is_not_descendant)
-      subject.valid?
-    end
-
-    context "when #parent_id matches #id of one of descadents", with_tree: true do
-      it "adds error on #parent_id" do
-        @node1.parent_id = @node3.id
-        @node1.send(:validate_parent_is_not_descendant)
-        expect( @node1.errors[:parent_id] ).to include "descendant can't be parent"
-      end
-    end
-
-    context "when parent is nil", with_tree: true do
-      it "does nothing" do
-        @node1.parent_id = nil
-        @node1.send(:validate_parent_is_not_descendant)
-        expect( @node1.errors[:parent_id] ).to be_blank
-      end
-    end
-
-    context "when there are no descadents with #id is #self#parent_id", with_tree: true do
-      it "does nothing" do
-        @node1.parent_id = @node4.id
-        @node1.send(:validate_parent_is_not_descendant)
-        expect( @node1.errors[:parent_id] ).to be_blank
-      end
-    end
-  end
-
-  describe "#prevent_auto_update_settings_timestamp" do
-    it "sets #prevent_auto_update_settings_timestamp? to true within block" do
-      expect do
-        subject.prevent_auto_update_settings_timestamp do
-          expect( subject.send(:prevent_auto_update_settings_timestamp?) ).to be_truthy
-        end
-      end.to_not change { subject.send(:prevent_auto_update_settings_timestamp?) }.from(false)
-    end
-  end
-
-  describe "#update_settings_timestamp" do
-    it "calls .updated" do
-      expect( Node ).to receive(:updated).and_call_original
-      subject.send(:update_settings_timestamp)
-    end
-
-    context "when #prevent_auto_update_settings_timestamp? is false" do
-      it "is called after save" do
-        node = FactoryGirl.build(:node)
-        allow( node ).to receive(:prevent_auto_update_settings_timestamp?).and_return(false)
-        expect( node ).to receive(:update_settings_timestamp).and_call_original
-        node.save!
-      end
-    end
-
-    context "when #prevent_auto_update_settings_timestamp? is true" do
-      it "is not called after save" do
-        node = FactoryGirl.build(:node)
-        allow( node ).to receive(:prevent_auto_update_settings_timestamp?).and_return(true)
-        expect( node ).to_not receive(:update_settings_timestamp)
-        node.save!
-      end
-    end
-  end
-
-  describe "#path" do
-    before do
-      allow(subject).to receive(:path_parts).and_return(["some", "bar", "foo"])
-    end
-
-    it "returns relative node path built ny joining node path parts" do
-      expect(subject.path).to eq("/some/bar/foo")
-    end
-
-    context "when node has parent" do
-      it "ads trailing slash to returned node path" do
-        allow(subject).to receive(:trailing_slash_for_path?).and_return(true)
-        expect(subject.path).to eq("/some/bar/foo/")
-      end
-    end
-  end
-
-
-  describe "#trailing_slash_for_path?" do
-    context "when rails route has trailing slash enabled" do
-      it "returns true" do
-        allow(Rails.application.routes).to receive(:default_url_options).and_return(trailing_slash: true)
-        expect(subject.trailing_slash_for_path?).to be true
-      end
-    end
-
-    context "when rails route has trailing slash disabled" do
-      it "returns false" do
-        allow(Rails.application.routes).to receive(:default_url_options).and_return({})
-        expect(subject.trailing_slash_for_path?).to be false
-      end
-    end
-  end
-
-  describe "#path_parts" do
-    it "returns array with slug" do
-      expect(subject.path_parts).to eq([""])
-      subject.slug = "foo"
-      expect(subject.path_parts).to eq(["foo"])
-    end
-
-    context "when node has parent" do
-      it "prepends parent path parts to returned array" do
-        parent = described_class.new
-        allow(parent).to receive(:path_parts).and_return(%w(some bar))
-
-        subject.slug = "foo"
-        subject.parent = parent
-        expect(subject.path_parts).to eq(["some", "bar", "foo"])
-      end
-    end
-  end
-end