lolita 3.2.0.rc.7 → 3.2.0.rc.9

data/spec/configuration/search_spec.rb

@@ -36,7 +36,7 @@ describe Lolita::Configuration::Search do
   describe "#run" do
 
     it "should run search on custom class" do
-      Factory.create(:post, :title => "my_title")
+      Fabricate(:post, :title => "my_title")
       search = Lolita::Configuration::Search.new(dbi, :with => CustomSearch)
       search.run("my_title",Object.new).size.should == 1
     end

data/spec/configuration/tabs_spec.rb

@@ -1,106 +1,121 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-module Lolita
-  module Configuration
-    module Tab
-      class Images < Lolita::Configuration::Tab::Base
-      end
-      class Translation < Lolita::Configuration::Tab::Base
-      end
-    end
-  end
-end
+require File.expand_path(File.dirname(__FILE__) + '/../simple_spec_helper')
+require 'ruby-debug'
 
 describe Lolita::Configuration::Tabs do
-  before(:each) do
-    @dbi=Lolita::DBI::Base.create(Post)
+  let(:klass){Lolita::Configuration::Tabs}
+  let(:dbp_klass){Lolita::DBI::Base}
+  let(:dbp){ Object.new }
+  let(:tabs){klass.new(dbp)}
+
+  # before(:each) do
+  #   dbp_class.stub(:create).with(kind_of(Class)).and_return(dbp)
+  # end
+
+  it "should set attributes from args to tabs" do 
+    args = [1,2,3]
+    klass.any_instance.should_receive(:set_attributes).with(*args)
+    klass.new(dbp,*args)
   end
 
-  it "should create tabs when Array is given" do
-    tabs=Lolita::Configuration::Tabs.new(@dbi)
-    tabs.size.should == 0
+  it "should eval block when given" do 
+    block = Proc.new{}
+    klass.any_instance.should_receive(:instance_eval).with(&block)
+    klass.new(dbp,&block)
   end
 
-  it "should create tabs when block is given" do
-    tabs=Lolita::Configuration::Tabs.new(@dbi) {}
-    tabs.size.should == 0
+  it "should initialize default attributes when instance is created" do 
+    tabs = klass.new(dbp)
+    tabs.should be_empty
+    tabs.tab_types.should eq([:content])
   end
 
-  it "should create tabs when specifid in block" do
-    tabs=Lolita::Configuration::Tabs.new(@dbi) do
-      tab(:content)
+  it "should be enumerable and yield each tab at once" do 
+    tabs.instance_variable_set(:@tabs, [1,2,3])
+    tabs.each_with_index do |tab,index|
+      tab.should eq(index+1)
     end
-    tabs.size.should == 1
   end
 
-  it "should create tabs when specified as arguments" do
-    tabs=Lolita::Configuration::Tabs.new(@dbi,:tabs=>[Lolita::Configuration::Tab::Base.new(@dbi,:content)])
-    tabs.size.should == 1
+  it "should create content tab when accessing any tab and none is given" do 
+    tabs.should_receive(:create_content_tab)
+    tabs.any?
   end
 
-  it "should create default tabs" do
-    tabs=Lolita::Configuration::Tabs.new(@dbi) do
-      default :content,:images
-    end
-    tabs.size.should > 0
+  it "should accept collection of tabs and iterate through them and assign to itself through builder" do 
+    tabs.should_receive(:build_element).twice
+    tabs.tabs= [1,2]
   end
 
-  it "should exclude all default tabs" do
-    tabs=Lolita::Configuration::Tabs.new(@dbi) do
-      exclude :all
-    end
-    tabs.size.should == 0
-    tabs.excluded.size.should > 0
+  it "should raise ArgumentError when assigned tabs is not collection" do 
+    expect{
+      tabs.tabs = Object.new
+    }.to raise_error(ArgumentError)
   end
 
-  it "should exclude specific tabs" do
-    tabs=Lolita::Configuration::Tabs.new(@dbi)
-    tabs.exclude :images
-    tabs.excluded.size.should == 1
+  it "should add tab with no args" do 
+    klass.any_instance.should_receive(:build_element).twice.and_return(1)
+    tabs.tab
+    tabs.should have(1).item
   end
 
-  it "should add tabs" do
-    tabs=Lolita::Configuration::Tabs.new(@dbi,:exclude=>:all)
-    tabs<<:images
-    tabs<<:content
-    tabs.size.should == 2
+  it "should return all field of each tab" do 
+    arr = [stub(:fields => [1,2]),stub(:fields => [3,4])]
+    tabs.instance_variable_set(:@tabs,arr)
+    tabs.fields.should eq([1,2,3,4])
   end
 
-  it "should raise error when two same type tabs are added" do
-    lambda{
-      tabs=Lolita::Configuration::Tabs.new(@dbi) do
-        tab :content
-        tab :content
-      end
-    }.should raise_error Lolita::SameTabTypeError
+  it "should detect tab by type" do 
+    arr = [stub(:type => :content),stub(:type => :image)]
+    tabs.instance_variable_set(:@tabs,arr)
+    tabs.by_type(:image).should_not be_nil
+    tabs.by_type(:not_existing).should be_nil
   end
 
-  it "should create real tabs when not tab is provided" do
-    tabs=Lolita::Configuration::Tabs.new(@dbi,:default=>:content)
-    tabs<<:images
-    tabs<<:translation
-    tabs[tabs.size-2].class.should == Lolita::Configuration::Tab::Images
-    tabs[tabs.size-1].class.should == Lolita::Configuration::Tab::Translation
+  it "should return all tabs names" do 
+    arr = [stub(:name => "n1"),stub(:name => "n2")]
+    tabs.instance_variable_set(:@tabs,arr)
+    tabs.names.should eq(["n1","n2"])
   end
 
-  it "should return all tab names" do
-    tabs=Lolita::Configuration::Tabs.new(@dbi) do
-      tab :content
-    end
-    tabs.names.size.should > 0
+  it "should return all associated tabs" do 
+    arr = [stub(:dissociate => true),stub(:dissociate => false)]
+    tabs.instance_variable_set(:@tabs,arr)
+    tabs.associated.should have(1).item
+  end
+
+  it "should return all dissociated tabs" do 
+    arr = [stub(:dissociate => true),stub(:dissociate => false)]
+    tabs.instance_variable_set(:@tabs,arr)
+    tabs.dissociated.should have(1).item
+  end
+
+  it "should populate self with default tabs" do 
+    tabs.stub(:build_element).and_return(stub())
+    tabs.default
+    tabs.should have(1).item
   end
 
-  context "tab finding" do
-    it "should find by type" do
-      tabs=Lolita::Configuration::Tabs.new(@dbi) do
-        tab :default do
-          field :name, :string
-        end
-        tab :content
-      end
-      tabs.by_type(:content).should_not be_nil
+  context "adding tabs" do 
+    it "should skip factory call when tab is not Hash or Symbol" do 
+      tab = stub()
+      tabs.tab(tab)
+      tabs.first.should == tab
     end
 
+    it "should call factory when tab is Hash" do 
+      tab = stub()
+      Lolita::Configuration::Factory::Tab.stub(:add).and_return(tab)
+      tabs.tab({})
+      tabs.first.should == tab
+    end
+
+    it "should call factory when tab is Symbol" do 
+      tab = stub()
+      Lolita::Configuration::Factory::Tab.stub(:add).and_return(tab)
+      tabs.tab(:image)
+      tabs.first.should == tab
+    end
   end
+
 end
 

data/spec/controllers/configuration_spec.rb

@@ -0,0 +1,15 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Lolita::RestController do
+  render_views
+
+  before(:each) do
+    @controller.request.env["lolita.mapping"]=Lolita.mappings[:post]
+  end
+
+  it "should add custom assets to Lolita" do
+    Lolita.application.assets += ["lolita_js_extensions.js"]
+    get :index
+    response.body.should =~/lolita_js_extensions.js/
+  end
+end

data/spec/controllers/internal_helpers_spec.rb

@@ -4,7 +4,7 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 class MyController < ApplicationController
-  include Lolita::Controllers::InternalHelpers
+  include Lolita::Controllers::RailsHelpers
   include Lolita::Hooks
   add_hook :before_build_resource,:after_build_resource
   add_hook :before_index

data/spec/controllers/lolita_rest_spec.rb

@@ -4,7 +4,7 @@ describe Lolita::RestController do
   render_views
   
   before(:each) do
-    @controller.request.env["lolita.mapping"]=Lolita.mappings[:post]
+    @request.env["lolita.mapping"]=Lolita.mappings[:post]
   end
 
   describe "hooks" do
@@ -25,7 +25,7 @@ describe Lolita::RestController do
 
   it "should overwrite list component body_cell" do
     pending "Need to be seperated from whole project"
-    Factory.create(:post)
+    Fabricate(:post)
     get :index
     response.body.should =~/overwritten cell/
   end
@@ -49,5 +49,34 @@ describe Lolita::RestController do
 
   it "should use field.title instead of field.name when displaying all error messages at top of form"
 
+  describe "nested lists" do
+
+    it "should have nested lists for columns" do
+      pending "Need to fix this"
+      get :index
+      response.body.should match(/tr.*class\s*=.*with-nested-list.*data-nested-list-url/)
+    end
+
+    it "should have nested lists for whole row" do
+      pending "Need to fix this"
+      @request.env["lolita.mapping"]=Lolita.mappings[:category]
+      get :index
+      response.body.should match(/tr.*class.*with-nested-list.*data-nested-list-url/)
+    end
+
+    it "should have nested list for nested lists" do
+      pending "Need to fix this"
+      categories = (1..5).to_a.map{|i|
+        Fabricate(:category)
+      }
+      2.times{Fabricate(:post, :category => categories.first)}
+      get :index, {:nested => {"category_id" => categories.last}}
+      response.body.should_not match(/tr/)
+      get :index, {:nested => {"category_id" => categories.first}}
+      response.body.scan(/<tr>/).should have(2).items
+      response.body.should match(/td.*class.*with-nested-list/)
+    end
+  end
+
 end
 

data/spec/coverage_helper.rb

@@ -0,0 +1,33 @@
+  require 'cover_me'
+  require 'ruby-debug'
+  CoverMe.config do |c|
+    # where is your project's root:
+    c.project.root = File.expand_path("../lolita") # => "Rails.root" (default)
+    
+    # what files are you interested in coverage for:
+    c.file_pattern =  [
+      /(#{CoverMe.config.project.root}\/app\/.+\.rb)/i,
+      /(#{CoverMe.config.project.root}\/lib\/.+\.rb)/i
+    ] 
+    
+    c.formatter = CoverMe::HtmlFormatter
+    # what files do you want to explicitly exclude from coverage
+    #c.exclude_file_patterns # => [] (default)
+  
+    # where do you want the HTML generated:
+    #c.html_formatter.output_path # => File.join(CoverMe.config.project.root, 'coverage') (default)
+  
+    # what do you want to happen when it finishes:
+    c.at_exit = Proc.new {
+      if CoverMe.config.formatter == CoverMe::HtmlFormatter
+        index = File.join(CoverMe.config.html_formatter.output_path, 'index.html')
+        if File.exists?(index)
+          `open #{index}`
+        end
+      end
+    } 
+  end
+
+  at_exit do 
+    CoverMe.complete!
+  end

data/spec/extensions/authentication/default_adapter_spec.rb

@@ -0,0 +1,34 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../simple_spec_helper')
+
+describe Lolita::Extensions::Authentication::DefaultAdapter do
+  let(:klass){ Lolita::Extensions::Authentication::DefaultAdapter }
+  let(:adapter){ klass.new(Object.new,{}) }
+
+  it "should create new DefaultAdapter" do
+    expect do
+      klass.new(Object.new,{})
+    end.not_to raise_error
+  end
+
+  it "should not have current user" do
+    adapter.current_user.should be_nil
+  end
+
+  it "should not be signed in" do
+    adapter.user_signed_in?.should be_false
+  end
+
+  it "should authenticate user" do
+    adapter.authenticate_user!.should be_true
+  end
+
+  describe 'Integration with proxy' do
+    let(:proxy){ Lolita::Extensions::Authentication::Proxy.new(Object.new,{}) }
+      it "should have the same method results for adapter and proxy" do
+        proxy.adapter = adapter
+        %w(current_user user_signed_in? authenticate_user!).each do |name|
+          proxy.send(name).should eql(adapter.send(name))
+        end
+      end
+  end
+end

data/spec/extensions/authentication/devise_adapter_spec.rb

@@ -0,0 +1,94 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../simple_spec_helper')
+
+module TestActionController
+  class Base
+  
+    def current_user
+      "user_1"
+    end
+
+    def authentitcate_test_user!
+      true 
+    end
+
+    def edit_admin_password_path
+      "/edit_admin"
+    end
+    
+    def destroy_admin_session_path
+      "/destroy_admin"
+    end
+
+    def current_admin
+      "admin_1"
+    end
+  end
+end
+
+module Devise
+  def self.sign_out_via
+    "get"
+  end
+end
+
+describe Lolita::Extensions::Authentication::DeviseAdapter do
+  around(:each){ |example|
+    Lolita.authentication = :authentitcate_test_user! 
+    Lolita.user_classes = ["Admin","User"]
+    example.run
+    Lolita.authentication = nil
+    Lolita.user_classes = []
+  }
+  let(:klass){ Lolita::Extensions::Authentication::DeviseAdapter }
+  let(:controller){TestActionController::Base.new}
+  let(:adapter){ klass.new(controller,{}) }
+
+  it "should create new" do
+    expect do
+      klass.new(TestActionController::Base,{})
+    end.not_to raise_error
+  end
+  
+  it "should raise error without authentication" do
+    expect do
+      Lolita.authentication = nil
+      klass.new(TestActionController::Base,{})
+    end.to raise_error(Lolita::NoAuthenticationDefinedError)
+  end
+
+  it "should not have current user" do
+    Lolita.user_classes = ["User"]
+    adapter.current_user.should == controller.current_user
+  end
+
+  it "should not be signed in" do
+    adapter.user_signed_in?.should be_true
+  end
+
+  it "should authenticate user" do
+    adapter.authenticate_user!.should be_true
+  end
+
+  it "should have sign_out_via method" do
+    adapter.sign_out_via.should == "get"
+  end
+
+  it "should have edit path" do
+    adapter.edit_path.should == "/edit_admin"
+  end
+
+  it "should have sign out path" do 
+    adapter.sign_out_path.should == "/destroy_admin"
+  end
+  
+
+  describe 'Integration with proxy' do
+    let(:proxy){ Lolita::Extensions::Authentication::Proxy.new(controller,{}) }
+      it "should have the same method results for adapter and proxy" do
+        proxy.adapter = adapter
+        %w(current_user user_signed_in? authenticate_user!).each do |name|
+          proxy.send(name).should eql(adapter.send(name))
+        end
+      end
+  end
+end