releaf-content 0.2.1 → 1.0.3

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

@@ -35,23 +35,15 @@ describe ActsAsNode do
       end
     end
 
-    describe "#node" do
-      it "returns corresponding node object" do
-        allow_any_instance_of(Releaf::Content::Node::RootValidator).to receive(:validate)
-        node = create(:node, content_type: "Book", content_attributes: {title: "xx"})
-        expect(Book.last.node).to eq(node)
-      end
-    end
-
     context ".acts_as_node_params" do
       before do
-        allow_any_instance_of(Releaf::Core::ResourceParams).to receive(:values).and_return(["a", "b"])
+        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::Core::ResourceParams).to receive(:new).with(Book).and_call_original
+          expect(Releaf::ResourceParams).to receive(:new).with(Book).and_call_original
           expect(Book.acts_as_node_params).to eq(["a", "b", :id])
         end
       end
@@ -66,13 +58,13 @@ describe ActsAsNode do
 
     context ".acts_as_node_fields" do
       before do
-        allow_any_instance_of(Releaf::Core::ResourceFields).to receive(:values).and_return(["a", "b"])
+        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::Core::ResourceFields).to receive(:new).with(Book).and_call_original
+          expect(Releaf::ResourceFields).to receive(:new).with(Book).and_call_original
           expect(Book.acts_as_node_fields).to eq(["a", "b"])
         end
       end
@@ -85,16 +77,6 @@ describe ActsAsNode do
       end
     end
 
-    context ".nodes" do
-      it "loads tree nodes" do
-        expect(Node).to receive(:where).with(content_type: Book.name)
-        Book.nodes
-      end
-
-      it "returns relation" do
-        expect(Book.nodes.class).to eq(Node::ActiveRecord_Relation)
-      end
-    end
   end
 
   describe ActionController::Acts::Node do
@@ -104,15 +86,5 @@ describe ActsAsNode do
       end
     end
 
-    context ".nodes" do
-      it "loads tree nodes" do
-        expect(Node).to receive(:where).with(content_type: ContactFormController.name)
-        ContactFormController.nodes
-      end
-
-      it "returns array" do
-        expect(ContactFormController.nodes.class).to eq(Node::ActiveRecord_Relation)
-      end
-    end
   end
 end

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

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

@@ -0,0 +1,149 @@
+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/errors#page_not_found", "path" => "nodes/1")
+        expect(get: "/admin/other_nodes/1").to route_to("releaf/errors#page_not_found", "path" => "other_nodes/1")
+      end
+
+    end
+
+  end
+
+end

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

@@ -42,14 +42,14 @@ describe Node do
     context 'when #content_type is nil' do
       it 'returns nil' do
         subject.content_type = nil
-        expect( subject.content_class ).to be_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
+        expect( subject.content_class ).to be nil
       end
     end
 
@@ -121,8 +121,15 @@ describe Node do
 
   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 slug 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 slug created_at updated_at locale]
+      end
+    end
   end
 
   describe "#attributes_to_copy" do
@@ -142,76 +149,7 @@ describe Node do
     end
   end
 
-  describe "#save_under" do
-    let(:node1) { create(:node) }
-
-    it "saves node nuder node with given node_id" do
-      node2 = create(:text_page_node, parent: node1)
-
-      new_node = FactoryGirl.build(:text_page_node)
-      new_node.send(:save_under, node2.id)
-      expect( new_node ).to_not be_new_record
-      expect( new_node.parent ).to eq node2
-    end
-
-    it "maintains node name, updates slug and then saves record" do
-      new_node = FactoryGirl.build(:text_page_node)
-      expect( new_node ).to receive(:maintain_name).ordered.and_call_original
-      expect( new_node ).to receive(:reasign_slug).ordered.and_call_original
-      expect( new_node ).to receive(:save!).ordered.and_call_original
-      new_node.save_under(node1.id)
-    end
-
-    context "when #validate_root_locale_uniqueness? returns true" do
-      it "sets locale to nil" do
-        new_node = FactoryGirl.build(:node)
-        allow(new_node).to receive(:validate_root_locale_uniqueness?).and_return(true)
-        new_node.locale = 'xx'
-        expect { new_node.save_under(nil) }.to change { new_node.locale }.from('xx').to(nil)
-      end
-    end
-
-    context "when #validate_root_locale_uniqueness? returns false" do
-      it "doesn't set locale to nil" do
-        new_node = FactoryGirl.build(:node)
-        allow(new_node).to receive(:validate_root_locale_uniqueness?).and_return(false)
-        new_node.locale = 'xx'
-        expect { new_node.save_under(nil) }.to_not change { new_node.locale }.from('xx')
-      end
-    end
-
-  end
-
-
-  describe "#duplicate_content" do
-
-    context "when #content_id is blank" do
-      let(:node) { create(:node) }
-
-      it "returns nil" do
-        expect( node.duplicate_content ).to be_nil
-      end
-    end
-
-    context "when #content_id is not blank" do
-      let(:node) { create(:home_page_node) }
-
-      it "returns saved duplicated content" do
-        content = double('new content')
-        expect( content ).to receive(:save!)
-        expect( node ).to receive_message_chain(:content, :dup).and_return(content)
-        expect( node.duplicate_content ).to eq content
-      end
-
-      it "doesn't return same as original content" do
-        result = node.duplicate_content
-        expect( result ).to be_an_instance_of HomePage
-        expect( result.id ).to_not eq node.content_id
-      end
-    end
-  end
-
-  describe "#copy_attributes_from" do
+  describe "#assign_attributes_from" do
     let(:source_node) { create(:node, active: false) }
 
     it "copies #attributes_to_copy attributes" do
@@ -225,181 +163,11 @@ describe Node do
 
       new_node = Node.new
 
-      new_node.copy_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_truthy
-    end
-  end
-
-  describe "#duplicate_under!" do
-    let!(:source_node) { create(:node, locale: "lv") }
-    let!(:target_node) { create(:node, locale: "en") }
-
-    before do
-      allow_any_instance_of(Releaf::Content::Node::RootValidator).to receive(:validate)
-    end
-
-    it "creates duplicated node under target node" do
-      new_node = Node.new
-      duplicated_content = double('content', id: 1234)
-      expect( Node ).to receive(:new).ordered.and_return(new_node)
-      expect( new_node ).to receive(:copy_attributes_from).with(source_node).ordered.and_call_original
-      expect( source_node ).to receive(:duplicate_content).ordered.and_return(duplicated_content)
-      expect( new_node ).to receive(:content_id=).with(1234).ordered
-      expect( new_node ).to receive(:save_under).with(target_node.id).ordered.and_call_original
-      source_node.duplicate_under!(target_node.id)
-    end
+      new_node.assign_attributes_from source_node
 
-    it "doesn't update settings timestamp" do
-      expect( Node ).to_not receive(:updated)
-      source_node.duplicate_under!(target_node.id)
-    end
-  end
-
-  describe "#copy", create_nodes: true do
-    before create_nodes: true do
-      @home_page_node = create(:home_page_node, locale: "lv")
-      @home_page_node_2 = create(:home_page_node, locale: "en")
-      @text_page_node_3 = create(:text_page_node, parent_id: @home_page_node_2.id)
-      @text_page_node_4 = create(:text_page_node, parent_id: @text_page_node_3.id)
-      @text_page_node_5 = create(:text_page_node, parent_id: @text_page_node_4.id)
-
-      # 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 one of children becomes invalid" do
-      before do
-        @text_page_node_4.name = nil
-        @text_page_node_4.save(validate: false)
-      end
-
-      it "raises ActiveRecord::RecordInvalid" do
-        expect { @text_page_node_3.copy(@home_page_node.id) }.to raise_error ActiveRecord::RecordInvalid
-      end
-
-      it "raises error on node being copied" do
-        begin
-          @text_page_node_3.copy(@home_page_node.id)
-        rescue ActiveRecord::RecordInvalid => e
-          expect( e.record ).to eq @text_page_node_3
-        end
-        expect(@text_page_node_3.errors.messages).to eq(base: ["descendant invalid"])
-      end
-
-      it "doesn't create any new nodes" do
-        expect do
-          begin
-            @text_page_node_3.copy(@home_page_node.id)
-          rescue ActiveRecord::RecordInvalid
-          end
-        end.to_not change { Node.count }
-      end
-
-      it "doesn't update settings timestamp" do
-        expect( Node ).to_not receive(:updated)
-        begin
-          @text_page_node_3.copy(@home_page_node.id)
-        rescue ActiveRecord::RecordInvalid
-        end
-      end
-
-    end
-
-
-    context "with corect parent_id" do
-      it "creates node along with descendant nodes" do
-        expect{ @text_page_node_3.copy(@home_page_node.id) }.to change{ Node.count }.by( @text_page_node_3.descendants.size + 1 )
-      end
-
-      it "correctly copies attributes" do
-        allow( @text_page_node_3 ).to receive(:children).and_return([@text_page_node_4])
-        allow( @text_page_node_4 ).to receive(:children).and_return([@text_page_node_5])
-
-        @text_page_node_3.update_attribute(:active, false)
-        @text_page_node_4.update_attribute(:active, false)
-
-        allow( @text_page_node_3 ).to receive(:attributes_to_copy).and_return(["name", "parent_id", "content_type"])
-
-        expect( @text_page_node_3 ).to receive(:duplicate_under!).and_call_original.ordered
-        expect( @text_page_node_4 ).to receive(:duplicate_under!).and_call_original.ordered
-        expect( @text_page_node_5 ).to receive(:duplicate_under!).and_call_original.ordered
-
-        @text_page_node_3.copy(@home_page_node.id)
-
-        @node_2_copy = @home_page_node.children.first
-        @node_3_copy = @node_2_copy.children.first
-        @node_4_copy = @node_3_copy.children.first
-
-        # new nodes by default are active, however we stubbed
-        # #attributes_to_copy of @test_node_2 to not return active attribute
-        # Also we updated @test_node_2#active to be false.
-        # However copy is active, because active attribute wasn't copied
-        expect( @node_2_copy ).to be_active
-        # for copy of @text_page_node_3 active attribute was copied however, as it
-        # should have been
-        expect( @node_3_copy ).to_not be_active
-        expect( @node_4_copy ).to be_active
-
-        expect( @node_2_copy.name ).to eq @text_page_node_3.name
-        expect( @node_3_copy.name ).to eq @text_page_node_4.name
-        expect( @node_4_copy.name ).to eq @text_page_node_5.name
-      end
-
-      it "updates settings timestamp only once" do
-        expect( Node ).to receive(:updated).once.and_call_original
-        @text_page_node_3.copy(@home_page_node.id)
-      end
-
-      context "when parent_id is nil" do
-        it "creates new node" do
-          allow_any_instance_of(Releaf::Content::Node::RootValidator).to receive(:validate)
-          expect{ @text_page_node_3.copy(nil) }.to change{ Node.count }.by(3)
-        end
-      end
-
-      context "when copying root nodes", create_nodes: false do
-        context "when root locale uniqueness is validated" do
-          it "resets locale to nil" do
-            @text_page_node = create(:home_page_node, locale: 'en')
-            allow_any_instance_of(Node).to receive(:validate_root_locale_uniqueness?).and_return(true)
-            @text_page_node.copy(nil)
-            expect( Node.last.locale ).to eq nil
-          end
-        end
-
-        context "when root locale uniqueness is not validated" do
-          it "doesn't reset locale to nil" do
-            @text_page_node = create(:home_page_node, locale: 'en')
-            allow_any_instance_of(Node).to receive(:validate_root_locale_uniqueness?).and_return(false)
-            @text_page_node.copy(nil)
-            expect( Node.last.locale ).to eq 'en'
-          end
-        end
-      end
-    end
-
-    context "with nonexistent parent_id" do
-      it "raises ActiveRecord::RecordInvalid" do
-        expect { @text_page_node_3.copy(99991) }.to raise_error(ActiveRecord::RecordInvalid)
-      end
-    end
-
-    context "with same parent_id as node.id" do
-      it "raises ActiveRecord::RecordInvalid" do
-        expect{ @text_page_node_3.copy(@text_page_node_3.id) }.to raise_error(ActiveRecord::RecordInvalid)
-      end
-    end
-
-    context "when copying to child node" do
-      it "raises ActiveRecord::RecordInvalid" do
-        expect{ @text_page_node_3.copy(@text_page_node_4.id) }.to raise_error(ActiveRecord::RecordInvalid)
-      end
+      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
 
@@ -437,66 +205,10 @@ describe Node do
   end
 
   describe "#move" do
-    before do
-      @home_page_node = create(:home_page_node, locale: "lv")
-      @home_page_node_2 = create(:home_page_node, locale: "en")
-      @text_page_node_3 = create(:text_page_node, parent_id: @home_page_node_2.id)
-      @text_page_node_4 = create(:text_page_node, parent_id: @text_page_node_3.id)
-
-      # 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
+    it "calls Node move service" do
+      expect(Releaf::Content::Node::Move).to receive(:call).with(node: subject, parent_id: 12)
+      subject.move(12)
     end
-
-    context "when one of children becomes invalid" do
-      before do
-        @text_page_node_4.name = nil
-        @text_page_node_4.save(validate: false)
-      end
-
-      it "raises ActiveRecord::RecordInvalid" do
-        expect { @text_page_node_3.move(@home_page_node.id) }.to raise_error ActiveRecord::RecordInvalid
-      end
-
-      it "raises error on node being moved, even tought descendant has error" do
-        begin
-          @text_page_node_3.move(@home_page_node.id)
-        rescue ActiveRecord::RecordInvalid => e
-          expect( e.record ).to eq @text_page_node_3
-        end
-
-        expect(@text_page_node_3.errors.messages).to eq(name: [], base: ["descendant invalid"])
-      end
-    end
-
-    context "when moving existing node to other nodes child's position" do
-      it "changes parent_id" do
-        expect{ @text_page_node_3.move(@home_page_node.id) }.to change{ Node.find(@text_page_node_3.id).parent_id }.from(@home_page_node_2.id).to(@home_page_node.id)
-      end
-    end
-
-    context "when moving to self child's position" do
-      it "raises ActiveRecord::RecordInvalid" do
-        expect{ @text_page_node_3.move(@text_page_node_3.id) }.to raise_error(ActiveRecord::RecordInvalid)
-      end
-    end
-
-    context "when passing nil as target node" do
-      it "updates parent_id" do
-        allow_any_instance_of(Releaf::Content::Node::RootValidator).to receive(:validate)
-        @home_page_node.destroy
-        expect{ @text_page_node_3.move(nil) }.to change { Node.find(@text_page_node_3.id).parent_id }.to(nil)
-      end
-    end
-
-    context "when passing nonexistent target node's id" do
-      it "raises ActiveRecord::RecordInvalid" do
-        expect{ @text_page_node_3.move(998123) }.to raise_error(ActiveRecord::RecordInvalid)
-      end
-    end
-
   end
 
   describe "#maintain_name" do
@@ -719,20 +431,6 @@ describe Node do
     end
   end
 
-  describe "#add_error_and_raise" do
-    it "raises error" do
-      expect { subject.add_error_and_raise('test error') }.to raise_error(ActiveRecord::RecordInvalid)
-    end
-
-    it "adds record on base and raise ActiveRecord::RecordInvalid" do
-      begin
-        subject.add_error_and_raise('test error')
-      rescue ActiveRecord::RecordInvalid => e
-        expect( e.record.errors[:base] ).to include 'test error'
-      end
-    end
-  end
-
   describe "#prevent_auto_update_settings_timestamp" do
     it "sets #prevent_auto_update_settings_timestamp? to true within block" do
       expect do
@@ -769,11 +467,55 @@ describe Node do
   end
 
   describe "#path" do
-    it "returns relative path of node" do
-      node = described_class.new(slug: 'foo')
-      node2 = described_class.new(slug: 'bar', parent: node)
-      expect( node.path ).to eq '/foo'
-      expect( node2.path ).to eq '/foo/bar'
+    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