sinicum 0.5.0

data/spec/sinicum/content/aggregator_spec.rb

@@ -0,0 +1,91 @@
+require "spec_helper"
+
+module Sinicum
+  module Content
+    describe "Content Thread local functionality" do
+      it "should return the original content as content data" do
+        Aggregator.original_content = "content"
+        Aggregator.content_data.should == "content"
+      end
+
+      it "should implicitly reset all stacks if original content is called" do
+        Aggregator.should_receive(:clean)
+        Aggregator.original_content = "original_content"
+      end
+
+      it "should return an empty hash if no content node with the respective name exists" do
+        Aggregator.original_content = {}
+        Aggregator.push_content_node(:no_valid_name) do
+          Aggregator.content_data.should == {}
+        end
+        Aggregator.clean
+      end
+
+      it "should clean the stack" do
+        Aggregator.original_content = "content"
+        Thread.current[:__cms_stack] = "other content"
+        Aggregator.clean
+        Aggregator.original_content.should.nil?
+        Thread.current[:__cms_stack].should.nil?
+      end
+
+      it "should push a paragraph name" do
+        Aggregator.push_content_node("some_name") do
+          Aggregator.content_node.should eq("some_name")
+        end
+      end
+
+      describe "current content" do
+        it "should push current content" do
+          Aggregator.original_content = "original"
+          in_block = false
+          Aggregator.push_current_content("local") do
+            Aggregator.content_data.should eq("local")
+            in_block = true
+          end
+          Aggregator.content_data.should eq("original")
+          in_block.should be_true
+        end
+      end
+
+      describe "current page" do
+        before(:each) do
+          Aggregator.clean
+          @original_page = Sinicum::Jcr::Node.new
+          @new_page = Sinicum::Jcr::Node.new
+          Aggregator.original_content = @original_page
+        end
+
+        it "should return the original page if no active page has been set explicitly" do
+          Aggregator.active_page.should == @original_page
+        end
+
+        it "should push the new content on top of the active page stack" do
+          Aggregator.push_active_page(@new_page) do
+            Aggregator.active_page.should == @new_page
+          end
+        end
+
+        it "should restore the active page after the push" do
+          Aggregator.push_active_page(@new_page) do
+            # nothing
+          end
+          Aggregator.active_page.should == @original_page
+        end
+
+        it "should make the new active page the current content_data object" do
+          Aggregator.push_active_page(@new_page) do
+            Aggregator.content_data.should == @new_page
+          end
+        end
+
+        it "should restore the content data object after the push" do
+          Aggregator.push_active_page(@new_page) do
+            # nothing
+          end
+          Aggregator.content_data.should == @original_page
+        end
+      end
+    end
+  end
+end

data/spec/sinicum/content/website_content_resolver_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+module Sinicum
+  module Content
+    describe WebsiteContentResolver do
+      it "should fetch the content matching the path" do
+        node = double(:node)
+        Sinicum::Jcr::Node.should_receive(:find_by_path).with(:website, "/home").and_return(node)
+        result = WebsiteContentResolver.find_for_path("/home")
+        result.should eq(node)
+      end
+    end
+  end
+end

data/spec/sinicum/imaging/config_spec.rb

@@ -0,0 +1,50 @@
+require "spec_helper"
+
+module Sinicum
+  module Imaging
+    describe Config do
+      test_config = File.join(File.dirname(__FILE__), "imaging.yml")
+
+      before(:each) do
+        @tmpdir = File.join("/", "tmp", "imaging")
+        FileUtils.mkdir(@tmpdir) unless File.exist?(@tmpdir)
+      end
+
+      after(:each) do
+        FileUtils.rm_r(@tmpdir) if File.exist?(@tmpdir)
+      end
+
+      it "should not initialize if not yet configured" do
+        expect { Config.instance }.to raise_error(RuntimeError, /config/)
+      end
+
+      it "should use the correct configuration file" do
+        config = Config.configure(test_config)
+        config.send(:config_file).should == test_config
+      end
+
+      it "should set the right root directory" do
+        config = Config.configure(test_config)
+        config.root_dir.should == @tmpdir.to_s
+      end
+
+      it "should store all files under the root dir" do
+        config = Config.configure(test_config)
+        config.file_dir.should =~ /#{config.root_dir}\/.+/
+        config.tmp_dir.should =~ /#{config.root_dir}\/.+/
+        config.version_file.should =~ /#{config.root_dir}\/.+/
+      end
+
+      it "should return the default converter if no valid renderer is given" do
+        config = Config.configure(test_config)
+        config.converter(:inexistent).should be_a DefaultConverter
+      end
+
+      it "should return the right converter" do
+        config = Config.configure(test_config)
+        config.converter(:slideshow_thumbs).should be_a ResizeCropConverter
+        config.converter(:margin_column).should be_a MaxSizeConverter
+      end
+    end
+  end
+end

data/spec/sinicum/imaging/converter_spec.rb

@@ -0,0 +1,41 @@
+require "spec_helper"
+
+module Sinicum
+  module Imaging
+    describe Converter do
+      let(:conv) do
+        clazz = Class.new do
+          include Converter
+
+          def initialize(configuration)
+            super(configuration)
+          end
+        end
+        clazz
+      end
+
+      describe "#device_pixel_size" do
+        it "should work without a hires_factor" do
+          converter = conv.new("x" => 57)
+          converter.send(:device_pixel_size, 57).should eq(57)
+        end
+
+        it "should consider a hires_factor if given" do
+          converter = conv.new("x" => 57, "hires_factor" => 2)
+          converter.send(:device_pixel_size, 57).should eq(114)
+        end
+
+        it "should consider round a result and always return an integer" do
+          converter = conv.new("x" => 57, "hires_factor" => 1.4)
+          converter.send(:device_pixel_size, 57).should eq(80)
+          converter.send(:device_pixel_size, 57).should be_kind_of(Integer)
+        end
+
+        it "should work with an empty string" do
+          converter = conv.new("x" => 57, "hires_factor" => 2)
+          converter.send(:device_pixel_size, '').should eq('')
+        end
+      end
+    end
+  end
+end

data/spec/sinicum/imaging/image_size_converter_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+module Sinicum
+  module Imaging
+    describe ImageSizeConverter do
+      let(:image) do
+        document = double("document")
+        document.stub(:[]).and_return(nil)
+        document.stub(:[]).with(:width).and_return(100)
+        document.stub(:[]).with(:height).and_return(50)
+        image = Sinicum::Jcr::Dam::Image.new
+        image.stub(:[]).and_return(nil)
+        image.stub(:[]).with(:document).and_return(document)
+      end
+
+      it "should convert the width" do
+        conv = ImageSizeConverter.new(image, "teaser")
+        conv.width.should eq(960)
+      end
+
+      it "should convert the height" do
+        conv = ImageSizeConverter.new(image, "teaser")
+        conv.height.should eq(444)
+      end
+    end
+  end
+end

data/spec/sinicum/imaging/imaging.yml

@@ -0,0 +1,15 @@
+root_dir: /tmp/imaging
+
+renderer:
+
+  slideshow_thumbs:
+    render_type: resize_crop
+    format: jpeg
+    x: 64
+    y: 50
+
+  margin_column:
+    render_type: resize_max
+    format: jpeg
+    x: 300
+    y: 500

data/spec/sinicum/imaging/imaging_file_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+module Sinicum
+  module Imaging
+    describe ImagingFile do
+      context "dam" do
+        it "should normalize the path" do
+          file = ImagingFile.new("/dam/pa.th/to.jpg")
+          file.normalized_request_path.should eq("/damfiles/default/pa.th/to")
+          file.extension.should eq("jpg")
+          file.fingerprint.should be nil
+        end
+
+        it "should normalize not touch a regular imaging path" do
+          file = ImagingFile.new("/damfiles/default/path/to")
+          file.normalized_request_path.should eq("/damfiles/default/path/to")
+          file.extension.should be nil
+          file.fingerprint.should be nil
+        end
+
+        it "should extract the cache key with a suffix" do
+          file = ImagingFile.new(
+            "/damfiles/default/path/to/file-de89466a9267dccc7712379f44e6cd85.jpg")
+          file.normalized_request_path.should eq("/damfiles/default/path/to/file")
+          file.extension.should eq("jpg")
+          file.fingerprint.should eq("de89466a9267dccc7712379f44e6cd85")
+        end
+
+        it "should ignore a possible document repetition if the last two path parts do not match" do
+          file = ImagingFile.new("/dam/pa.th/to/tu.jpg")
+          file.normalized_request_path.should eq("/damfiles/default/pa.th/to/tu")
+          file.extension.should eq("jpg")
+          file.fingerprint.should be nil
+        end
+
+        it "should extract the cache key with a suffix" do
+          file = ImagingFile.new("/damfiles/default/path/to/" \
+            "file-de89466a9267dccc7712379f44e6cd85.jpg")
+          file.normalized_request_path.should eq("/damfiles/default/path/to/file")
+          file.extension.should eq("jpg")
+          file.fingerprint.should eq("de89466a9267dccc7712379f44e6cd85")
+        end
+
+        it "should extract the cache key without a suffix" do
+          file = ImagingFile.new(
+            "/damfiles/default/path/to/file-de89466a9267dccc7712379f44e6cd85")
+          file.normalized_request_path.should eq("/damfiles/default/path/to/file")
+          file.extension.should be nil
+          file.fingerprint.should eq("de89466a9267dccc7712379f44e6cd85")
+        end
+
+        describe "#cache_time" do
+          it "should have a cache time of one day for regular requests" do
+            file = ImagingFile.new("/damfiles/default/path/to")
+            file.cache_time.should eq(24 * 60 * 60)
+          end
+
+          it "should have a cache time of a week day for requests with a fingerprint" do
+            file = ImagingFile.new("/damfiles/default/path/to-de89466a9267dccc7712379f44e6cd85")
+            file.cache_time.should eq(7 * 24 * 60 * 60)
+          end
+        end
+      end
+
+      context "dms" do
+        it "should normalize the path" do
+          file = ImagingFile.new("/dms/pa.th/to.jpg")
+          file.normalized_request_path.should eq("/dmsfiles/default/pa.th/to")
+          file.extension.should eq("jpg")
+          file.fingerprint.should be nil
+        end
+
+        it "should normalize not touch a regular imaging path" do
+          file = ImagingFile.new("/dmsfiles/default/path/to")
+          file.normalized_request_path.should eq("/dmsfiles/default/path/to")
+          file.extension.should be nil
+          file.fingerprint.should be nil
+        end
+
+        it "should extract the cache key with a suffix" do
+          file = ImagingFile.new(
+            "/dmsfiles/default/path/to/file-de89466a9267dccc7712379f44e6cd85.jpg")
+          file.normalized_request_path.should eq("/dmsfiles/default/path/to/file")
+          file.extension.should eq("jpg")
+          file.fingerprint.should eq("de89466a9267dccc7712379f44e6cd85")
+        end
+
+        it "should ignore a possible document repetition if the last two path parts do not match" do
+          file = ImagingFile.new("/dms/pa.th/to/tu.jpg")
+          file.normalized_request_path.should eq("/dmsfiles/default/pa.th/to/tu")
+          file.extension.should eq("jpg")
+          file.fingerprint.should be nil
+        end
+
+        it "should extract the cache key with a suffix" do
+          file = ImagingFile.new("/dmsfiles/default/path/to/" \
+            "file-de89466a9267dccc7712379f44e6cd85.jpg")
+          file.normalized_request_path.should eq("/dmsfiles/default/path/to/file")
+          file.extension.should eq("jpg")
+          file.fingerprint.should eq("de89466a9267dccc7712379f44e6cd85")
+        end
+
+        it "should extract the cache key without a suffix" do
+          file = ImagingFile.new(
+            "/dmsfiles/default/path/to/file-de89466a9267dccc7712379f44e6cd85")
+          file.normalized_request_path.should eq("/dmsfiles/default/path/to/file")
+          file.extension.should be nil
+          file.fingerprint.should eq("de89466a9267dccc7712379f44e6cd85")
+        end
+
+        describe "#cache_time" do
+          it "should have a cache time of one day for regular requests" do
+            file = ImagingFile.new("/dmsfiles/default/path/to")
+            file.cache_time.should eq(24 * 60 * 60)
+          end
+
+          it "should have a cache time of a week day for requests with a fingerprint" do
+            file = ImagingFile.new("/dmsfiles/default/path/to-de89466a9267dccc7712379f44e6cd85")
+            file.cache_time.should eq(7 * 24 * 60 * 60)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/sinicum/imaging/imaging_middleware_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+module Sinicum
+  module Imaging
+    describe ImagingMiddleware do
+      include Rack::Test::Methods
+
+      let(:inner_app) do
+        ->(env) { [200, { "Content-Type" => "text/plain" }, "Downstream Response"] }
+      end
+      let(:app) { ImagingMiddleware.new(inner_app) }
+
+      let(:mock_file) { File.absolute_path("../../../fixtures/mock_image.gif", __FILE__) }
+
+      it "should be ok" do
+        get "/"
+        last_response.should =~ /Downstream Response/
+      end
+
+      it "should return 404 if the file requested does not exist" do
+        ::Sinicum::Imaging::Imaging.stub(:rendered_resource).and_return(nil)
+        get "/damfiles/default/path/to/file"
+        last_response.status.should eq(404)
+      end
+
+      describe "request to an existing file" do
+        before(:each) do
+          mock_resource = double("resource")
+          mock_resource.stub(:path) { mock_file }
+          mock_resource.stub(:filename) { "mock_image.gif" }
+          mock_resource.stub(:fingerprint) { "de89466a9267dccc7712379f44e6cd85" }
+          ::Sinicum::Imaging::Imaging.stub(:rendered_resource).and_return(mock_resource)
+        end
+
+        it "should be successful" do
+          get "/damfiles/default/path/to/file-de89466a9267dccc7712379f44e6cd85"
+          last_response.status.should eq(200)
+          get "/dmsfiles/default/path/to/file-de89466a9267dccc7712379f44e6cd85"
+          last_response.status.should eq(200)
+        end
+
+        it "should set the filename header" do
+          get "/damfiles/default/path/to/file-de89466a9267dccc7712379f44e6cd85"
+          cd_header = last_response.headers["Content-Disposition"]
+          cd_header.should =~ /inline; filename="mock_image.gif"/
+          get "/dmsfiles/default/path/to/file-de89466a9267dccc7712379f44e6cd85"
+          cd_header = last_response.headers["Content-Disposition"]
+          cd_header.should =~ /inline; filename="mock_image.gif"/
+        end
+
+        it "should set the cache header to one week" do
+          Rails.configuration.action_controller.perform_caching = true
+          get "/damfiles/default/path/to/file-de89466a9267dccc7712379f44e6cd85"
+          cd_header = last_response.headers["Cache-Control"]
+          cd_header.should =~ /max-age=604800, public/
+          Rails.configuration.action_controller.perform_caching = false
+        end
+
+        it "should set the cache header to one week (dms)" do
+          Rails.configuration.action_controller.perform_caching = true
+          get "/dmsfiles/default/path/to/file-de89466a9267dccc7712379f44e6cd85"
+          cd_header = last_response.headers["Cache-Control"]
+          cd_header.should =~ /max-age=604800, public/
+          Rails.configuration.action_controller.perform_caching = false
+        end
+      end
+
+      describe "request images whith the original prefix" do
+        it "should be successful" do
+          ::Sinicum::Imaging::Imaging.stub(:rendered_resource).and_return(nil)
+          get "/dam/path/to/file"
+          last_response.body.should_not =~ /Downstream Response/
+          get "/dms/path/to/file"
+          last_response.body.should_not =~ /Downstream Response/
+        end
+      end
+    end
+  end
+end