lalala 4.0.0.dev.141 → 4.0.0.dev.144

data/vendor/deps/active_admin/spec/unit/resource_controller/data_access_spec.rb

@@ -1,74 +0,0 @@
-require 'spec_helper'
-
-describe ActiveAdmin::ResourceController::DataAccess do
-  let(:params) do
-    {}
-  end
-
-  let(:controller) do
-    rc = Admin::PostsController.new
-    rc.stub!(:params) do
-      params
-    end
-    rc
-  end
-
-  describe "searching" do
-    let(:params){ {:q => {} }}
-
-    it "should call the metasearch method" do
-      chain = mock("ChainObj")
-      chain.should_receive(:metasearch).with(params[:q]).once.and_return(Post.search)
-      controller.send :apply_filtering, chain
-    end
-
-  end
-
-  describe "sorting" do
-
-    context "for table columns" do
-      let(:params){ {:order => "id_asc" }}
-      it "should prepend the table name" do
-        chain = mock("ChainObj")
-        chain.should_receive(:reorder).with("\"posts\".\"id\" asc").once.and_return(Post.search)
-        controller.send :apply_sorting, chain
-      end
-    end
-
-    context "for virtual columns" do
-      let(:params){ {:order => "virtual_id_asc" }}
-      it "should not prepend the table name" do
-        chain = mock("ChainObj")
-        chain.should_receive(:reorder).with("\"virtual_id\" asc").once.and_return(Post.search)
-        controller.send :apply_sorting, chain
-      end
-    end
-
-  end
-
-  describe "scoping" do
-
-    context "when no current scope" do
-      it "should set collection_before_scope to the chain and return the chain" do
-        chain = mock("ChainObj")
-        controller.send(:apply_scoping, chain).should == chain
-        controller.send(:collection_before_scope).should == chain
-      end
-    end
-
-    context "when current scope" do
-      it "should set collection_before_scope to the chain and return the scoped chain" do
-        chain = mock("ChainObj")
-        scoped_chain = mock("ScopedChain")
-        current_scope = mock("CurrentScope")
-        controller.stub!(:current_scope) { current_scope }
-
-        controller.should_receive(:scope_chain).with(current_scope, chain) { scoped_chain }
-        controller.send(:apply_scoping, chain).should == scoped_chain
-        controller.send(:collection_before_scope).should == chain
-      end
-    end
-
-  end
-
-end

data/vendor/deps/active_admin/spec/unit/resource_controller/sidebars_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-
-describe ActiveAdmin::ResourceController::Sidebars do
-  let(:controller){ Admin::PostsController }
-
-  context 'without before_filter' do
-    before do
-      ActiveAdmin.register Post
-    end
-
-    subject { find_before_filter controller, :skip_sidebar! }
-
-    it { should set_skip_sidebar_to nil }
-  end
-
-  describe '#skip_sidebar!' do
-    before do
-      ActiveAdmin.register Post do
-        before_filter :skip_sidebar!
-      end
-    end
-
-    subject { find_before_filter controller, :skip_sidebar! }
-
-    it { should set_skip_sidebar_to true }
-  end
-
-  def find_before_filter(controller, filter)
-    #raise controller._process_action_callbacks.map(&:filter).inspect
-    controller._process_action_callbacks.detect { |f| f.raw_filter == filter.to_sym }
-  end
-
-  RSpec::Matchers.define :set_skip_sidebar_to do |expected|
-    match do |filter|
-      klass = filter && filter.klass || controller
-      object = klass.new
-      object.send filter.raw_filter if filter
-      @actual = object.instance_variable_get(:@skip_sidebar)
-      @actual == expected
-    end
-
-    failure_message_for_should do |filter|
-      message = "expected before_filter to set @skip_sidebar to '#{expected}', but was '#{@actual}'"
-    end
-  end
-end

data/vendor/deps/active_admin/spec/unit/resource_controller_spec.rb

@@ -1,266 +0,0 @@
-require 'spec_helper'
-
-describe ActiveAdmin::ResourceController do
-
-  before(:all) { load_defaults! }
-
-  let(:controller) { ActiveAdmin::ResourceController.new }
-
-  describe "authenticating the user" do
-    let(:controller){ Admin::PostsController.new }
-
-    it "should do nothing when no authentication_method set" do
-      namespace = controller.class.active_admin_config.namespace
-      namespace.should_receive(:authentication_method).once.and_return(nil)
-
-      controller.send(:authenticate_active_admin_user)
-    end
-
-    it "should call the authentication_method when set" do
-      namespace = controller.class.active_admin_config.namespace
-
-      namespace.should_receive(:authentication_method).twice.
-        and_return(:authenticate_admin_user!)
-
-      controller.should_receive(:authenticate_admin_user!).and_return(true)
-
-      controller.send(:authenticate_active_admin_user)
-    end
-
-  end
-
-  describe "retrieving the current user" do
-    let(:controller){ Admin::PostsController.new }
-
-    it "should return nil when no current_user_method set" do
-      namespace = controller.class.active_admin_config.namespace
-      namespace.should_receive(:current_user_method).once.and_return(nil)
-
-      controller.send(:current_active_admin_user).should == nil
-    end
-
-    it "should call the current_user_method when set" do
-      user = mock
-      namespace = controller.class.active_admin_config.namespace
-
-      namespace.should_receive(:current_user_method).twice.
-        and_return(:current_admin_user)
-
-      controller.should_receive(:current_admin_user).and_return(user)
-
-      controller.send(:current_active_admin_user).should == user
-    end
-  end
-
-
-  describe "callbacks" do
-    let(:application){ ::ActiveAdmin::Application.new }
-    let(:namespace){ ActiveAdmin::Namespace.new(application, :admin) }
-
-    before :all do
-      namespace.register Post do
-        after_build :call_after_build
-        before_save :call_before_save
-        after_save :call_after_save
-        before_create :call_before_create
-        after_create :call_after_create
-        before_update :call_before_update
-        after_update :call_after_update
-        before_destroy :call_before_destroy
-        after_destroy :call_after_destroy
-
-        controller do
-          def call_after_build(obj); end
-          def call_before_save(obj); end
-          def call_after_save(obj); end
-          def call_before_create(obj); end
-          def call_after_create(obj); end
-          def call_before_update(obj); end
-          def call_after_update(obj); end
-          def call_before_destroy(obj); end
-          def call_after_destroy(obj); end
-        end
-      end
-    end
-
-    describe "performing create" do
-      let(:controller){ Admin::PostsController.new }
-      let(:resource){ mock("Resource", :save => true) }
-
-      before do
-        resource.should_receive(:save)
-      end
-
-      it "should call the before create callback" do
-        controller.should_receive(:call_before_create).with(resource)
-        controller.send :create_resource, resource
-      end
-      it "should call the before save callback" do
-        controller.should_receive(:call_before_save).with(resource)
-        controller.send :create_resource, resource
-      end
-      it "should call the after save callback" do
-        controller.should_receive(:call_after_save).with(resource)
-        controller.send :create_resource, resource
-      end
-      it "should call the after create callback" do
-        controller.should_receive(:call_after_create).with(resource)
-        controller.send :create_resource, resource
-      end
-    end
-
-    describe "performing update" do
-      let(:controller){ Admin::PostsController.new }
-      let(:resource){ mock("Resource", :attributes= => true, :save => true) }
-      let(:attributes){ [{}] }
-
-      before do
-        resource.should_receive(:attributes=).with(attributes[0])
-        resource.should_receive(:save)
-      end
-
-      it "should call the before update callback" do
-        controller.should_receive(:call_before_update).with(resource)
-        controller.send :update_resource, resource, attributes
-      end
-      it "should call the before save callback" do
-        controller.should_receive(:call_before_save).with(resource)
-        controller.send :update_resource, resource, attributes
-      end
-      it "should call the after save callback" do
-        controller.should_receive(:call_after_save).with(resource)
-        controller.send :update_resource, resource, attributes
-      end
-      it "should call the after create callback" do
-        controller.should_receive(:call_after_update).with(resource)
-        controller.send :update_resource, resource, attributes
-      end
-    end
-
-    describe "performing destroy" do
-      let(:controller){ Admin::PostsController.new }
-      let(:resource){ mock("Resource", :destroy => true) }
-
-      before do
-        resource.should_receive(:destroy)
-      end
-
-      it "should call the before destroy callback" do
-        controller.should_receive(:call_before_destroy).with(resource)
-        controller.send :destroy_resource, resource
-      end
-
-      it "should call the after destroy callback" do
-        controller.should_receive(:call_after_destroy).with(resource)
-        controller.send :destroy_resource, resource
-      end
-    end
-  end
-end
-
-describe Admin::PostsController, :type => "controller" do
-
-  describe 'retreiving the resource' do
-    let(:controller){ Admin::PostsController.new }
-    let(:post) { Post.new :title => "An incledibly unique Post Title" }
-
-    before do
-      Post.stub(:find).and_return(post)
-      controller.class_eval { public :resource }
-      controller.stub(:params).and_return({ :id => '1' })
-    end
-
-    subject { controller.resource }
-
-    it "returns a Post" do
-      subject.should be_kind_of(Post)
-    end
-
-    context 'with a decorator' do
-      let(:config) { controller.class.active_admin_config }
-      before { config.decorator_class_name = '::PostDecorator' }
-      it 'returns a PostDecorator' do
-        subject.should be_kind_of(PostDecorator)
-      end
-
-      it 'returns a PostDecorator that wraps the post' do
-        subject.title.should == post.title
-      end
-    end
-  end
-
-  describe 'retreiving the resource collection' do
-    let(:controller){ Admin::PostsController.new }
-    before do
-      Post.create!(:title => "An incledibly unique Post Title") if Post.count == 0
-      controller.class_eval { public :collection }
-    end
-
-    subject { controller.collection }
-
-    it {
-      pending # doesn't pass when running whole spec suite (WTF)
-      should be_kind_of(ActiveRecord::Relation)
-    }
-
-    it "returns a collection of posts" do
-      pending # doesn't pass when running whole spec suite (WTF)
-      subject.first.should be_kind_of(Post)
-    end
-
-    context 'with a decorator' do
-      let(:config) { controller.class.active_admin_config }
-      before { config.decorator_class_name = '::PostDecorator' }
-
-      it 'returns a PostDecorator' do
-        pending # doesn't pass when running whole spec suite (WTF)
-        subject.should be_kind_of(PostDecorator::DecoratedEnumerableProxy)
-      end
-
-      it 'returns a PostDecorator that wraps the post' do
-        pending # doesn't pass when running whole spec suite (WTF)
-        subject.first.title.should == Post.first.title
-      end
-    end
-  end
-
-
-  describe "performing batch_action" do
-    let(:controller){ Admin::PostsController.new }
-    before do
-      batch_action = ActiveAdmin::BatchAction.new :flag, "Flag" do
-        redirect_to collection_path
-      end
-
-      controller.class.active_admin_config.stub!(:batch_actions).and_return([batch_action])
-    end
-
-    describe "when params batch_action matches existing BatchAction" do
-      it "should call the block with args" do
-        pending # dont know how to check if the block was called
-      end
-    end
-
-    describe "when params batch_action doesn't match a BatchAction" do
-      it "should raise an error" do
-        pending # doesn't pass when running whole spec suite (WTF)
-
-        lambda {
-          post(:batch_action, :batch_action => "derp", :collection_selection => ["1"])
-        }.should raise_error("Couldn't find batch action \"derp\"")
-      end
-    end
-
-    describe "when params batch_action is blank" do
-      it "should raise an error" do
-        pending # doesn't pass when running whole spec suite (WTF)
-
-        lambda {
-          post(:batch_action, :collection_selection => ["1"])
-        }.should raise_error("Couldn't find batch action \"\"")
-      end
-    end
-
-  end
-
-end

data/vendor/deps/active_admin/spec/unit/resource_registration_spec.rb

@@ -1,65 +0,0 @@
-require 'spec_helper' 
-
-describe "Registering an object to administer" do
-  let(:application){ ActiveAdmin::Application.new }
-
-  context "with no configuration" do
-    let(:namespace) { ActiveAdmin::Namespace.new(application, :admin) }
-    it "should call register on the namespace" do
-      application.namespaces[namespace.name] = namespace
-      namespace.should_receive(:register)
-
-      application.register Category
-    end
-
-    it "should dispatch a Resource::RegisterEvent" do
-      ActiveAdmin::Event.should_receive(:dispatch).with(ActiveAdmin::Resource::RegisterEvent, an_instance_of(ActiveAdmin::Resource))
-      application.register Category
-    end
-  end
-
-  context "with a different namespace" do
-    it "should call register on the namespace" do
-      namespace = ActiveAdmin::Namespace.new(application, :hello_world)
-      application.namespaces[namespace.name] = namespace
-      namespace.should_receive(:register)
-
-      application.register Category, :namespace => :hello_world
-    end
-
-    it "should generate a Namespace::RegisterEvent and a Resource::RegisterEvent" do
-      ActiveAdmin::Event.should_receive(:dispatch).with(ActiveAdmin::Namespace::RegisterEvent, an_instance_of(ActiveAdmin::Namespace))
-      ActiveAdmin::Event.should_receive(:dispatch).with(ActiveAdmin::Resource::RegisterEvent, an_instance_of(ActiveAdmin::Resource))
-      application.register Category, :namespace => :not_yet_created
-    end
-  end
-
-  context "with no namespace" do
-    it "should call register on the root namespace" do
-      namespace = ActiveAdmin::Namespace.new(application, :root)
-      application.namespaces[namespace.name] = namespace
-      namespace.should_receive(:register)
-
-      application.register Category, :namespace => false
-    end
-  end
-
-  context "when being registered multiple times" do
-    it "should run the dsl in the same config object" do
-      config_1 = ActiveAdmin.register(Category) { filter :name }
-      config_2 = ActiveAdmin.register(Category) { filter :id }
-      config_1.should == config_2
-      config_1.filters.size.should == 2
-    end
-
-    context "with different resource classes" do
-      it "should raise an ActiveAdmin::ResourceMismatch" do
-        lambda {
-          ActiveAdmin.register Category
-          ActiveAdmin.register Post, :as => "Category"
-        }.should raise_error(ActiveAdmin::ResourceMismatchError)
-      end
-    end
-  end
-
-end

data/vendor/deps/active_admin/spec/unit/resource_spec.rb

@@ -1,250 +0,0 @@
-require 'spec_helper' 
-require File.expand_path('config_shared_examples', File.dirname(__FILE__))
-
-module ActiveAdmin
-  describe Resource do
-
-    it_should_behave_like "ActiveAdmin::Config"
-
-    before { load_defaults! }
-
-    let(:application){ ActiveAdmin::Application.new }
-    let(:namespace){ Namespace.new(application, :admin) }
-
-    def config(options = {})
-      @config ||= Resource.new(namespace, Category, options)
-    end
-
-    it { respond_to :resource_class }
-
-    describe "#resource_table_name" do
-      it "should return the resource's table name" do
-        config.resource_table_name.should == '"categories"'
-      end
-      context "when the :as option is given" do
-        it "should return the resource's table name" do
-          config(:as => "My Category").resource_table_name.should == '"categories"'
-        end
-      end
-    end
-
-    describe "#resource_column_names" do
-      it "should return the resource's column names" do
-        config.resource_column_names.should == Category.column_names
-      end
-    end
-
-    describe '#decorator_class' do
-      it 'returns nil by default' do
-        config.decorator_class.should be_nil
-      end
-      context 'when a decorator is defined' do
-        let(:resource) { namespace.register(Post) { decorate_with PostDecorator } }
-        specify '#decorator_class_name should return PostDecorator' do
-          resource.decorator_class_name.should == '::PostDecorator'
-        end
-
-        it 'returns the decorator class' do
-          resource.decorator_class.should == PostDecorator
-        end
-      end
-    end
-
-
-    describe "controller name" do
-      it "should return a namespaced controller name" do
-        config.controller_name.should == "Admin::CategoriesController"
-      end
-      context "when non namespaced controller" do
-        let(:namespace){ ActiveAdmin::Namespace.new(application, :root) }
-        it "should return a non namespaced controller name" do
-          config.controller_name.should == "CategoriesController"
-        end
-      end
-    end
-
-    describe "#include_in_menu?" do
-      let(:namespace){ ActiveAdmin::Namespace.new(application, :admin) }
-      subject{ resource }
-
-      context "when regular resource" do
-        let(:resource){ namespace.register(Post) }
-        it { should be_include_in_menu }
-      end
-
-      context "when menu set to false" do
-        let(:resource){ namespace.register(Post){ menu false } }
-        it { should_not be_include_in_menu }
-      end
-    end
-
-    describe "#belongs_to" do
-
-      it "should build a belongs to configuration" do
-        config.belongs_to_config.should be_nil
-        config.belongs_to :posts
-        config.belongs_to_config.should_not be_nil
-      end
-
-      it "should set the target menu to the belongs to target" do
-        config.menu_item_menu_name.should == ActiveAdmin::DEFAULT_MENU
-        config.belongs_to :posts
-        config.menu_item_menu_name.should == :posts
-      end
-
-    end
-
-    describe "route names" do
-      it "should return the route prefix" do
-        config.route_prefix.should == "admin"
-      end
-      it "should return the route collection path" do
-        config.route_collection_path.should == "/admin/categories"
-      end
-
-      context "when in the root namespace" do
-        let(:config){ application.register Category, :namespace => false}
-        it "should have a nil route_prefix" do
-          config.route_prefix.should == nil
-        end
-
-        it "should generate a correct route" do
-          config
-          reload_routes!
-          config.route_collection_path.should == "/categories"
-        end
-      end
-
-      context "when registering a plural resource" do
-        class ::News; def self.has_many(*); end end
-
-        it "should return the plurali route with _index" do
-          config = application.register News
-          reload_routes!
-          config.route_collection_path.should == "/admin/news"
-        end
-      end
-    end
-
-    describe "scoping" do
-      context "when using a block" do
-        before do
-          @resource = application.register Category do
-            scope_to do
-              "scoped"
-            end
-          end
-        end
-        it "should call the proc for the begin of association chain" do
-          begin_of_association_chain = @resource.controller.new.send(:begin_of_association_chain)
-          begin_of_association_chain.should == "scoped"
-        end
-      end
-
-      context "when using a symbol" do
-        before do
-          @resource = application.register Category do
-            scope_to :current_user
-          end
-        end
-        it "should call the method for the begin of association chain" do
-          controller = @resource.controller.new
-          controller.should_receive(:current_user).and_return(true)
-          begin_of_association_chain = controller.send(:begin_of_association_chain)
-          begin_of_association_chain.should == true
-        end
-      end
-
-      context "when not using a block or symbol" do
-        before do
-          @resource = application.register Category do
-            scope_to "Some string"
-          end
-        end
-        it "should raise and exception" do
-          lambda {
-            @resource.controller.new.send(:begin_of_association_chain)
-          }.should raise_error(ArgumentError)
-        end
-      end
-
-      describe "getting the method for the association chain" do
-        context "when a simple registration" do
-          before do
-            @resource = application.register Category do
-              scope_to :current_user
-            end
-          end
-          it "should return the pluralized collection name" do
-            @resource.controller.new.send(:method_for_association_chain).should == :categories
-          end
-        end
-        context "when passing in the method as an option" do
-          before do
-            @resource = application.register Category do
-              scope_to :current_user, :association_method => :blog_categories
-            end
-          end
-          it "should return the method from the option" do
-            @resource.controller.new.send(:method_for_association_chain).should == :blog_categories
-          end
-        end
-      end
-    end
-
-
-    describe "sort order" do
-
-      context "when resource class responds to primary_key" do
-        it "should sort by primary key desc by default" do
-          MockResource.should_receive(:primary_key).and_return("pk")
-          config = Resource.new(namespace, MockResource)
-          config.sort_order.should == "pk_desc"
-        end
-      end
-
-      context "when resource class does not respond to primary_key" do
-        it "should default to id" do
-          config = Resource.new(namespace, MockResource)
-          config.sort_order.should == "id_desc"
-        end
-      end
-
-      it "should be set-able" do
-        config.sort_order = "task_id_desc"
-        config.sort_order.should == "task_id_desc"
-      end
-
-    end
-
-    describe "adding a scope" do
-
-      it "should add a scope" do
-        config.scope :published
-        config.scopes.first.should be_a(ActiveAdmin::Scope)
-        config.scopes.first.name.should == "Published"
-      end
-
-      it "should retrive a scope by its id" do
-        config.scope :published
-        config.get_scope_by_id(:published).name.should == "Published"
-      end
-    end
-
-    describe "#csv_builder" do
-      context "when no csv builder set" do
-        it "should return a default column builder with id and content columns" do
-          config.csv_builder.columns.size.should == Category.content_columns.size + 1
-        end
-      end
-
-      context "when csv builder set" do
-        it "shuld return the csv_builder we set" do
-          csv_builder = CSVBuilder.new
-          config.csv_builder = csv_builder
-          config.csv_builder.should == csv_builder
-        end
-      end
-    end
-  end
-end