lc_alchemy_cms 3.2.0

data/spec/helpers/picture_url_helpers_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe "Picture url helpers" do
+
+  it "should generate a url string for cropped picture" do
+    p = show_picture_path(:id => 3, :crop => "crop", :size => "100x33", :name => "kitten", :format => "jpg")
+    expect(p).to eq("/pictures/3/show/100x33/crop/kitten.jpg")
+  end
+
+  it "should generate a url string for cropped and masked picture" do
+    p = show_picture_path(:id => 3, :crop => "crop", :crop_from => "0x0", :crop_size => "900x300", :size => "100x33", :name => "kitten", :format => :jpg)
+    expect(p).to eq("/pictures/3/show/100x33/crop/0x0/900x300/kitten.jpg")
+  end
+
+  it "should generate a url string for cropped thumbnail" do
+    p = thumbnail_path(:id => 3, :crop => "crop", :size => "100x33", :name => "kitten", :format => :jpg)
+    expect(p).to eq("/pictures/3/thumbnails/100x33/crop/kitten.jpg")
+  end
+
+  it "should generate a url string for thumbnail with default name and format" do
+    p = thumbnail_path(:id => 3, :size => "100x33")
+    expect(p).to eq("/pictures/3/thumbnails/100x33/thumbnail.png")
+  end
+
+  it "should generate a url string for cropped and masked thumbnail" do
+    p = thumbnail_path(:id => 3, :crop_from => "0x0", :crop_size => "900x300", :size => "100x33", :name => "kitten", :format => :jpg)
+    expect(p).to eq("/pictures/3/thumbnails/100x33/0x0/900x300/kitten.jpg")
+  end
+
+  it "should generate a url string for zoomed image" do
+    p = zoom_picture_path(:id => 3, :name => "kitten", :format => :jpg)
+    expect(p).to eq("/pictures/3/zoom/kitten.jpg")
+  end
+
+end

data/spec/helpers/url_helper_spec.rb

@@ -0,0 +1,174 @@
+require 'spec_helper'
+
+include Alchemy::ElementsHelper
+
+module Alchemy
+  describe UrlHelper do
+    let(:page) { mock_model(Page, urlname: 'testpage', language_code: 'en') }
+
+    before do
+      helper.controller.class_eval { include Alchemy::ConfigurationMethods }
+    end
+
+    context 'page path helpers' do
+      describe "#show_page_path_params" do
+        context "when multi_language" do
+
+          before do
+            allow(helper).to receive(:multi_language?).and_return(true)
+          end
+
+          it "should return a Hash with urlname and language_id parameter" do
+            allow(helper).to receive(:multi_language?).and_return(true)
+            expect(helper.show_page_path_params(page)).to include(urlname: 'testpage', locale: 'en')
+          end
+
+          it "should return a Hash with urlname, language_id and query parameter" do
+            allow(helper).to receive(:multi_language?).and_return(true)
+            expect(helper.show_page_path_params(page, {query: 'test'})).to include(urlname: 'testpage', locale: 'en', query: 'test')
+          end
+        end
+
+        context "not multi_language" do
+          before do
+            allow(helper).to receive(:multi_language?).and_return(false)
+          end
+
+          it "should return a Hash with the urlname but without language_id parameter" do
+            expect(helper.show_page_path_params(page)).to include(urlname: 'testpage')
+            expect(helper.show_page_path_params(page)).not_to include(locale: 'en')
+          end
+
+          it "should return a Hash with urlname and query parameter" do
+            expect(helper.show_page_path_params(page, {query: 'test'})).to include(urlname: 'testpage', query: 'test')
+            expect(helper.show_page_path_params(page)).not_to include(locale: 'en')
+          end
+        end
+      end
+
+      describe "#show_alchemy_page_path" do
+        context "when multi_language" do
+
+          before do
+            allow(helper).to receive(:multi_language?).and_return(true)
+          end
+
+          it "should return the correct relative path string" do
+            expect(helper.show_alchemy_page_path(page)).to eq("/#{page.language_code}/testpage")
+          end
+
+          it "should return the correct relative path string with additional parameters" do
+            expect(helper.show_alchemy_page_path(page, {query: 'test'})).to eq("/#{page.language_code}/testpage?query=test")
+          end
+        end
+
+        context "not multi_language" do
+          before do
+            allow(helper).to receive(:multi_language?).and_return(false)
+          end
+
+          it "should return the correct relative path string" do
+            expect(helper.show_alchemy_page_path(page)).to eq("/testpage")
+          end
+
+          it "should return the correct relative path string with additional parameter" do
+            expect(helper.show_alchemy_page_path(page, {query: 'test'})).to eq("/testpage?query=test")
+          end
+        end
+      end
+
+      describe "#show_alchemy_page_url" do
+        context "when multi_language" do
+
+          before do
+            allow(helper).to receive(:multi_language?).and_return(true)
+          end
+
+          it "should return the correct url string" do
+            expect(helper.show_alchemy_page_url(page)).to eq("http://#{helper.request.host}/#{page.language_code}/testpage")
+          end
+
+          it "should return the correct url string with additional parameters" do
+            expect(helper.show_alchemy_page_url(page, {query: 'test'})).to eq("http://#{helper.request.host}/#{page.language_code}/testpage?query=test")
+          end
+        end
+
+        context "not multi_language" do
+          before do
+            allow(helper).to receive(:multi_language?).and_return(false)
+          end
+
+          it "should return the correct url string" do
+            expect(helper.show_alchemy_page_url(page)).to eq("http://#{helper.request.host}/testpage")
+          end
+
+          it "should return the correct url string with additional parameter" do
+            expect(helper.show_alchemy_page_url(page, {query: 'test'})).to eq("http://#{helper.request.host}/testpage?query=test")
+          end
+        end
+      end
+    end
+
+    context 'picture path helpers' do
+      let(:picture) { stub_model(Picture, urlname: 'cute_kitten', id: 42) }
+
+      describe '#show_alchemy_picture_path' do
+        it "should return the correct relative path string" do
+          expect(helper.show_alchemy_picture_path(picture)).to match(Regexp.new("/pictures/42/show/cute_kitten.jpg"))
+        end
+      end
+
+      describe '#show_alchemy_picture_url' do
+        it "should return the correct url string" do
+          expect(helper.show_alchemy_picture_url(picture)).to match(Regexp.new("http://#{helper.request.host}/pictures/42/show/cute_kitten.jpg"))
+        end
+      end
+
+      describe '#show_picture_path_params' do
+        it "should return the correct params for rendering a picture" do
+          expect(helper.show_picture_path_params(picture)).to include(name: 'cute_kitten', format: 'jpg')
+        end
+
+        it "should include the secure hash parameter" do
+          expect(helper.show_picture_path_params(picture).keys).to include(:sh)
+          expect(helper.show_picture_path_params(picture)[:sh]).not_to be_empty
+        end
+
+        context "with additional params" do
+          it "should include these params" do
+            expect(helper.show_picture_path_params(picture, {format: 'png'})).to include(name: 'cute_kitten', format: 'png')
+          end
+        end
+
+        context "with additional params crop set to true" do
+          it "should include crop as parameter" do
+            expect(helper.show_picture_path_params(picture, {crop: true})).to include(name: 'cute_kitten', crop: 'crop')
+          end
+        end
+      end
+    end
+
+    context 'attachment path helpers' do
+      let(:attachment) { mock_model(Attachment, urlname: 'test-attachment.pdf') }
+
+      it 'should return the correct relative path to download an attachment' do
+        expect(helper.download_alchemy_attachment_path(attachment)).to eq("/attachment/#{attachment.id}/download/#{attachment.urlname}")
+      end
+
+      it 'should return the correct url to download an attachment' do
+        expect(helper.download_alchemy_attachment_url(attachment)).to eq("http://#{helper.request.host}/attachment/#{attachment.id}/download/#{attachment.urlname}")
+      end
+    end
+
+    describe '#full_url_for_element' do
+      subject { full_url_for_element(element) }
+
+      let(:element) { build_stubbed(:element, name: 'headline', page: page) }
+      let(:current_server) { '' }
+
+      it "returns the url to this element" do
+        is_expected.to eq("#{current_server}/#{element.page.urlname}##{element_dom_id(element)}")
+      end
+    end
+  end
+end

data/spec/javascripts/alchemy/dialog_spec.coffee

@@ -0,0 +1,82 @@
+#= require jasmine-jquery
+
+describe "Alchemy.Dialog", ->
+
+  # beforeEach ->
+  #   # first load the jasmine-jquery fixtures
+  #   # loadFixtures('fixture.html')
+  #   # then use ajax mocking
+  #   jasmine.Ajax.useMock()
+
+  afterEach ->
+    @dialog.dialog.remove()
+    if @dialog.overlay
+      @dialog.overlay.remove()
+
+  describe 'with default options', ->
+    beforeEach ->
+      @dialog = new Alchemy.Dialog('/events/new')
+
+    it 'appends the dialog to the dom', ->
+      expect($('.alchemy-dialog')).toHaveLength(1)
+
+    it 'appends an overlay to the dom', ->
+      expect($('.alchemy-dialog-overlay')).toHaveLength(1)
+
+    it 'has a close button', ->
+      expect($('.alchemy-dialog-close')).toHaveLength(1)
+
+    it 'has a title bar', ->
+      expect($('.alchemy-dialog-title')).toHaveLength(1)
+
+    it 'has a body', ->
+      expect($('.alchemy-dialog-body')).toHaveLength(1)
+
+    it 'has width and height attributes', ->
+      expect(@dialog.width).toEqual(400)
+      expect(@dialog.height).toEqual(300)
+
+    it 'has max-width and min-height styles', ->
+      expect(@dialog.dialog).toHaveCss({'max-width': '400px', 'min-height': '300px'})
+
+    describe '#open', ->
+      beforeEach ->
+        @dialog.open()
+
+      it 'adds "open" class to the dialog', ->
+        expect(@dialog.dialog).toHaveClass('open')
+
+      it 'adds "open" class to the overlay', ->
+        expect(@dialog.overlay).toHaveClass('open')
+
+      it 'attaches "#close" click event to close button', ->
+        expect(@dialog.close_button).toHandleWith('click', @dialog.close)
+
+      it 'attaches "#close" click event to overlay', ->
+        expect(@dialog.overlay).toHandleWith('click', @dialog.close)
+
+      it 'attaches "#close" key event to esc key', ->
+        expect(@dialog.$document).toHandle('keydown')
+
+    describe '#load', ->
+      beforeEach ->
+        @dialog.load()
+
+      it 'shows a spinner', ->
+        expect(@dialog.dialog_body.find('.spinner')).toHaveLength(1)
+
+      xit 'loads content via ajax'
+
+  describe 'with modal set to false', ->
+    beforeEach ->
+      @dialog = new Alchemy.Dialog('/events/new', {modal: false})
+
+    it 'does not append the overlay to the dom', ->
+      expect($('.alchemy-dialog-overlay').length).toEqual(0)
+
+  describe 'with title given', ->
+    beforeEach ->
+      @dialog = new Alchemy.Dialog('/events/new', {title: 'My Title'})
+
+    it 'has a title', ->
+      expect($('.alchemy-dialog-title')).toContainText('My Title')

data/spec/javascripts/alchemy/link_overlay_spec.coffee

@@ -0,0 +1,25 @@
+#= require jasmine-jquery
+
+describe "Alchemy.LinkOverlay", ->
+
+  beforeEach ->
+    setFixtures('<div id="myelement"></div>')
+
+  it "should be on object", ->
+    expect(Alchemy.LinkOverlay).toBeDefined()
+  describe "close", ->
+    xit "should ....", ->
+  describe "selectPage", ->
+    xit "should ....", ->
+  describe "createLink", ->
+    xit "should ....", ->
+  describe "selectTab", ->
+    xit "should ....", ->
+  describe "showElementsSelect", ->
+    xit "should ....", ->
+  describe "hideElementsSelect", ->
+    xit "should ....", ->
+  describe "createTempLink", ->
+    xit "should ....", ->
+  describe "removeLink", ->
+    xit "should ....", ->

data/spec/javascripts/alchemy_integration_spec.coffee

@@ -0,0 +1,3 @@
+describe 'Alchemy', ->
+  it 'should provide an Alchemy Javascript Object', ->
+    expect(Alchemy).toBeDefined()

data/spec/javascripts/fixtures/select.html

@@ -0,0 +1,3 @@
+<select id="selectfield1">
+
+</select>

data/spec/javascripts/helpers/mock-ajax.js

@@ -0,0 +1,199 @@
+/*
+ Jasmine-Ajax : a set of helpers for testing AJAX requests under the Jasmine
+ BDD framework for JavaScript.
+
+ Supports jQuery.
+
+ http://github.com/pivotal/jasmine-ajax
+
+ Jasmine Home page: http://pivotal.github.com/jasmine
+
+ Copyright (c) 2008-2013 Pivotal Labs
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to
+ permit persons to whom the Software is furnished to do so, subject to
+ the following conditions:
+
+ The above copyright notice and this permission notice shall be
+ included in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+ */
+
+// Jasmine-Ajax interface
+var ajaxRequests = [];
+
+function mostRecentAjaxRequest() {
+  if (ajaxRequests.length > 0) {
+    return ajaxRequests[ajaxRequests.length - 1];
+  } else {
+    return null;
+  }
+}
+
+function clearAjaxRequests() {
+  ajaxRequests = [];
+}
+
+// Fake XHR for mocking Ajax Requests & Responses
+function FakeXMLHttpRequest() {
+  var extend = Object.extend || jQuery.extend;
+  extend(this, {
+    requestHeaders: {},
+
+    open: function() {
+      this.method = arguments[0];
+      this.url = arguments[1];
+      this.username = arguments[3];
+      this.password = arguments[4];
+      this.readyState = 1;
+    },
+
+    setRequestHeader: function(header, value) {
+      this.requestHeaders[header] = value;
+    },
+
+    abort: function() {
+      this.readyState = 0;
+    },
+
+    readyState: 0,
+
+    onload: function() {
+    },
+
+    onreadystatechange: function(isTimeout) {
+    },
+
+    status: null,
+
+    send: function(data) {
+      this.params = data;
+      this.readyState = 2;
+    },
+
+    data: function() {
+      var data = {};
+      if (typeof this.params !== 'string') return data;
+      var params = this.params.split('&');
+
+      for (var i = 0; i < params.length; ++i) {
+        var kv = params[i].replace(/\+/g, ' ').split('=');
+        var key = decodeURIComponent(kv[0]);
+        data[key] = data[key] || [];
+        data[key].push(decodeURIComponent(kv[1]));
+        data[key].sort();
+      }
+      return data;
+    },
+
+    getResponseHeader: function(name) {
+      return this.responseHeaders[name];
+    },
+
+    getAllResponseHeaders: function() {
+      var responseHeaders = [];
+      for (var i in this.responseHeaders) {
+        if (this.responseHeaders.hasOwnProperty(i)) {
+          responseHeaders.push(i + ': ' + this.responseHeaders[i]);
+        }
+      }
+      return responseHeaders.join('\r\n');
+    },
+
+    responseText: null,
+
+    response: function(response) {
+      this.status = response.status;
+      this.responseText = response.responseText || "";
+      this.readyState = 4;
+      this.responseHeaders = response.responseHeaders ||
+      {"Content-type": response.contentType || "application/json" };
+      // uncomment for jquery 1.3.x support
+      // jasmine.Clock.tick(20);
+
+      this.onload();
+      this.onreadystatechange();
+    },
+    responseTimeout: function() {
+      this.readyState = 4;
+      jasmine.Clock.tick(jQuery.ajaxSettings.timeout || 30000);
+      this.onreadystatechange('timeout');
+    }
+  });
+
+  return this;
+}
+
+
+jasmine.Ajax = {
+
+  isInstalled: function() {
+    return jasmine.Ajax.installed === true;
+  },
+
+  assertInstalled: function() {
+    if (!jasmine.Ajax.isInstalled()) {
+      throw new Error("Mock ajax is not installed, use jasmine.Ajax.useMock()");
+    }
+  },
+
+  useMock: function() {
+    if (!jasmine.Ajax.isInstalled()) {
+      var spec = jasmine.getEnv().currentSpec;
+      spec.after(jasmine.Ajax.uninstallMock);
+
+      jasmine.Ajax.installMock();
+    }
+  },
+
+  installMock: function() {
+    if (typeof jQuery != 'undefined') {
+      jasmine.Ajax.installJquery();
+    } else {
+      throw new Error("jasmine.Ajax currently only supports jQuery");
+    }
+    jasmine.Ajax.installed = true;
+  },
+
+  installJquery: function() {
+    jasmine.Ajax.mode = 'jQuery';
+    jasmine.Ajax.real = jQuery.ajaxSettings.xhr;
+    jQuery.ajaxSettings.xhr = jasmine.Ajax.jQueryMock;
+
+  },
+
+  uninstallMock: function() {
+    jasmine.Ajax.assertInstalled();
+    if (jasmine.Ajax.mode == 'jQuery') {
+      jQuery.ajaxSettings.xhr = jasmine.Ajax.real;
+    }
+    jasmine.Ajax.reset();
+  },
+
+  reset: function() {
+    jasmine.Ajax.installed = false;
+    jasmine.Ajax.mode = null;
+    jasmine.Ajax.real = null;
+  },
+
+  jQueryMock: function() {
+    var newXhr = new FakeXMLHttpRequest();
+    ajaxRequests.push(newXhr);
+    return newXhr;
+  },
+
+  installed: false,
+  mode: null
+};