alchemy_cms 2.1.12 → 2.2.rc1

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

@@ -0,0 +1,207 @@
+/*
+ Jasmine-Ajax : a set of helpers for testing AJAX requests under the Jasmine
+ BDD framework for JavaScript.
+
+ Supports both Prototype.js and jQuery.
+
+ http://github.com/pivotal/jasmine-ajax
+
+ Jasmine Home page: http://pivotal.github.com/jasmine
+
+ Copyright (c) 2008-2010 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 || $.extend;
+  extend(this, {
+    requestHeaders:{},
+
+    open:function () {
+      this.method = arguments[0];
+      this.url = arguments[1];
+      this.readyState = 1;
+    },
+
+    setRequestHeader:function (header, value) {
+      this.requestHeaders[header] = value;
+    },
+
+    abort:function () {
+      this.readyState = 0;
+    },
+
+    readyState:0,
+
+    onreadystatechange:function (isTimeout) {
+    },
+
+    status:null,
+
+    send:function (data) {
+      this.params = data;
+      this.readyState = 2;
+    },
+
+    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.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 if (typeof Prototype != 'undefined') {
+      jasmine.Ajax.installPrototype();
+    } else {
+      throw new Error("jasmine.Ajax currently only supports jQuery and Prototype");
+    }
+    jasmine.Ajax.installed = true;
+  },
+
+  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 () {
+    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 () {
+    jasmine.Ajax.installed = false;
+    jasmine.Ajax.mode = null;
+    jasmine.Ajax.real = null;
+  },
+
+  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);
+  };
+}

data/spec/javascripts/helpers/test_responses/test_responses.js

@@ -0,0 +1 @@
+var TestResponses = {};

data/spec/javascripts/spec.css

@@ -0,0 +1,3 @@
+/*
+*= require application
+*/

data/spec/javascripts/spec.js

@@ -0,0 +1,2 @@
+//= require_tree ./
+//= require application

data/spec/libraries/resource_spec.rb

@@ -0,0 +1,122 @@
+require 'rspec'
+require File.dirname(__FILE__) + '/../../lib/alchemy/resource'
+
+class Event
+end
+
+
+describe Alchemy::Resource do
+
+  it "is initialized with a controller_path" do
+    resource = Alchemy::Resource.new("admin/events")
+    resource.should be_a Alchemy::Resource
+  end
+  it "can be can be initialized with an alchemy module_definition" do
+    resource = Alchemy::Resource.new("admin/events", {'engine_name' => 'engine'})
+    resource.should be_a Alchemy::Resource
+  end
+
+  describe "model_array" do
+    it "splits the controller_path and returns it as array." do
+      resource = Alchemy::Resource.new("namespace1/namespace2/events")
+      resource.model_array.should eql(['namespace1', 'namespace2', 'events'])
+    end
+
+    it "deletes 'admin' if found hence our model isn't in the admin-namespace by convention" do
+      resource = Alchemy::Resource.new("admin/events")
+      resource.model_array.should eql(['events'])
+    end
+  end
+
+  describe "instance methods" do
+    before :each do
+      @resource = Alchemy::Resource.new("admin/events")
+    end
+
+    describe "model" do
+      it "returns resource's model-class" do
+        @resource.model.should be(Event)
+      end
+
+      describe "resources_name" do
+        it "returns plural name (like events for model Event)" do
+          @resource.resources_name.should == 'events'
+        end
+      end
+
+      describe "model_name" do
+        it "returns model_name (like event for model Event" do
+          @resource.model_name.should == 'event'
+        end
+      end
+
+      describe "permission_scope" do
+        it "should return the permissions_scope usable in declarative authorization" do
+          @resource.permission_scope.should == :admin_events
+        end
+      end
+
+      describe "namespace_for_scope" do
+        it "returns a scope for use in url_for-based path-helpers" do
+          @resource.namespace_for_scope.should == ['admin']
+        end
+      end
+
+      describe "attributes" do
+        before :each do
+          ##stubbing an ActiveRecord::ModelSchema...
+          columns = [
+            mock(:column, {:name => 'name', :type => :string}),
+            mock(:column, {:name => 'hidden_value', :type => :string}),
+            mock(:column, {:name => 'description', :type => :string}),
+            mock(:column, {:name => 'id', :type => :integer}),
+            mock(:column, {:name => 'starts_at', :type => :datetime}),
+          ]
+          Event.stub(:columns).and_return columns
+        end
+
+        it "parses and returns the resource-model's attributes from ActiveRecord::ModelSchema" do
+          @resource.attributes.should == [{:name => "name", :type => :string}, {:name => "hidden_value", :type => :string}, {:name => "description", :type => :string}, {:name => "starts_at", :type => :datetime}]
+        end
+
+        it "skips attributes mentioned in SKIP_ATTRIBUTES" do
+          @resource.attributes.should_not include({:name => "id", :type => :integer})
+          @resource.attributes.should include({:name => "hidden_value", :type => :string})
+        end
+
+        it "should prefer SKIP_ATTRIBUTES in model if defined" do
+          Event.const_set :SKIP_ATTRIBUTES, %W[hidden_value]
+          @resource.attributes.should include({:name => "id", :type => :integer})
+          @resource.attributes.should_not include({:name => "hidden_value", :type => :string})
+        end
+
+        describe "searchable_attributes" do
+          it "should return all attributes of type string" do
+            Event.const_set :SKIP_ATTRIBUTES, []
+            @resource.searchable_attributes.should == [{:name => "name", :type => :string}, {:name => "hidden_value", :type => :string}, {:name => "description", :type => :string}]
+          end
+        end
+      end
+
+    end
+
+    describe "namespaced_model_name" do
+      it "returns model_name with namespace (namespace_event for Namespace::Event), i.e. for use in forms" do
+        namespaced_resource = Alchemy::Resource.new("admin/namespace/events")
+        namespaced_resource.namespaced_model_name.should == 'namespace_event'
+      end
+
+      it "should not include the engine's name" do
+        namespaced_resource = Alchemy::Resource.new("admin/engine/namespace/events", {'engine_name' => 'engine'})
+        namespaced_resource.namespaced_model_name.should == 'namespace_event'
+      end
+
+      it "should equal model_name if model not namespaced" do
+        namespaced_resource = Alchemy::Resource.new("admin/events")
+        namespaced_resource.namespaced_model_name.should == namespaced_resource.model_name
+      end
+    end
+
+
+  end
+end

data/spec/libraries/resources_helper_spec.rb

@@ -0,0 +1,105 @@
+require File.dirname(__FILE__) + "/../../lib/alchemy/resource"
+require File.dirname(__FILE__) + "/../../lib/alchemy/resources_helper"
+
+module Namespace
+  class MyResource
+  end
+end
+
+class ResourcesController
+  def resource_handler
+    @resource_handler = Alchemy::Resource.new('admin/namespace/my_resources')
+  end
+
+  include Alchemy::ResourcesHelper
+end
+
+class ResourcesControllerForEngine
+  def resource_handler
+    @resource_handler = Alchemy::Resource.new('admin/engine_resources', {'engine_name' => 'my_engine'})
+  end
+
+  include Alchemy::ResourcesHelper
+end
+
+
+describe Alchemy::ResourcesHelper do
+
+  before :each do
+    @controller = ResourcesController.new
+    @controller.stub(:main_app).and_return 'main_app_proxy'
+    @resource_item = stub('resource-item')
+    @controller.instance_variable_set('@my_resource', @resource_item)
+    @controller.instance_variable_set('@my_resources', [@resource_item])
+  end
+
+  describe "path-helpers" do
+
+    describe "resource_url_proxy" do
+      it "should return the current proxy for use in url-helper-methods" do
+        @controller.resource_url_proxy.should == 'main_app_proxy'
+      end
+      it "should return the engine's proxy object when resource is in engine" do
+        @controller_for_engine = ResourcesControllerForEngine.new
+        @controller_for_engine.stub('my_engine').and_return 'my_engine_proxy'
+        @controller_for_engine.resource_url_proxy.should == 'my_engine_proxy'
+      end
+    end
+
+    describe "resource_scope" do
+      it "should provide an array containing a proxy and namespaces for use in url_for-based helper-methods" do
+        @controller.resource_scope.should == %W[main_app_proxy admin]
+      end
+    end
+
+    describe "resource_path" do
+
+      it "should invoke polymorphic-path with correct scope and object" do
+        my_resource_item = stub
+        @controller.should_receive(:polymorphic_path).with(["main_app_proxy", "admin", my_resource_item], {})
+        @controller.resource_path(my_resource_item)
+      end
+
+      it "use resource's class when no object is given" do
+        @controller.should_receive(:polymorphic_path).with(["main_app_proxy", "admin", Namespace::MyResource], {})
+        @controller.resource_path
+      end
+
+    end
+
+    describe "resources_path method" do
+      it "should invoke polymorphic-path with correct scope and resource class-name" do
+        @controller.should_receive(:polymorphic_path).with(["main_app_proxy", "admin", Namespace::MyResource], {})
+        @controller.resources_path
+      end
+    end
+
+    it "should provide a new_resource_path method" do
+      @controller.should_receive(:new_polymorphic_path).with(["main_app_proxy", "admin", Namespace::MyResource], {})
+      @controller.new_resource_path
+    end
+
+    it "should provide a edit_resource_path method" do
+      my_resource_item = stub
+      @controller.should_receive(:edit_polymorphic_path).with(["main_app_proxy", "admin", my_resource_item], {})
+      @controller.edit_resource_path(my_resource_item)
+    end
+
+  end
+
+  describe "resource_instance_variable" do
+    it "should return the resource_item" do
+      @controller.resource_instance_variable.should == @resource_item
+    end
+  end
+
+  describe "resources_instance_variable" do
+    it "should return a collection of resource_items" do
+      @controller.resources_instance_variable.should == [@resource_item]
+    end
+  end
+
+  describe "resource_window_size" do
+    it "should do something"
+  end
+end

data/spec/models/content_spec.rb

@@ -2,99 +2,99 @@ require 'spec_helper'
 
 describe Alchemy::Content do
 
-	it "should return the ingredient from its essence" do
-		@element = Factory(:element, :name => 'headline')
-		@content = @element.contents.find_by_essence_type('Alchemy::EssenceText')
-		@content.essence.update_attributes(:body => "Hello")
-		@content.ingredient.should == "Hello"
-	end
+  it "should return the ingredient from its essence" do
+    @element = Factory(:element, :name => 'headline')
+    @content = @element.contents.find_by_essence_type('Alchemy::EssenceText')
+    @content.essence.update_attributes(:body => "Hello")
+    @content.ingredient.should == "Hello"
+  end
 
-	describe '.normalize_essence_type' do
+  describe '.normalize_essence_type' do
 
-		context "passing namespaced essence type" do
+    context "passing namespaced essence type" do
 
-			it "should not add alchemy namespace" do
-				Alchemy::Content.normalize_essence_type('Alchemy::EssenceText').should == "Alchemy::EssenceText"
-			end
+      it "should not add alchemy namespace" do
+        Alchemy::Content.normalize_essence_type('Alchemy::EssenceText').should == "Alchemy::EssenceText"
+      end
 
-		end
+    end
 
-		context "passing not namespaced essence type" do
+    context "passing not namespaced essence type" do
 
-			it "should add alchemy namespace" do
-				Alchemy::Content.normalize_essence_type('EssenceText').should == "Alchemy::EssenceText"
-			end
+      it "should add alchemy namespace" do
+        Alchemy::Content.normalize_essence_type('EssenceText').should == "Alchemy::EssenceText"
+      end
 
-		end
+    end
 
-	end
+  end
 
-	describe '#normalized_essence_type' do
+  describe '#normalized_essence_type' do
 
-		context "without namespace in essence_type column" do
+    context "without namespace in essence_type column" do
 
-			it "should return the namespaced essence type" do
-				Alchemy::Content.new(:essence_type => 'EssenceText').normalized_essence_type.should == 'Alchemy::EssenceText'
-			end
+      it "should return the namespaced essence type" do
+        Alchemy::Content.new(:essence_type => 'EssenceText').normalized_essence_type.should == 'Alchemy::EssenceText'
+      end
 
-		end
+    end
 
-		context "with namespace in essence_type column" do
+    context "with namespace in essence_type column" do
 
-			it "should return the namespaced essence type" do
-				Alchemy::Content.new(:essence_type => 'Alchemy::EssenceText').normalized_essence_type.should == 'Alchemy::EssenceText'
-			end
+      it "should return the namespaced essence type" do
+        Alchemy::Content.new(:essence_type => 'Alchemy::EssenceText').normalized_essence_type.should == 'Alchemy::EssenceText'
+      end
 
-		end
+    end
 
-	end
+  end
 
-	describe '#update_essence' do
+  describe '#update_essence' do
 
-		it "should update the attributes of related essence and return true" do
-			@element = Factory(:element, :name => 'text')
-			@content = @element.contents.first
-			@content.update_essence(:body => 'Mikes Petshop')
-			@content.ingredient.should == "Mikes Petshop"
-		end
+    it "should update the attributes of related essence and return true" do
+      @element = Factory(:element, :name => 'text')
+      @content = @element.contents.first
+      @content.update_essence(:body => 'Mikes Petshop')
+      @content.ingredient.should == "Mikes Petshop"
+    end
 
-		it "should add error messages if save fails and return false" do
-			@element = Factory(:element, :name => 'contactform')
-			@content = @element.contents.first
-			@content.update_essence
-			@content.errors[:essence].should have(1).item
-		end
+    it "should add error messages if save fails and return false" do
+      @element = Factory(:element, :name => 'contactform')
+      @content = @element.contents.first
+      @content.update_essence
+      @content.errors[:essence].should have(1).item
+    end
 
-		it "should raise error if essence is missing" do
-			@element = Factory(:element, :name => 'text')
-			@content = @element.contents.first
-			@content.update_essence
-		end
+    it "should raise error if essence is missing" do
+      @element = Factory(:element, :name => 'text')
+      @content = @element.contents.first
+      @content.update_essence
+    end
 
-	end
+  end
 
-	describe '#copy' do
+  describe '#copy' do
 
-		before(:each) do
-			@element = Factory(:element, :name => 'text')
-			@content = @element.contents.first
-		end
+    before(:each) do
+      @element = Factory(:element, :name => 'text')
+      @content = @element.contents.first
+    end
 
-		it "should create a new record with all attributes of source except given differences" do
-			copy = Alchemy::Content.copy(@content, {:name => 'foobar', :element_id => @element.id + 1})
-			copy.name.should == 'foobar'
-		end
+    it "should create a new record with all attributes of source except given differences" do
+      copy = Alchemy::Content.copy(@content, {:name => 'foobar', :element_id => @element.id + 1})
+      copy.name.should == 'foobar'
+    end
 
-		it "should make a new record for essence of source" do
-			copy = Alchemy::Content.copy(@content, {:element_id => @element.id + 1})
-			copy.essence_id.should_not == @content.essence_id
-		end
+    it "should make a new record for essence of source" do
+      copy = Alchemy::Content.copy(@content, {:element_id => @element.id + 1})
+      copy.essence_id.should_not == @content.essence_id
+    end
 
-		it "should copy source essence attributes" do
-			copy = Alchemy::Content.copy(@content, {:element_id => @element.id + 1})
-			copy.essence.body == @content.essence.body
-		end
+    it "should copy source essence attributes" do
+      copy = Alchemy::Content.copy(@content, {:element_id => @element.id + 1})
+      copy.essence.body == @content.essence.body
+    end
 
-	end
+  end
 
 end