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

data/spec/configuration/base_spec.rb

@@ -1,44 +1,23 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require File.expand_path(File.dirname(__FILE__) + '/../simple_spec_helper')
 
-describe Lolita::Configuration::Base do
-#    before(:each) do
-#      @base = Lolita::Configuration::Base.new
-#    end
+describe Lolita::Configuration::Base do 
+  let(:klass){Lolita::Configuration::Base}
+  let(:dbp){Object.new}
 
-  it "should define configuration without block" do
-    Post.lolita.should_not be_nil
+  it "should include Lolita::Builder" do 
+    klass.ancestors.should include(Lolita::Builder)
   end
 
-  it "should define configuration with block" do
-    Profile.lolita.should_not be_nil
+  it "should respond to dbp" do 
+    klass.new(dbp).should respond_to(:dbp)
   end
 
-  it "should not initialize instance methods for configuration without calling them" do
-    Profile.lolita.list.to_s.should match(/Lolita::LazyLoader/)
-    Post.lolita.list.to_s.should match(/Lolita::LazyLoader/)
+  it "should respond to dbi" do 
+    klass.new(dbp).should respond_to(:dbi)
   end
 
-  it "should return real object when calling it" do
-    define_config do
-      list
-    end
-    Post.lolita.list.class.to_s.should == "Lolita::Configuration::List"
+  it "should call all args hash part keys as writer methods " do
+    klass.any_instance.should_receive(:my_method=).with(1)
+    klass.new(dbp, :my_method => 1)
   end
-
-  it "should return tabs" do
-    define_config
-    Post.lolita.tabs.class.should == Lolita::Configuration::Tabs
-  end
-
-  it "should allow add tabs" do
-    define_config do
-      tab(:content)
-    end
-    Post.lolita.tabs.size.should == 1
-  end
-  
-  def define_config &block
-    Post.lolita=Lolita::Configuration::Base.new(Post,&block)
-  end
-end
-
+end

data/spec/configuration/column_spec.rb

@@ -3,11 +3,12 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 describe Lolita::Configuration::Column do
   let(:dbi){Lolita::DBI::Base.create(Post)}
   let(:column){Lolita::Configuration::Column.new(dbi,:col1)}
+  let(:column_class){Lolita::Configuration::Column}
   
   
   it "should create new column with Hash attributes" do
     column=Lolita::Configuration::Column.new(dbi,:name=>"col1",:title=>"Col1",:type=>String)
-    column.name.should == "col1"
+    column.name.should == :col1
   end
 
   it "should create new column with Proc as block given" do
@@ -33,7 +34,7 @@ describe Lolita::Configuration::Column do
     column=Lolita::Configuration::Column.new(dbi,:col1)
     column.name.should == :col1
     column=Lolita::Configuration::Column.new(dbi,"col2")
-    column.name.should == "col2"
+    column.name.should == :col2
   end
   
   it "should raise error when no name is provided for column" do
@@ -85,5 +86,53 @@ describe Lolita::Configuration::Column do
     column.formatter.with(1).should == 1
   end
 
+  it "should set association for column if name matches any association name" do
+    new_column = column_class.new(dbi,:comments)
+    new_column.association.klass.should == Comment
+  end
+
+  describe "sublist" do
+
+    it "should accept sublist" do
+      new_column = column_class.new(dbi,:comments) do
+        list do
+          column :body
+        end
+      end
+      new_column.list.should_not be_nil
+    end
+
+    it "should accept list for reflection fields without any specifict arguments" do
+      expect{
+        column_class.new(dbi,:comments) do
+          list{}
+        end
+      }.not_to raise_error
+
+      expect{
+        column_class.new(dbi, :title) do
+          list{}
+        end
+      }.to raise_error(Lolita::UnknownDBPError)
+    end
+
+    it "should accept sublist in any depth" do
+      dbi = Lolita::DBI::Base.create(Category)
+      new_column = column_class.new(dbi,:posts) do
+        list do
+          column :title
+          column :comments do
+            list do
+              column :body
+            end
+          end
+        end
+      end
+
+      new_column.list.columns.by_name(:comments).list.should_not be_nil
+    end
+
+  end
+
 end
 

data/spec/configuration/columns_spec.rb

@@ -2,53 +2,47 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 describe Lolita::Configuration::Columns do
 
-  before(:each) do
-    @dbi=Lolita::DBI::Base.create(Post)
-    @list=Lolita::Configuration::List.new(@dbi)
-  end
+  let(:dbi){Lolita::DBI::Base.create(Post)}
 
   it "should create columns" do
-    columns=Lolita::Configuration::Columns.new(@list)
+    columns=Lolita::Configuration::Columns.new(dbi)
     columns.class.should == Lolita::Configuration::Columns
   end
 
   it "should respond to array methods" do
-    columns=Lolita::Configuration::Columns.new(@list)
+    columns=Lolita::Configuration::Columns.new(dbi)
     columns.size.should == 0
   end
 
   it "should generate columns from dbi class" do
-    columns=Lolita::Configuration::Columns.new(@list)
+    columns=Lolita::Configuration::Columns.new(dbi)
     columns.generate!
-    columns.last.name.size.should > 0
+    columns.last.should_not be_nil
   end
 
   it "should make Lolita::Configuration::Column for each element " do
-    columns=Lolita::Configuration::Columns.new(@list)
+    columns=Lolita::Configuration::Columns.new(dbi)
     columns<<{:name=>"col1"}
-    columns<<Lolita::Configuration::Column.new(@dbi,:name=>"col2")
+    columns<<Lolita::Configuration::Column.new(dbi,:name=>"col2")
     columns.first.class.should == Lolita::Configuration::Column
   end
 
   it "should make Lolita::Configuration::Column from Symbol as name" do
-    columns=Lolita::Configuration::Columns.new(@list)
+    columns=Lolita::Configuration::Columns.new(dbi)
     columns<<:col1
     columns.first.class.should == Lolita::Configuration::Column
-    columns.add(:col2).add(:col3)
-    columns.last.class.should == Lolita::Configuration::Column
-    columns.size.should == 3
   end
 
   it "should make ::Column object with given block" do
-    columns=Lolita::Configuration::Columns.new(@list)
+    columns=Lolita::Configuration::Columns.new(dbi)
     columns<<(Proc.new{
         name "col1"
       })
-    columns.first.name.should == "col1"
-    columns.add do
-      name "col2"
+    columns.first.name.should == :col1
+    columns.column do 
+      name :col2
     end
-    columns.last.name.should == "col2"
+    columns.last.name.should == :col2
   end
 end
 

data/spec/configuration/core_spec.rb

@@ -0,0 +1,89 @@
+require File.expand_path(File.dirname(__FILE__) + '/../simple_spec_helper')
+
+describe Lolita::Configuration::Core do
+  let(:klass){Lolita::Configuration::Core}
+  let(:dbp_klass){Lolita::DBI::Base}
+  let(:dbp){Object.new}
+  let(:conf){klass.new(Object)}
+
+  before(:each) do 
+    dbp_klass.stub(:create).with(kind_of(Class)).and_return(dbp)
+  end
+
+  it "should create new instance without block" do 
+    expect{
+      klass.new(Object)
+    }.not_to raise_error
+  end
+
+  it "should create new instance with block" do 
+    expect{
+      klass.new(Object){}
+    }.not_to raise_error
+  end
+
+  it "should create dbp instance for received class" do 
+    conf = klass.new(Object)
+    conf.dbi.should eq(dbp)
+  end
+
+  it "should call #generate! when no block is given" do 
+    klass.any_instance.should_receive(:generate!).once
+    klass.new(Object)
+  end
+
+  it "should eval block on instance when block is given" do 
+    proc = Proc.new{ "result" }
+    klass.any_instance.should_receive(:instance_eval).with(&proc).once
+    klass.new(Object,&proc)
+  end
+
+  it "should create new list with same DB proxy" do 
+    Lolita::Configuration::List.should_receive(:new).with(dbp)
+    conf.list.class
+  end
+
+  it "should create new list with block" do 
+    block = Proc.new{}
+    Lolita::Configuration::List.should_receive(:new).with(dbp,&block)
+    conf.list(&block).class
+  end
+
+  it "should assign new list to @list when instance class is kind of Lolita::Configuration::List" do 
+    list = double("list")
+    list.stub(:is_a?).with(Lolita::Configuration::List).and_return(true)
+    conf.list = list
+  end
+
+  it "should create tabs with same DB proxy" do 
+    Lolita::Configuration::Tabs.should_receive(:new).with(dbp)
+    conf.tabs.class
+  end
+
+  it "should create tabs with block" do 
+    block = Proc.new{}
+    Lolita::Configuration::Tabs.should_receive(:new).with(dbp,&block)
+    conf.tabs(&block).class
+  end
+
+  it "should create tab with any arguments and add to #tabs" do 
+    Lolita::Configuration::Tabs.any_instance.should_receive(:<<).once.and_return(true)
+    Lolita::Configuration::Factory::Tab.should_receive(:add).with(dbp,1).and_return(Object.new)
+    conf.tab(1)
+  end
+
+  it "shoud create tab with any arguments and block" do 
+    block = Proc.new{}
+    Lolita::Configuration::Tabs.any_instance.should_receive(:<<).once
+    Lolita::Configuration::Factory::Tab.should_receive(:add).with(dbp,1,&block)
+    conf.tab(1,&block)
+  end
+
+  it "should call generator methods when #generate! is called" do 
+    klass.class_variable_get(:@@generators).each do |gen_name|
+      klass.any_instance.should_receive(gen_name).once
+    end
+    conf
+  end
+end
+

data/spec/configuration/field_spec.rb

@@ -7,6 +7,7 @@ describe Lolita::Configuration::Field do
   end
 
   let(:field_class){Lolita::Configuration::Field::Base}
+  let(:factory_class){Lolita::Configuration::Factory::Field}
 
   it "should create new field" do
     Lolita::Configuration::Field::Base.new(@dbi,:title,:string)
@@ -85,11 +86,11 @@ describe Lolita::Configuration::Field do
     field.association.macro.should == :many
   end
 
-  it "should use detect field state matches record state" do
-    field = Lolita::Configuration::Factory::Field.add(@dbi, :title, :string, :on => :create)
-    field2 = Lolita::Configuration::Factory::Field.add(@dbi, :title, :string, :on => [:update])
-    field3 = Lolita::Configuration::Factory::Field.add(@dbi, :title, :string)
-    field4 = Lolita::Configuration::Factory::Field.add(@dbi, :title, :string, :on => Proc.new{|rec| rec.title == "title"})
+  it "should match state with given record state" do
+    field = factory_class.add(@dbi, :title, :string, :on => :create)
+    field2 = factory_class.add(@dbi, :title, :string, :on => [:update])
+    field3 = factory_class.add(@dbi, :title, :string)
+    field4 = factory_class.add(@dbi, :title, :string, :on => Proc.new{|rec| rec.title == "title"})
     record = @dbi.klass.new
     field.match_state_of?(record).should be_true
     field2.match_state_of?(record).should_not be_true
@@ -102,5 +103,16 @@ describe Lolita::Configuration::Field do
     field4.match_state_of?(record2).should be_true
   end
 
+  it "should match :read state for record" do
+    field = factory_class.add(@dbi,:title,:string, :on => :create)
+    field2 = factory_class.add(@dbi,:title,:string, :on => :read)
+    field3 = factory_class.add(@dbi,:title,:string)
+    record = @dbi.klass.new
+    @dbi.switch_record_state(record,:read)
+    field.match_state_of?(record).should_not be_true
+    field2.match_state_of?(record).should be_true
+    field3.match_state_of?(record).should be_true
+  end
+
 end
 

data/spec/configuration/filter_spec.rb

@@ -2,41 +2,32 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 describe Lolita::Configuration::Filter do
 
-  before(:each) do
-    @dbi=Lolita::DBI::Base.new(Post)
-  end
+  let(:dbi){Lolita::DBI::Base.new(Post)}
 
   it "should create new filter with block" do
-    Lolita::Configuration::Filter.new(@dbi) do
+    Lolita::Configuration::Filter.new(dbi) do
     end
   end
 
   it "should create new filter without block" do
-    Lolita::Configuration::Filter.new(@dbi)
+    Lolita::Configuration::Filter.new(dbi)
   end
 
   it "should give fields as arguments" do
-    list=Lolita::Configuration::List.new(@dbi)
+    list=Lolita::Configuration::List.new(dbi)
     list.filter :name, :is_public
     list.filter.fields.size.should == 2
   end
-  
-  it "should add default search field if none is given" do
-    filter=Lolita::Configuration::Filter.new(@dbi)
-    filter.fields.size.should == 1
-    filter=Lolita::Configuration::Filter.new(@dbi){}
-    filter.fields.size.should == 1
-  end
 
   it "should add some fields" do
-    filter=Lolita::Configuration::Filter.new(@dbi) do
+    filter=Lolita::Configuration::Filter.new(dbi) do
       fields :name, :is_public, :not_public
     end
     filter.fields.size.should == 3
   end
 
   it "should add some field with block" do
-    filter=Lolita::Configuration::Filter.new(@dbi) do
+    filter=Lolita::Configuration::Filter.new(dbi) do
       field :name do
         type :integer
       end
@@ -45,7 +36,7 @@ describe Lolita::Configuration::Filter do
   end
 
   it "should add some fields with block" do
-    filter=Lolita::Configuration::Filter.new(@dbi) do
+    filter=Lolita::Configuration::Filter.new(dbi) do
       fields :name, :is_public do
         type :integer
       end
@@ -57,67 +48,91 @@ describe Lolita::Configuration::Filter do
     filter.fields[2].type.should == "time"
   end
 
-  it "should generate correct field_name" do
-    filter=Lolita::Configuration::Filter.new(@dbi)
-    filter.fields :name, :not_public
-    filter.field_name(filter.fields.first).should == "f_name"
-    filter.field_name(filter.fields.last).should == "f_not_public"
-  end
-
-  it "should return right options_for_select" do
-    Category.delete_all
-    3.times{ Factory.create(:category)}
-    filter=Lolita::Configuration::Filter.new(@dbi) do
-      field :category
-      field :some_type, :array, :options_for_select => %w(a b c)
-    end
-    options = filter.options_for_select(filter.fields.first)
-    options.size.should == 3
-    options.first.first.should be_an(String)
-    options.first.last.should be_an(BSON::ObjectId)
-    options = filter.options_for_select(filter.fields.last)
-    options.size.should == 3
-    options.should == %w(a b c)
-  end
-
   it "should filter results for boolean" do
-    Factory.create(:post, :is_public => true)
-    Factory.create(:post, :is_public => true)
-    Factory.create(:post, :is_public => false)
+    Fabricate(:post, :is_public => true)
+    Fabricate(:post, :is_public => true)
+    Fabricate(:post, :is_public => false)
 
-    filter=Lolita::Configuration::Filter.new(@dbi) do
+    filter=Lolita::Configuration::Filter.new(dbi) do
       field :is_public
     end
 
-    @dbi.filter(:is_public => 1).size.should == 2
-    @dbi.filter(:is_public => 0).size.should == 1
+    dbi.filter(:is_public => 1).size.should == 2
+    dbi.filter(:is_public => 0).size.should == 1
   end
 
   it "should filter results for belongs_to" do
-    c1 = Factory.create(:category, :name => "Linux")
-    c2 = Factory.create(:category, :name => "Android")
-    p1=Factory.create(:post, :category => c1)
-    p2=Factory.create(:post, :category => c1)
-    p3=Factory.create(:post, :category => c2)
+    c1 = Fabricate(:category, :name => "Linux")
+    c2 = Fabricate(:category, :name => "Android")
+    p1=Fabricate(:post, :category => c1)
+    p2=Fabricate(:post, :category => c1)
+    p3=Fabricate(:post, :category => c2)
 
-    filter=Lolita::Configuration::Filter.new(@dbi) do
+    filter=Lolita::Configuration::Filter.new(dbi) do
       field :tags
     end
-    @dbi.filter(:category => c1.id).size.should == 2
-    @dbi.filter(:category => c2.id).size.should == 1
+    dbi.filter(:category_id => c1.id).size.should == 2
+    dbi.filter(:category_id => c2.id).size.should == 1
   end
 
   it "should filter results for has_and_belongs_to_many" do
-    tag1 = Factory.create(:tag, :name => "Linux")
-    tag2 = Factory.create(:tag, :name => "Android")
-    p1=Factory.create(:post, :tags => [tag1,tag2])
-    p2=Factory.create(:post, :tags => [tag1,tag2])
-    p3=Factory.create(:post, :tags => [tag1])
+    tag1 = Fabricate(:tag, :name => "Linux")
+    tag2 = Fabricate(:tag, :name => "Android")
+    p1=Fabricate(:post, :tags => [tag1,tag2])
+    p2=Fabricate(:post, :tags => [tag1,tag2])
+    p3=Fabricate(:post, :tags => [tag1])
 
-    filter=Lolita::Configuration::Filter.new(@dbi) do
+    filter=Lolita::Configuration::Filter.new(dbi) do
       field :tags
     end
-    @dbi.filter(:tags => tag1.id).size.should == 3
-    @dbi.filter(:tags => tag2.id).size.should == 2
+    dbi.filter(:tag_ids => tag1.id).size.should == 3
+    dbi.filter(:tag_ids => tag2.id).size.should == 2
+  end
+
+  describe "Filtering list" do
+    let(:list){ Lolita::Configuration::List}
+
+    it "should filter with default filters" do
+      tags = %w(Android Linux Windows).map{|name| Fabricate(:tag, :name => name )}
+      3.times {|i| Fabricate(:post,:tags => [tags[i]])}
+
+      list_conf = list.new(dbi) do
+        filter do
+          field :tags
+        end
+      end
+      list_conf.paginate(1).should have(3).items
+      request = Object.new
+      request.class_eval do
+        def params
+          {:filter => {:tag_ids => Tag.where(:name => 'Android').first.id}}
+        end
+      end
+      list_conf.paginate(1,request).should have(1).items
+    end
+    
+    it "should filter with custom search" do
+      tags = %w(Android Linux Windows).map{|name| Fabricate(:tag, :name => name )}
+      3.times {|i| Fabricate(:post,:tags => [tags[i]])}
+      Post.class_eval do
+        def self.custom_filter query,request
+          where(:tag_ids.in => Tag.where(:name.in => ['Android','Linux']).map(&:id))
+        end
+      end
+      list_conf = list.new(dbi) do
+        filter do
+          field :tags
+          search :custom_filter
+        end
+      end
+      list_conf.paginate(1).should have(3).items
+      request = Object.new
+      request.class_eval do
+        def params
+          {:filter => {:tag_ids => Tag.where(:name => 'Android').first.id}}
+        end
+      end
+      list_conf.paginate(1,request).should have(2).items
+    end
   end
 end