sinicum 0.5.0

data/spec/sinicum/imaging/max_size_converter_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+
+module Sinicum
+  module Imaging
+    describe MaxSizeConverter do
+      describe "#converted_size" do
+        def image(x, y)
+          image = double("image")
+          image.stub(:width).and_return(x)
+          image.stub(:height).and_return(y)
+          image
+        end
+
+        it "should rescale a landscape image correctly to a landscape format" do
+          converter = MaxSizeConverter.new("x" => 57, "y" => 42)
+          converter.document = image(192, 110)
+          converter.converted_size.should == [57, 33]
+        end
+
+        it "should rescale a portrait image correctly to a landscape format" do
+          converter = MaxSizeConverter.new("x" => 57, "y" => 42)
+          converter.document = image(110, 192)
+          converter.converted_size.should == [24, 42]
+        end
+
+        it "should rescale a portrait image correctly to a portrait format" do
+          converter = MaxSizeConverter.new("x" => 42, "y" => 57)
+          converter.document = image(110, 192)
+          converter.converted_size.should == [33, 57]
+        end
+
+        it "should rescale a landscape image correctly to a portrait format" do
+          converter = MaxSizeConverter.new("x" => 42, "y" => 57)
+          converter.document = image(192, 110)
+          converter.converted_size.should == [42, 24]
+        end
+
+        it "should rescale to the same format" do
+          converter = MaxSizeConverter.new("x" => 308, "y" => 800)
+          converter.document = image(308, 125)
+          converter.converted_size.should == [308, 125]
+        end
+
+        it "should rescale an image even if the configuration has no 'y' information" do
+          converter = MaxSizeConverter.new("x" => 57)
+          converter.document = image(192, 110)
+          converter.converted_size.should == [57, 33]
+        end
+      end
+    end
+  end
+end

data/spec/sinicum/imaging/resize_crop_converter_spec.rb

@@ -0,0 +1,18 @@
+require "spec_helper"
+module Sinicum
+  module Imaging
+    describe ResizeCropConverter do
+
+      it "should require the arguments format, x, y" do
+        config = { "format" => "jpeg", "x" => "200", "y" => "300" }
+        conv = ResizeCropConverter.new(config)
+        config = { "format" => "jpeg", "x" => "200" }
+        expect { conv = ResizeCropConverter.new(config) }.to raise_error(ArgumentError)
+        config = { "format" => "jpeg", "y" => "300" }
+        expect { conv = ResizeCropConverter.new(config) }.to raise_error(ArgumentError)
+        config = { "x" => "200", "y" => "300" }
+        expect { conv = ResizeCropConverter.new(config) }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end

data/spec/sinicum/imaging_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+module Sinicum
+  describe Imaging do
+    it "should return the default converter name" do
+      Imaging.default_converter_name.should eq("default")
+    end
+
+    it "should return the imaging path" do
+      Imaging.path_prefix.should eq("/damfiles")
+    end
+  end
+end

data/spec/sinicum/jcr/api_client_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+module Sinicum
+  module Jcr
+    describe ApiClient do
+      mock_api_client_class = Class.new do
+        include ApiClient
+      end
+
+      let(:subject) { mock_api_client_class.new }
+      let(:http_client) { double :http_client }
+      let(:response) { double :response }
+
+      let(:host) { "content.dievision.de" }
+      let(:client_base_url) { "http://content.dievision.de/sinicum-rest" }
+
+      before(:each) do
+        ApiQueries.configure_jcr = { host: host }
+      end
+
+      describe "GET" do
+        it "should delegate to the ApiQueries get method" do
+          path = "/path/to/url"
+
+          ApiQueries.should_receive(:http_client).and_return(http_client)
+          http_client.should_receive(:get).with(
+            client_base_url + path).and_return(response)
+
+          subject.api_get(path)
+        end
+
+        it "should delegate to the ApiQueries post method with query parameters" do
+          path = "/path/to/url"
+          query = { query: { param: "value" } }
+
+          ApiQueries.should_receive(:http_client).and_return(http_client)
+          http_client.should_receive(:get).with(
+            client_base_url + path, query).and_return(response)
+
+          subject.api_get(path, query)
+        end
+      end
+
+      describe "POST" do
+
+        it "should delegate to the ApiQueries post method" do
+          path = "/path/to/url"
+
+          ApiQueries.should_receive(:http_client).and_return(http_client)
+          http_client.should_receive(:post).with(
+            client_base_url + path).and_return(response)
+
+          subject.api_post(path)
+        end
+
+        it "should delegate to the ApiQueries post method with query parameters" do
+          path = "/path/to/url"
+          query = { query: { param: "value" } }
+
+          ApiQueries.should_receive(:http_client).and_return(http_client)
+          http_client.should_receive(:post).with(
+            client_base_url + path, query).and_return(response)
+
+          subject.api_post(path, query)
+        end
+      end
+    end
+  end
+end

data/spec/sinicum/jcr/cache/global_cache_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+module Sinicum
+  module Jcr
+    module Cache
+      describe GlobalCache do
+        let(:prefix) { "http://content.dievision.de:80/sinicum-rest" }
+        let(:api_response) do
+          File.read(File.dirname(__FILE__) + "/../../../fixtures/api/cache_global.json")
+        end
+
+        before(:each) do
+          ::Sinicum::Jcr::ApiQueries.configure_jcr = { host: "content.dievision.de" }
+        end
+
+        before(:each) do
+          stub_request(:get, "#{prefix}/_cache/global").to_return(
+            body: api_response,
+            headers: { "Content-Type" => "application/json" }
+          )
+        end
+
+        it "should return the current key" do
+          GlobalCache.new.current_key.should eq("a11cd0d31248427cbadfd8a7bc51e04e96e4de98")
+        end
+      end
+    end
+  end
+end

data/spec/sinicum/jcr/dam/document_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+module Sinicum
+  module Jcr
+    module Dam
+      describe Document do
+        let(:api_response) do
+          File.read(File.dirname(__FILE__) + "/../../../fixtures/api/file_mgnl5.json")
+        end
+        let(:json) { MultiJson.load(api_response).first }
+
+        subject do
+          ::Sinicum::Jcr::NodeInitializer.initialize_node_from_json(json)
+        end
+
+        describe "when created from JSON" do
+          it { should be_kind_of Document }
+          its(:name) { should eq("Tecnotes_18_Sommer_10") }
+          its(:subject) { should eq("TecNotes Ausgabe 18, Sommer 2010") }
+          its(:description) { should eq("Some Description") }
+          its(:file_size) { should eq(562_116_5) }
+          its(:file_name) { should eq("Tecnotes_18_Sommer_10.pdf") }
+          its(:mime_type) { should eq("application/pdf") }
+        end
+
+        describe "date" do
+          it "should have the correct date when 'date1' is given" do
+            subject.date.should eq(Date.new(2013, 06, 05))
+          end
+
+          it "should have the correct date when 'date1' is not defined" do
+            subject.stub(:[]).with(:date1).and_return(nil)
+            unless defined?(JRUBY_VERSION)
+              subject.date.should eq(DateTime.new(2010, 7, 27, 14, 41, 4.105, "+0200"))
+            end
+          end
+        end
+
+        it "should return a web-compatible path" do
+          subject.path.should eq(
+            "/damfiles/default/shure/support_downloads/education/tecnotes/Tecnotes_18_Sommer_10" \
+            "-79209c1a63d7435f3f2179e31c104ef8.pdf")
+        end
+
+        it "should accept a 'converter_name' argument to specify the converter" do
+          subject.path(converter: "some_converter").should eq(
+            "/damfiles/some_converter/shure/support_downloads/education/tecnotes/" \
+            "Tecnotes_18_Sommer_10-79209c1a63d7435f3f2179e31c104ef8.pdf")
+        end
+
+        describe "fingerprint" do
+          let(:default_fingerprint) { "79209c1a63d7435f3f2179e31c104ef8" }
+
+          its(:fingerprint) { should eq(default_fingerprint) }
+
+          it "should depend on the path" do
+            subject.stub(:jcr_path).and_return("different")
+            subject.send(:fingerprint).should_not eq(default_fingerprint)
+            subject.send(:fingerprint).should =~ /^[a-f0-9]{32}$/
+          end
+
+          it "should depend on the id" do
+            subject.stub(:id).and_return("different")
+            subject.send(:fingerprint).should_not eq(default_fingerprint)
+            subject.send(:fingerprint).should =~ /^[a-f0-9]{32}$/
+          end
+
+          it "should depend on the various other attributes" do
+            doc = double("document")
+            doc.stub(:[]).with(:"jcr:lastModified").and_return("different")
+            doc.stub(:[]).with(:"jcr:lastModifiedBy").and_return("different")
+            doc.stub(:[]).with(:size).and_return("different")
+            subject.stub(:[]).with(:'jcr:content').and_return(doc)
+            subject.send(:fingerprint).should_not eq(default_fingerprint)
+            subject.send(:fingerprint).should =~ /^[a-f0-9]{32}$/
+          end
+        end
+      end
+    end
+  end
+end

data/spec/sinicum/jcr/dam/image_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+module Sinicum
+  module Jcr
+    module Dam
+      describe Document do
+        let(:api_response) do
+          File.read(File.dirname(__FILE__) + "/../../../fixtures/api/image_mgnl5.json")
+        end
+        let(:json) { MultiJson.load(api_response).first }
+
+        subject do
+          ::Sinicum::Jcr::NodeInitializer.initialize_node_from_json(json)
+        end
+
+        describe "when created from JSON" do
+          it { should be_kind_of Image }
+          it { should be_kind_of Document }
+          its(:width) { should eq(300) }
+          its(:height) { should eq(110) }
+        end
+
+        describe "alt tag" do
+          it "should take the alt attribute from the subject" do
+            subject.alt.should eq("A subject")
+          end
+
+          it "should return an empty string if no subject is given" do
+            subject.stub(:[]).with(:subject).and_return(nil)
+            subject.alt.should eq("")
+          end
+        end
+
+        describe "height and width" do
+          it "should consider a converter for the width" do
+            subject.width("teaser").should eq(960)
+          end
+
+          it "should consider a converter for the height" do
+            subject.height("teaser").should eq(444)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/sinicum/jcr/jcr_configuration_spec.rb

@@ -0,0 +1,57 @@
+module Sinicum; end
+require_relative '../../../lib/sinicum/jcr/jcr_configuration'
+
+module Sinicum
+  module Jcr
+    describe JcrConfiguration do
+      it "should respect the configuration parameters" do
+        config = JcrConfiguration.new(
+          host: "some.host", port: "8080", protocol: "https",
+          path_prefix: "/some_prefix", username: "user", password: "pass"
+        )
+        config.host.should eq("some.host")
+        config.port.should eq("8080")
+        config.protocol.should eq("https")
+        config.path_prefix.should eq("/some_prefix")
+        config.username.should eq("user")
+        config.password.should eq("pass")
+      end
+
+      it "should add a / to the path prefix if not automatically given" do
+        subject.path_prefix = "some_prefix"
+        subject.path_prefix.should eq("/some_prefix")
+      end
+
+      it "should not add a / to the path prefix if it does not exist in the configuration" do
+        subject.path_prefix = "/some_prefix"
+        subject.path_prefix.should eq("/some_prefix")
+      end
+
+      it "should construct a right base url only with the mininum parameters" do
+        config = JcrConfiguration.new
+        config.base_url.should eq("http://localhost/sinicum-rest")
+      end
+
+      it "should construct a right base_proto_host_port only with the mininum parameters" do
+        config = JcrConfiguration.new
+        config.base_proto_host_port.should eq("http://localhost")
+      end
+
+      it "should respect the various configuration parameters" do
+        config = JcrConfiguration.new(
+          host: "some.host", port: "8443", protocol: "https",
+          path_prefix: "some_prefix", username: "user", password: "pass"
+        )
+        config.base_url.should eq("https://some.host:8443/some_prefix")
+      end
+
+      it "should respect the varios configuration parameters for the host part" do
+        config = JcrConfiguration.new(
+          host: "some.host", port: "8443", protocol: "https",
+          path_prefix: "some_prefix", username: "user", password: "pass"
+        )
+        config.base_proto_host_port.should eq("https://some.host:8443")
+      end
+    end
+  end
+end

data/spec/sinicum/jcr/mgnl4_compatibility_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+module Sinicum
+  module Jcr
+    describe Mgnl4Compatibility do
+      it "should return a value for authorid"
+      it "should return a value for activatorid"
+    end
+  end
+end

data/spec/sinicum/jcr/node_queries_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+require 'digest/md5'
+
+module Sinicum
+  module Jcr
+    describe NodeQueries do
+      let(:api_response) { File.read(File.dirname(__FILE__) + "/../../fixtures/api/homepage.json") }
+      let(:json_response) { MultiJson.load(api_response) }
+      let(:prefix) { "http://content.dievision.de:80/sinicum-rest" }
+
+      before(:each) do
+        ApiQueries.configure_jcr = { host: "content.dievision.de" }
+      end
+
+      describe "web access" do
+        before(:each) do
+          stub_request(:get, "#{prefix}/website/home")
+            .to_return(body: api_response, headers: { "Content-Type" => "application/json" })
+          stub_request(:get, "#{prefix}/website/_uuid/21cbc762-bdcd-4520-9eff-1928986fb419")
+            .to_return(body: api_response, headers: { "Content-Type" => "application/json" })
+        end
+
+        xit "should query for a node by path" do
+          Node.should_receive(:new).with(json_response: json_response.first)
+          result = Node.find_by_path("website", "home")
+          result.should be_a(Sinicum::Jcr::Node)
+        end
+
+        xit "should query for a node by uuid" do
+          Node.should_receive(:new).with(json_response: json_response.first)
+          result = Node.find_by_uuid("website", "21cbc762-bdcd-4520-9eff-1928986fb419")
+          result.should be_a(Sinicum::Jcr::Node)
+        end
+      end
+
+      describe "authentication" do
+        it "should use no authentication if no user and password is configured" do
+          stub_request(:get, "#{prefix}/website/home")
+            .to_return(body: api_response, headers: { "Content-Type" => "application/json" })
+          Node.should_receive(:new).with(json_response: json_response.first)
+
+          Node.find_by_path("website", "home")
+        end
+
+        it "should use no authentication if no user and password is configured" do
+          stub_request(:get, "user:pass@content.dievision.de/sinicum-rest/website/home")
+            .to_return(body: api_response, headers: { "Content-Type" => "application/json" })
+          ApiQueries.configure_jcr = {
+            host: "content.dievision.de",
+            username: "user",
+            password: "pass"
+          }
+          Node.should_receive(:new).with(json_response: json_response.first)
+
+          Node.find_by_path("website", "home")
+        end
+      end
+
+      describe "streaming" do
+        it "should construct the right url for streaming an attribute and stream the content" do
+          pending "The actual test seems wrong"
+          begin
+            image_file = File.join(File.dirname(__FILE__), "..", "..", "fixtures", "mock_image.gif")
+            tmp_file = File.join(File.dirname(__FILE__), "..", "..", "fixtures", "tmp.gif")
+            stub_request(:get, "http://content.dievision.de/sinicum-rest/dam/_binary/some/path")
+              .with(query: { "property" => "jcr:data" }).to_return(body: File.new(image_file))
+
+            target = File.open(tmp_file, "wb")
+            Node.stream_attribute(
+              "dam", "/some/path", "jcr:data", File.open(tmp_file, "wb")
+            )
+            WebMock.should have_requested(
+              :get,
+              "http://content.dievision.de/sinicum-rest/dam/_binary/some/path"
+            ).with(query: { "property" => "jcr:data" })
+            target.close
+
+            Digest::MD5.hexdigest(File.read(tmp_file)).should eq(
+              Digest::MD5.hexdigest(File.read(tmp_file)))
+          ensure
+            File.delete(tmp_file) if File.exist?(tmp_file)
+          end
+        end
+      end
+
+      describe "queries" do
+        let(:api_response) do
+          File.read(File.dirname(__FILE__) + "/../../fixtures/api/query_result.json")
+        end
+        let(:json_response) { MultiJson.load(api_response) }
+
+        before(:each) do
+          stub_request(
+            :get,
+            "http://content.dievision.de/sinicum-rest/website/_query?" \
+            "query=/jcr:root/path//element(*, mgnl:page)&language=xpath"
+          ).to_return(
+            status: 200,
+            body: api_response,
+            headers: { "Content-Type" => "application/json" }
+          )
+        end
+
+        it "should return results based on a query" do
+          Node.should_receive(:new).with(json_response: json_response.first)
+          Node.should_receive(:new).with(json_response: json_response.last)
+          result = Node.query("website", :xpath, "/jcr:root/path//element(*, mgnl:page)")
+          result.should be_kind_of(Array)
+        end
+      end
+    end
+  end
+end