alchemy_cms 2.9.1 → 3.0.0.rc5

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

@@ -1,12 +1,3 @@
-describe 'Alchemy integration', ->
-  beforeEach ->
-    #    setFixtures('<select id="myselect"></select>')
-    #    jasmine.Ajax.useMock();
-    #    request = FakeXMLHttpRequest()
-    #    request.response(TestResponses.search.success)
-    #    element = $('#myselect')
-    #
-
-  it 'should provide an Alchemy-Object', ->
-    expect(Alchemy).toExist()
-
+describe 'Alchemy', ->
+  it 'should provide an Alchemy Javascript Object', ->
+    expect(Alchemy).toBeDefined()

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

@@ -2,13 +2,13 @@
  Jasmine-Ajax : a set of helpers for testing AJAX requests under the Jasmine
  BDD framework for JavaScript.
 
- Supports both Prototype.js and jQuery.
+ Supports jQuery.
 
  http://github.com/pivotal/jasmine-ajax
 
  Jasmine Home page: http://pivotal.github.com/jasmine
 
- Copyright (c) 2008-2010 Pivotal Labs
+ 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
@@ -48,41 +48,61 @@ function clearAjaxRequests() {
 
 // Fake XHR for mocking Ajax Requests & Responses
 function FakeXMLHttpRequest() {
-  var extend = Object.extend || $.extend;
+  var extend = Object.extend || jQuery.extend;
   extend(this, {
-    requestHeaders:{},
+    requestHeaders: {},
 
-    open:function () {
+    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) {
+    setRequestHeader: function(header, value) {
       this.requestHeaders[header] = value;
     },
 
-    abort:function () {
+    abort: function() {
       this.readyState = 0;
     },
 
-    readyState:0,
+    readyState: 0,
 
-    onreadystatechange:function (isTimeout) {
+    onload: function() {
     },
 
-    status:null,
+    onreadystatechange: function(isTimeout) {
+    },
+
+    status: null,
 
-    send:function (data) {
+    send: function(data) {
       this.params = data;
       this.readyState = 2;
     },
 
-    getResponseHeader:function (name) {
+    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 () {
+    getAllResponseHeaders: function() {
       var responseHeaders = [];
       for (var i in this.responseHeaders) {
         if (this.responseHeaders.hasOwnProperty(i)) {
@@ -92,20 +112,21 @@ function FakeXMLHttpRequest() {
       return responseHeaders.join('\r\n');
     },
 
-    responseText:null,
+    responseText: null,
 
-    response:function (response) {
+    response: function(response) {
       this.status = response.status;
       this.responseText = response.responseText || "";
       this.readyState = 4;
       this.responseHeaders = response.responseHeaders ||
-      {"Content-type":response.contentType || "application/json" };
+      {"Content-type": response.contentType || "application/json" };
       // uncomment for jquery 1.3.x support
       // jasmine.Clock.tick(20);
 
+      this.onload();
       this.onreadystatechange();
     },
-    responseTimeout:function () {
+    responseTimeout: function() {
       this.readyState = 4;
       jasmine.Clock.tick(jQuery.ajaxSettings.timeout || 30000);
       this.onreadystatechange('timeout');
@@ -118,17 +139,17 @@ function FakeXMLHttpRequest() {
 
 jasmine.Ajax = {
 
-  isInstalled:function () {
-    return jasmine.Ajax.installed == true;
+  isInstalled: function() {
+    return jasmine.Ajax.installed === true;
   },
 
-  assertInstalled:function () {
+  assertInstalled: function() {
     if (!jasmine.Ajax.isInstalled()) {
-      throw new Error("Mock ajax is not installed, use jasmine.Ajax.useMock()")
+      throw new Error("Mock ajax is not installed, use jasmine.Ajax.useMock()");
     }
   },
 
-  useMock:function () {
+  useMock: function() {
     if (!jasmine.Ajax.isInstalled()) {
       var spec = jasmine.getEnv().currentSpec;
       spec.after(jasmine.Ajax.uninstallMock);
@@ -137,71 +158,42 @@ jasmine.Ajax = {
     }
   },
 
-  installMock:function () {
+  installMock: function() {
     if (typeof jQuery != 'undefined') {
       jasmine.Ajax.installJquery();
-    } else if (typeof Prototype != 'undefined') {
-      jasmine.Ajax.installPrototype();
     } else {
-      throw new Error("jasmine.Ajax currently only supports jQuery and Prototype");
+      throw new Error("jasmine.Ajax currently only supports jQuery");
     }
     jasmine.Ajax.installed = true;
   },
 
-  installJquery:function () {
+  installJquery: function() {
     jasmine.Ajax.mode = 'jQuery';
     jasmine.Ajax.real = jQuery.ajaxSettings.xhr;
     jQuery.ajaxSettings.xhr = jasmine.Ajax.jQueryMock;
 
   },
 
-  installPrototype:function () {
-    jasmine.Ajax.mode = 'Prototype';
-    jasmine.Ajax.real = Ajax.getTransport;
-
-    Ajax.getTransport = jasmine.Ajax.prototypeMock;
-  },
-
-  uninstallMock:function () {
+  uninstallMock: function() {
     jasmine.Ajax.assertInstalled();
     if (jasmine.Ajax.mode == 'jQuery') {
       jQuery.ajaxSettings.xhr = jasmine.Ajax.real;
-    } else if (jasmine.Ajax.mode == 'Prototype') {
-      Ajax.getTransport = jasmine.Ajax.real;
     }
     jasmine.Ajax.reset();
   },
 
-  reset:function () {
+  reset: function() {
     jasmine.Ajax.installed = false;
     jasmine.Ajax.mode = null;
     jasmine.Ajax.real = null;
   },
 
-  jQueryMock:function () {
+  jQueryMock: function() {
     var newXhr = new FakeXMLHttpRequest();
     ajaxRequests.push(newXhr);
     return newXhr;
   },
 
-  prototypeMock:function () {
-    return new FakeXMLHttpRequest();
-  },
-
-  installed:false,
-  mode:null
-}
-
-
-// Jasmine-Ajax Glue code for Prototype.js
-if (typeof Prototype != 'undefined' && Ajax && Ajax.Request) {
-  Ajax.Request.prototype.originalRequest = Ajax.Request.prototype.request;
-  Ajax.Request.prototype.request = function (url) {
-    this.originalRequest(url);
-    ajaxRequests.push(this);
-  };
-
-  Ajax.Request.prototype.response = function (responseOptions) {
-    return this.transport.response(responseOptions);
-  };
-}
+  installed: false,
+  mode: null
+};

data/spec/javascripts/support/jasmine.yml

@@ -0,0 +1,29 @@
+# path to parent directory of src_files
+# relative path from Rails.root
+# defaults to app/assets/javascripts
+src_dir: "app/assets/javascripts"
+
+# list of file expressions to include as source files
+# relative path from src_dir
+src_files:
+ - "application.{js,coffee}"
+
+# path to parent directory of spec_files
+# relative path from Rails.root
+# defaults to spec/javascripts
+spec_dir: spec/javascripts
+
+# list of file expressions to include as helpers into spec runner
+# relative path from spec_dir
+helpers:
+  - "helpers/**/*.{js,coffee}"
+
+# list of file expressions to include as specs into spec runner
+# relative path from spec_dir
+spec_files:
+  - "**/*[Ss]pec.{js,coffee}"
+
+# path to directory of temporary files
+# (spec runner and asset cache)
+# defaults to spec/tmp
+tmp_dir: "spec/tmp"

data/spec/libraries/auth_accessors_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+module Alchemy
+  class MyCustomUser
+  end
+
+  describe 'AuthAccessors' do
+    describe '.user_class' do
+      before {
+        # prevent memoization
+        Alchemy.class_variable_set('@@user_class', nil)
+      }
+
+      it "raises error if user_class_name is not a String" do
+        Alchemy.user_class_name = MyCustomUser
+        expect {Alchemy.user_class }.to raise_error
+      end
+
+      after {
+        Alchemy.user_class_name = 'DummyUser'
+      }
+    end
+  end
+end

data/spec/libraries/config_spec.rb

@@ -55,7 +55,7 @@ module Alchemy
 
     describe '.read_file' do
       context 'when given path to yml file exists' do
-        before { File.stub!(:exists?).and_return(true) }
+        before { File.stub(:exists?).and_return(true) }
 
         it 'should call YAML.load_file with the given config path' do
           YAML.should_receive(:load_file).once.with('path/to/config.yml').and_return({})
@@ -64,8 +64,8 @@ module Alchemy
 
         context 'but its empty' do
           before do
-            File.stub!(:exists?).with('empty_file.yml').and_return(true)
-            YAML.stub!(:load_file).and_return(false) # YAML.load_file returns false if file is empty.
+            File.stub(:exists?).with('empty_file.yml').and_return(true)
+            YAML.stub(:load_file).and_return(false) # YAML.load_file returns false if file is empty.
           end
 
           it "should return an empty Hash" do

data/spec/libraries/controller_actions_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+
+# Here's a tiny custom matcher making it a bit easier to check the
+# current session for a language configuration.
+#
+RSpec::Matchers.define :include_language_information_for do |expected|
+  match do |actual|
+    actual[:alchemy_language_id] == expected.id
+  end
+end
+
+describe 'Alchemy::ControllerActions', type: 'controller' do
+  # Anonymous controller to test the integration against
+  controller(ActionController::Base) do
+    include Alchemy::ControllerActions
+  end
+
+  describe "#current_alchemy_user" do
+    context "with default current_user_method" do
+      it "calls current_user by default" do
+        controller.should_receive :current_user
+        controller.send :current_alchemy_user
+      end
+    end
+
+    context "with custom current_user_method" do
+      before do
+        Alchemy.current_user_method = 'current_admin'
+      end
+
+      it "calls the custom method" do
+        controller.should_receive :current_admin
+        controller.send :current_alchemy_user
+      end
+    end
+
+    context "with not implemented current_user_method" do
+      before do
+        Alchemy.current_user_method = 'not_implemented_method'
+      end
+
+      after do
+        Alchemy.current_user_method = 'current_user'
+      end
+
+      it "raises an error" do
+        expect{
+          controller.send :current_alchemy_user
+        }.to raise_error(Alchemy::NoCurrentUserFoundError)
+      end
+    end
+  end
+
+  describe "#set_alchemy_language" do
+    let(:default_language) { Alchemy::Language.default }
+    let(:klingonian)       { FactoryGirl.create(:klingonian) }
+
+    after do
+      # We must never change the app's locale
+      expect(::I18n.locale).to eq(:en)
+    end
+
+    context "with a Language argument" do
+      it "should set the language to the passed Language instance" do
+        controller.send :set_alchemy_language, klingonian
+        assigns(:language).should == klingonian
+        expect(Alchemy::Language.current).to eq(klingonian)
+      end
+    end
+
+    context "with a language id argument" do
+      it "should set the language to the language specified by the passed id" do
+        controller.send :set_alchemy_language, klingonian.id
+        assigns(:language).should == klingonian
+        expect(Alchemy::Language.current).to eq(klingonian)
+      end
+    end
+
+    context "with a language code argument" do
+      it "should set the language to the language specified by the passed code" do
+        controller.send :set_alchemy_language, klingonian.code
+        assigns(:language).should == klingonian
+        expect(Alchemy::Language.current).to eq(klingonian)
+      end
+    end
+
+    context "with no lang param" do
+      it "should set the default language" do
+        controller.stub(:params).and_return({})
+        controller.send :set_alchemy_language
+        assigns(:language).should == default_language
+        expect(Alchemy::Language.current).to eq(default_language)
+        expect(controller.session).to include_language_information_for(default_language)
+      end
+    end
+
+    context "with language in the session" do
+      before do
+        controller.stub(:session).and_return(alchemy_language_id: klingonian.id)
+        Alchemy::Language.stub(current: klingonian)
+      end
+
+      it "should use the language from the session" do
+        controller.send :set_alchemy_language
+        assigns(:language).should == klingonian
+        expect(Alchemy::Language.current).to eq(klingonian)
+      end
+    end
+
+    context "with lang param" do
+      it "should set the language" do
+        controller.stub(:params).and_return(lang: klingonian.code)
+        controller.send :set_alchemy_language
+        assigns(:language).should == klingonian
+        expect(Alchemy::Language.current).to eq(klingonian)
+        expect(controller.session).to include_language_information_for(klingonian)
+      end
+
+      context "for language that does not exist" do
+        before do
+          controller.stub(:params).and_return(lang: 'fo')
+          controller.send :set_alchemy_language
+        end
+
+        it "should set the language to default" do
+          assigns(:language).should == default_language
+          expect(Alchemy::Language.current).to eq(default_language)
+          expect(controller.session).to include_language_information_for(default_language)
+        end
+      end
+    end
+  end
+end