sinicum 0.5.0

data/spec/sinicum/jcr/node_spec.rb

@@ -0,0 +1,261 @@
+# encoding: utf-8
+require 'spec_helper'
+
+module Sinicum
+  module Jcr
+    describe Node do
+      context "should behave like an ActiveModel object" do
+        require 'test/unit/assertions'
+        require 'active_model/lint'
+        include Test::Unit::Assertions
+        include ActiveModel::Lint::Tests
+
+        before(:each) do
+          @model = Node.new
+        end
+
+        unless Rails.version =~ /^4\.1\./
+          ActiveModel::Lint::Tests.public_instance_methods.map { |m| m.to_s }.grep(/^test/)
+            .each do |m|
+            example m.gsub("_", " ") do
+              send(m)
+            end
+          end
+
+          it "should expose a singular and human name" do
+            @model.class.model_name.singular.should eq("sinicum_jcr_node")
+            @model.class.model_name.human.should eq("Node")
+          end
+        end
+
+        it "should use i18n for model_name.human" do
+          begin
+            I18n.backend.store_translations(
+              I18n.locale,
+              activemodel: {
+                models: {
+                  :'sinicum/jcr/node' => "A node name"
+                }
+              })
+            @model.class.model_name.human.should eq("A node name")
+          ensure
+            I18n.reload!
+          end
+        end
+      end
+
+      describe "basic properties after JSON initialization" do
+        let(:api_response) do
+          File.read(File.dirname(__FILE__) + "/../../fixtures/api/content_mgnl5.json")
+        end
+        let(:json_response) { MultiJson.load(api_response) }
+        let(:subject) { Node.new(json_response: json_response.first) }
+
+        its(:uuid) { should eq("684af75b-0504-467e-92ce-bea998cc8d8b") }
+        its(:jcr_path) { should eq("/home") }
+        its(:jcr_name) { should eq("home") }
+        its(:jcr_primary_type) { should eq("mgnl:page") }
+        its(:jcr_super_types) do should eq(
+          [
+            "mix:created", "mix:referenceable", "nt:base", "nt:hierarchyNode",
+            "mgnl:activatable", "mgnl:content", "mgnl:created", "mgnl:lastModified",
+            "mgnl:renderable", "mgnl:versionable"
+          ])
+        end
+        its(:jcr_mixin_node_types) { should eq([]) }
+        its(:jcr_workspace) { should eq("website") }
+        its(:jcr_depth) { should eq(1) }
+
+        unless defined?(JRUBY_VERSION)
+          its(:created_at) { should eq(DateTime.new(2014, 3, 16, 14, 6, 17.666, "+01:00")) }
+          its(:updated_at) { should eq(DateTime.new(2014, 3, 18, 15, 57, 51.329, "+01:00")) }
+        end
+
+        its(:mgnl_template) { should eq("themodule:pages/appplication") }
+        its(:mgnl_created_by) { should eq("superuser") }
+      end
+
+      describe "handling of properties" do
+        let(:api_response) do
+          File.read(File.dirname(__FILE__) + "/../../fixtures/api/homepage.json")
+        end
+        let(:json_response) { MultiJson.load(api_response) }
+        let(:subject) { Node.new(json_response: json_response.first) }
+
+        it "should return the correct title" do
+          subject[:title].should eq("Shure: Mikrofone, Funkmikrofone, Ohrhörer")
+          subject[:boolean_true_test].should be true
+        end
+
+        it "should be possible to use symbol and string keys interchangeably" do
+          subject[:title].should eq("Shure: Mikrofone, Funkmikrofone, Ohrhörer")
+          subject["title"].should eq("Shure: Mikrofone, Funkmikrofone, Ohrhörer")
+        end
+      end
+
+      describe "handling of child nodes" do
+        let(:api_response) do
+          File.read(File.dirname(__FILE__) + "/../../fixtures/api/homepage.json")
+        end
+        let(:json_response) { MultiJson.load(api_response) }
+        let(:subject) { Node.new(json_response: json_response.first) }
+
+        it "should return a child node and resolve an array" do
+          children = subject[:orc_13]
+          children.should be_kind_of(Array)
+        end
+
+        it "should return the correct child node" do
+          children = subject[:orc_13]
+          children.first.jcr_path.should eq("/home/orc_13/0")
+        end
+
+        it "should return nodes in multiple steps" do
+          picture_teaser = subject[:orc_13].first[:picture_teaser_items].first
+          picture_teaser[:link_text].should eq("more")
+        end
+
+        it "should return non-array child nodes" do
+          picture_teaser = subject[:orc_13].first[:picture_teaser_items].first
+          text_files_node = picture_teaser[:text_files]
+          text_files_node.should be_kind_of(Node)
+          text_files_node.jcr_path.should eq("/home/orc_13/0/picture_teaser_items/0/text_files")
+        end
+
+        it "should be possible to call a node multiple times" do
+          children = subject[:orc_13]
+          children.should_not be_nil
+          subject[:orc_13].should eq(children)
+        end
+      end
+
+      describe "parent handling" do
+        let(:api_response) do
+          File.read(File.dirname(__FILE__) + "/../../fixtures/api/homepage_parent.json")
+        end
+        let(:api_response2) do
+          File.read(File.dirname(__FILE__) + "/../../fixtures/api/homepage.json")
+        end
+        let(:json_response) { MultiJson.load(api_response) }
+        let(:subject) { Node.new(json_response: json_response) }
+
+        it "should return its parent node as an Array" do
+          body = { body: "should not be triggered because of cache" }
+          stub_request(:get, "http://content.dievision.de/sinicum-rest/website/home/orc_13")
+            .to_return(body: api_response, headers: { "Content-Type" => "application/json" })
+            .times(1).then.to_return(body)
+          stub_request(:get, "http://content.dievision.de/sinicum-rest/website/home")
+            .to_return(body: api_response2, headers: { "Content-Type" => "application/json" })
+
+          node = subject[0]
+          node.parent.uuid.should eq(subject.uuid)
+          node.parent.parent.uuid.should eq('21cbc762-bdcd-4520-9eff-1928986fb419')
+        end
+      end
+
+      describe "Type conversion" do
+        describe "date conversion" do
+          it "should properly convert a iso 8601 time string" do
+            time = subject.send(:jcr_time_string_to_datetime, "2010-04-13T09:35:01.322+02:00")
+            time.year.should eq(2010)
+            time.month.should eq(4)
+            time.day.should eq(13)
+            time.hour.should eq(9)
+            time.minute.should eq(35)
+            time.second.should eq(1)
+            time.zone.should eq("+02:00")
+          end
+
+          it "should return the original string if it is not an iso8601 format" do
+            time = subject.send(:jcr_time_string_to_datetime, "2010-04-13F09:35:01.322+02:00")
+            time.should eq("2010-04-13F09:35:01.322+02:00")
+          end
+
+          it "should handle null values" do
+            time = subject.send(:jcr_time_string_to_datetime, nil)
+            time.should be nil
+          end
+
+          it "should convert Magnolia's Date notation: e.g. 2013-06-05T22:00:00.000Z"
+        end
+
+        describe "boolean conversion" do
+          it "should not touch strings" do
+            value = subject.send(:mgnl_boolean_string_to_boolean, "Some string")
+            value.should eq("Some string")
+          end
+
+          it "should convert true values" do
+            value = subject.send(:mgnl_boolean_string_to_boolean, "true")
+            value.should be true
+          end
+
+          it "should convert false values" do
+            value = subject.send(:mgnl_boolean_string_to_boolean, "false")
+            value.should be false
+          end
+        end
+      end
+
+      describe "persistence" do
+        it "should not be persisted as a new node" do
+          node = Node.new
+          node.should_not be_persisted
+        end
+
+        it "should be persisted if constructed from an api response" do
+          api_response = File.read(File.dirname(__FILE__) + "/../../fixtures/api/homepage.json")
+          node = Node.new(json_response: api_response)
+          node.should be_persisted
+        end
+      end
+
+      describe "initialize from hash" do
+        it "should set a property" do
+          node = Node.new(name: "A name")
+          node[:name].should eq("A name")
+        end
+
+        it "should not be possible to set 'forbidden' JCR properties" do
+          Node::PROHIBITED_JCR_PROPERTIES.each do |prop|
+            expect { Node.new(prop => "value") }.to raise_error
+          end
+        end
+
+        it "should not be possible to set 'forbidden' Manglia properties" do
+          Node::PROHIBITED_MGNL_PROPERTIES.each do |prop|
+            expect { Node.new(prop => "value") }.to raise_error
+          end
+        end
+
+        it "should directly set allowed JCR properties" do
+          Node::SETABLE_JCR_PROPERTIES.each do |prop|
+            node = Node.new(prop => "value")
+            node.send(prop).should eq("value")
+          end
+        end
+
+        it "should should not set a hash-based value for a directly allowed JCR property" do
+          Node::SETABLE_JCR_PROPERTIES.each do |prop|
+            node = Node.new(prop => "value")
+            node[prop].should be_nil
+          end
+        end
+
+        it "should directly set allowed Magnolia properties" do
+          Node::SETABLE_MGNL_PROPERTIES.each do |prop|
+            node = Node.new(prop => "value")
+            node.send(prop).should eq("value")
+          end
+        end
+
+        it "should should not set a hash-based value for a directly allowed Magnolia property" do
+          Node::SETABLE_MGNL_PROPERTIES.each do |prop|
+            node = Node.new(prop => "value")
+            node[prop].should be_nil
+          end
+        end
+      end
+    end
+  end
+end

data/spec/sinicum/jcr/query_sanitizer_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module Sinicum
+  module Jcr
+    describe QuerySanitizer do
+      let(:mock_class) { Class.new { include QuerySanitizer } }
+      subject { mock_class.new }
+
+      it "should not touch a query if no parameters are given" do
+        subject.send(:sanitize_query, "xpath", "query").should eq("query")
+      end
+
+      it "should not touch a query if empty parameters are given" do
+        subject.send(:sanitize_query, "xpath", "query", {}).should eq("query")
+      end
+
+      it "should sanitize a sql query" do
+        query = "select * from microphone where lower(url_path) = ':name' " \
+          "and jcr:path like '/products/microphones/en/%'"
+        result = subject.send(:sanitize_query, "xpath", query, name: "A name")
+        result.should eq("select * from microphone where lower(url_path) = 'A name' " \
+          "and jcr:path like '/products/microphones/en/%'")
+      end
+    end
+  end
+end

data/spec/sinicum/jcr/type_translator_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+module Sinicum
+  module Jcr
+    describe TypeTranslator do
+      let(:first_translator) { Class.new }
+      let(:second_translator) { Class.new }
+      let(:third_translator) { Class.new }
+      let(:fourth_translator) { Class.new }
+
+      before(:each) { TypeTranslator.clear }
+      after(:each) { TypeTranslator.reset }
+
+      it "should add a new translator to the translator stack" do
+        TypeTranslator.use(first_translator)
+        TypeTranslator.use(second_translator)
+        TypeTranslator.list.should eq([second_translator, first_translator])
+      end
+
+      it "should reset the stack" do
+        TypeTranslator.clear
+        TypeTranslator.reset
+        TypeTranslator.list.should eq(TypeTranslator::DEFAULT_TRANSLATORS)
+      end
+
+      describe "swapping" do
+        let(:new_translator) { Class.new }
+
+        before(:each) do
+          [first_translator, second_translator, third_translator, fourth_translator].each do |t|
+            TypeTranslator.use(t)
+          end
+        end
+
+        it "should clear the stack" do
+          TypeTranslator.clear
+          TypeTranslator.list.should eq([])
+        end
+      end
+    end
+  end
+end

data/spec/sinicum/jcr/type_translators/component_translator_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+module Sinicum
+  module Jcr
+    module TypeTranslators
+      describe ComponentTranslator do
+        let(:mock_class) do
+          Class.new do
+            def initialize(options)
+            end
+          end
+        end
+
+        [:mgnl4, :mgnl5].each do |mgnl_version|
+          it "should return nothing for a default node in #{mgnl_version}" do
+            result = ComponentTranslator.initialize_node(
+              read_default_node_json("website", "mgnl:contentNode", nil, mgnl_version))
+            result.should be nil
+          end
+
+          it "should return a page for a page instance in #{mgnl_version}" do
+            json = read_default_node_json(
+                      "website",
+                      "mgnl:page",
+                      "myModule:pages/homepage",
+                      mgnl_version)
+            stub_const("MyModule::Pages::Homepage", mock_class)
+
+            result = ComponentTranslator.initialize_node(json)
+            result.should be_kind_of(mock_class)
+          end
+
+          it "should handle module names with dashes in #{mgnl_version}" do
+            json = read_default_node_json(
+                      "website",
+                      "mgnl:page",
+                      "myModule:pages/homepage",
+                      mgnl_version)
+            stub_const("MyModule::Pages::Homepage", mock_class)
+
+            result = ComponentTranslator.initialize_node(json)
+            result.should be_kind_of(mock_class)
+          end
+
+          it "should return nothing if a page class is not defined in #{mgnl_version}" do
+            json = read_default_node_json(
+                      "website",
+                      "mgnl:page",
+                      "myModule:pages/homepage",
+                      mgnl_version)
+
+            result = ComponentTranslator.initialize_node(json)
+            result.should be nil
+          end
+
+          it "should return a page for a component instance in #{mgnl_version}" do
+            json = read_default_node_json(
+                      "website",
+                      "mgnl:component",
+                      "myModule:components/path/teaser",
+                      mgnl_version)
+            stub_const("MyModule::Components::Path::Teaser", mock_class)
+
+            result = ComponentTranslator.initialize_node(json)
+            result.should be_kind_of(mock_class)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/sinicum/jcr/type_translators/data_translator_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+module Sinicum
+  module Jcr
+    module TypeTranslators
+      describe ComponentTranslator do
+        let(:mock_class) do
+          Class.new do
+            def initialize(options)
+            end
+          end
+        end
+        let(:api_response) do
+          File.read(File.dirname(__FILE__) +
+          "/../../../fixtures/api/product.json")
+        end
+
+        let(:json) { MultiJson.load(api_response).first }
+
+        it "should return nothing for a default node" do
+          result = DataTranslator.initialize_node(read_default_node_json)
+          result.should be nil
+        end
+
+        it "should return a default node when no matching class exists" do
+          result = DataTranslator.initialize_node(json)
+          result.should be nil
+        end
+
+        it "should initialize a new class based on the node's primary type" do
+          stub_const("Microphone", mock_class)
+          result = DataTranslator.initialize_node(json)
+          result.should be_kind_of(mock_class)
+        end
+      end
+    end
+  end
+end

data/spec/sinicum/jcr/type_translators/default_translator_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+module Sinicum
+  module Jcr
+    module TypeTranslators
+      describe DefaultTranslator do
+        it "should return a Node instance" do
+          result = DefaultTranslator.initialize_node(read_default_node_json)
+          result.class.should eq(::Sinicum::Jcr::Node)
+        end
+
+        it "should return a properly initialized instance" do
+          result = DefaultTranslator.initialize_node(read_default_node_json)
+          result.uuid.should eq("21cbc762-bdcd-4520-9eff-1928986fb419")
+        end
+      end
+    end
+  end
+end