lolita 3.4.3 → 4.0.0

data/spec/configuration/filter_spec.rb

@@ -1,131 +1,145 @@
-require 'spec_helper'
-
-describe Lolita::Configuration::Filter do
-
-  let(:dbi){Lolita::DBI::Base.new(Post)}
-
-  it "should create new filter with block" do
-    Lolita::Configuration::Filter.new(dbi) do
-    end
-  end
-
-  it "should create new filter without block" do
-    Lolita::Configuration::Filter.new(dbi)
-  end
-
-  it "should give fields as arguments" do
-    list=Lolita::Configuration::List.new(dbi)
-    list.filter :name, :is_public
-    list.filter.fields.size.should == 2
-  end
-
-  it "should add some fields" 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
-      field :name do
-        type :integer
-      end
-    end
-    filter.fields.first.type.should == "integer"
-  end
-
-  it "should add some fields with block" do
-    filter=Lolita::Configuration::Filter.new(dbi) do
-      fields :name, :is_public do
-        type :integer
-      end
-      field :created_at, :time
-    end
-    filter.fields.size.should == 3
-    filter.fields[0].type.should == "integer"
-    filter.fields[1].type.should == "integer"
-    filter.fields[2].type.should == "time"
-  end
-
-  it "should filter results for boolean" do
-    Fabricate(:post, :is_public => true)
-    Fabricate(:post, :is_public => true)
-    Fabricate(:post, :is_public => false)
-
-    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
-  end
-
-  it "should filter results for belongs_to" do
-    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
-      field :tags
-    end
-    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 = 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
-      field :tags
-    end
-    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}
-    let(:request){
-      double('request', headers: {}, params: {})
-    }
-
-    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, request).should have(3).items
-      request.stub(params: {:filter => {:tag_ids => Tag.where(:name => 'Android').first.id}})
-      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, request).should have(3).items
-      request.stub(params: {:filter => {:tag_ids => Tag.where(:name => 'Android').first.id}})
-      list_conf.paginate(1,request).should have(2).items
-    end
-  end
-end
+require 'spec_helper'
+
+describe Lolita::Configuration::Filter do
+
+  let(:dbi){Lolita::DBI::Base.new(Post)}
+
+  describe "#initialize" do
+    it "should create new filter with block" do
+      Lolita::Configuration::Filter.new(dbi) do
+      end
+    end
+
+    it "should create new filter without block" do
+      Lolita::Configuration::Filter.new(dbi)
+    end
+
+    it "should give fields as arguments" do
+      list=Lolita::Configuration::List.new(dbi)
+      list.filter :name, :is_public
+      list.filter.fields.size.should == 2
+    end
+  end
+
+  describe "#field" do
+    it "add field" do
+      filter = Lolita::Configuration::Filter.new(dbi) do
+        field :title
+      end
+      filter.fields.first.name.should eq(:title)
+    end
+
+    it "add field with block" do
+      filter = Lolita::Configuration::Filter.new(dbi) do
+        field :name do
+          type :integer
+        end
+      end
+      filter.fields.first.type.should == "integer"
+    end
+  end
+
+  describe "#fields" do
+    it "add multiple fields" 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 fields with block" do
+      filter=Lolita::Configuration::Filter.new(dbi) do
+        fields :name, :is_public do
+          type :integer
+        end
+        field :created_at, :time
+      end
+      filter.fields.size.should == 3
+      filter.fields[0].type.should == "integer"
+      filter.fields[1].type.should == "integer"
+      filter.fields[2].type.should == "time"
+    end
+  end
+
+  describe "#search" do
+    let(:list){ Lolita::Configuration::List}
+
+    it "should filter with default search" do
+      Fabricate(:post, title: "Big fish")
+      2.times { Fabricate(:post) }
+      list_conf = list.new(dbi) do
+        filter :title
+      end
+      list_conf.paginate(1).should have(3).items
+      request = Object.new
+      request.class_eval do
+        def params
+          {filter: {title: "Big fish"}}
+        end
+
+        def headers
+          {}
+        end
+      end
+      list_conf.paginate(1, request).should have(1).item
+    end
+
+    it "should filter with custom search" do
+      3.times {|i| Fabricate(:post, price: i * 5) }
+      Post.class_eval do
+        def self.custom_filter query, request
+          where(price: 10)
+        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: {price: 5}}
+        end
+
+        def headers
+          {}
+        end
+      end
+      list_conf.paginate(1,request).should have(1).item
+      list_conf.paginate(1,request).first.price.should eq(10)
+    end
+  end
+
+  describe "#resource" do
+    let(:filter){ Lolita::Configuration::Filter.new(dbi, :name ) }
+
+    let(:params){ {} }
+    subject do
+      tags = %w(Android Linux Windows).map{|name| Fabricate(:tag, name: name )}
+      filter.resource(params)
+    end
+
+    context "reflections" do
+      let(:params){ {post: {tag_ids: ["", Tag.where(name: "Android").first.id]}} }
+      let(:filter){ Lolita::Configuration::Filter.new(dbi, :tag) }
+      it "recognizes" do
+        subject.tags.should have(1).item
+      end
+    end
+
+    context "simple attributes" do
+      let(:params){ {post: {title: "MyName" }} }
+      let(:filter){ Lolita::Configuration::Filter.new(dbi, :title ) }
+      it "recognizes" do
+        subject.title.should eq("MyName")
+      end
+    end
+
+    it "should be persisted" do
+      subject.should be_persisted
+    end
+  end
+end

data/spec/configuration/tab_spec.rb

@@ -1,187 +1,184 @@
-require 'spec_helper'
-
-# temp class for extending tabs
-class Lolita::Configuration::Tab::My < Lolita::Configuration::Tab::Base
-  def initialize(dbi,type=nil,*args,&block)
-    type = :my
-    super
-  end
-end
-
-
-describe Lolita::Configuration::Tab do
-
-  before(:each) do
-    @dbi=Lolita::DBI::Base.create(Post)
-  end
-
-  let(:tab_class){Lolita::Configuration::Tab::Base}
-
-  def default_tab &block
-    Lolita::Configuration::Tab::Base.new(@dbi,:default,&block)
-  end
-
-  describe "create extended tabs" do
-
-    context "tab class is child class of ::Tab class " do
-      it "should create new" do
-        Lolita::Configuration::Tab::My.new(@dbi).type.should == :my
-      end
-
-      it "should create new with block" do
-        Lolita::Configuration::Tab::My.new(@dbi) do 
-          title "My New tab"
-        end.title.should == "My New tab"
-      end
-    end
-  end
-
-  it "should create tab" do
-    tab_class.new(@dbi,:content)
-  end
-
-  it "should allow to set title" do
-    tab=tab_class.new(@dbi,:content) do
-      title "My tab"
-    end
-    tab.title.should == "My tab"
-  end
-  
-  it "should have default title that is humanized type" do
-    tab=tab_class.new(@dbi,:content)
-    tab.title.should=="Content"
-  end
-  
-  it "should raise error when no fields are given for default type tab" do
-    lambda{
-      Lolita::Configuration::Factory::Tab.add(@dbi,:default)
-    }.should raise_error Lolita::NoFieldsGivenError
-  end
-
-  it "should create tab when attributes are given" do
-    tab=tab_class.new(@dbi,:default,:fields=>[{:name=>"field one"}])
-    tab.fields.size.should == 1
-  end
-
-  it "should create tab when block is given" do
-    tab=default_tab do
-      field :name=>"field one"
-    end
-    tab.fields.size.should == 1
-  end
-
-  it "should allow add fieldset to tab" do
-    tab=default_tab do
-      field_set("Person information") do
-        field :name=>"field one"
-      end
-    end
-    tab.field_sets.should have(1).item
-  end
-
-  it "should keep order for fields added in tab and in tab fieldsets" do
-    tab=default_tab do
-      field :name=>"one"
-      field_set("Fieldset") do
-        field :name=>"two"
-        field :name=>"three"
-      end
-      field :name=>"four"
-      field_set("Fieldset 2") do
-        field :name=>"five"
-      end
-      field :name=>"six"
-    end
-    tab.fields.collect{|f| f.name }.should == [:"one",:"two",:"three",:"four",:"five",:"six"]
-  end
-
-  it "should get fields from fieldset" do
-     tab=default_tab do
-      field :name=>"one"
-      field_set("Fieldset") do
-        field :name=>"two"
-        field :name=>"three"
-      end
-    end
-    tab.field_sets.first.fields.size.should == 2
-  end
-
-  it "should add default fields for any tab when specified" do
-    tab=tab_class.new(@dbi,:images) do
-      default_fields
-    end
-    tab.fields.size.should > 0
-  end
-
-  describe "nested field operations" do 
-
-    it "should add nested fields" do
-      tab=default_tab do
-        default_fields
-        nested_fields_for(:comments) do
-          default_fields
-        end
-      end
-      dbi2=Lolita::DBI::Base.new(Comment)
-      tab.fields.size.should == @dbi.fields.reject{|f| f.technical?}.size+dbi2.fields.reject{|f| f.technical?}.size
-    end
-
-    it "should detect that field is nested" do
-      tab=default_tab do
-        default_fields
-        nested_fields_for(:comments) do
-          default_fields
-        end
-      end
-      tab.fields.last.nested?.should be_true
-    end
-  
-    it "should return nested fields for specified class" do
-      tab=default_tab do
-        default_fields
-        nested_fields_for(:comments) do
-          default_fields
-        end
-      end
-      tab.nested_fields_of(:comments).size.should > 0
-    end
-
-    it "should have nested forms" do
-      tab = default_tab do
-        default_fields
-        nested_fields_for(:comments) do
-          default_fields
-        end
-      end
-      tab.nested_forms.should have(1).item
-      tab.nested_forms[0].fields.size.should > 0
-    end 
-
-    it "should return nested field sets" do
-      tab = default_tab do
-        field :name => "one"
-        nested_fields_for(:comments) do
-          default_fields
-        end
-        field :name => "two"
-        nested_fields_for(:profile) do
-          default_fields
-        end
-        field :name => "last"
-      end
-
-      tab.fields_in_groups.size.should == 5
-      tab.fields_in_groups[3].first.dbi == Profile
-    end
-
-  end
-
-  it "should return field with given name" do
-    tab=default_tab do
-      default_fields
-    end
-    tab.fields.by_name(:title).name.should == :title
-  end
-
-end
-
+require 'spec_helper'
+
+# temp class for extending tabs
+class Lolita::Configuration::Tab::My < Lolita::Configuration::Tab::Base
+  def initialize(dbi,type=nil,*args,&block)
+    type = :my
+    super
+  end
+end
+
+
+describe Lolita::Configuration::Tab do
+
+  before(:each) do
+    @dbi=Lolita::DBI::Base.create(Post)
+  end
+
+  let(:tab_class){Lolita::Configuration::Tab::Base}
+
+  def default_tab &block
+    Lolita::Configuration::Tab::Base.new(@dbi,:default,&block)
+  end
+
+  describe "create extended tabs" do
+
+    context "tab class is child class of ::Tab class " do
+      it "should create new" do
+        Lolita::Configuration::Tab::My.new(@dbi).type.should == :my
+      end
+
+      it "should create new with block" do
+        Lolita::Configuration::Tab::My.new(@dbi) do 
+          title "My New tab"
+        end.title.should == "My New tab"
+      end
+    end
+  end
+
+  it "should create tab" do
+    tab_class.new(@dbi,:content)
+  end
+
+  it "should allow to set title" do
+    tab=tab_class.new(@dbi,:content) do
+      title "My tab"
+    end
+    tab.title.should == "My tab"
+  end
+  
+  it "should have default title that is humanized type" do
+    tab=tab_class.new(@dbi,:content)
+    tab.title.should=="Content"
+  end
+  
+  it "should raise error when no fields are given for default type tab" do
+    lambda{
+      Lolita::Configuration::Factory::Tab.add(@dbi,:default)
+    }.should raise_error Lolita::NoFieldsGivenError
+  end
+
+  it "should create tab when attributes are given" do
+    tab=tab_class.new(@dbi,:default,:fields=>[{:name=>"field one"}])
+    tab.fields.size.should == 1
+  end
+
+  it "should create tab when block is given" do
+    tab=default_tab do
+      field :name=>"field one"
+    end
+    tab.fields.size.should == 1
+  end
+
+  it "should allow add fieldset to tab" do
+    tab=default_tab do
+      field_set("Person information") do
+        field :name=>"field one"
+      end
+    end
+    tab.field_sets.should have(1).item
+  end
+
+  it "should keep order for fields added in tab and in tab fieldsets" do
+    tab=default_tab do
+      field :name=>"one"
+      field_set("Fieldset") do
+        field :name=>"two"
+        field :name=>"three"
+      end
+      field :name=>"four"
+      field_set("Fieldset 2") do
+        field :name=>"five"
+      end
+      field :name=>"six"
+    end
+    tab.fields.collect{|f| f.name }.should == [:"one",:"two",:"three",:"four",:"five",:"six"]
+  end
+
+  it "should get fields from fieldset" do
+     tab=default_tab do
+      field :name=>"one"
+      field_set("Fieldset") do
+        field :name=>"two"
+        field :name=>"three"
+      end
+    end
+    tab.field_sets.first.fields.size.should == 2
+  end
+
+  it "should add default fields for any tab when specified" do
+    tab=tab_class.new(@dbi,:images) do
+      default_fields
+    end
+    tab.fields.size.should > 0
+  end
+
+  describe "nested field operations" do 
+
+    it "should add nested fields" do
+      tab=default_tab do
+        default_fields
+        nested_fields_for(:comments) do
+          default_fields
+        end
+      end
+      dbi2=Lolita::DBI::Base.new(Comment)
+      tab.fields.size.should == @dbi.fields.reject{|f| f.technical?}.size+dbi2.fields.reject{|f| f.technical?}.size
+    end
+
+    it "should detect that field is nested" do
+      tab=default_tab do
+        default_fields
+        nested_fields_for(:comments) do
+          default_fields
+        end
+      end
+      tab.fields.last.nested?.should be_true
+    end
+  
+    it "should return nested fields for specified class" do
+      tab=default_tab do
+        default_fields
+        nested_fields_for(:comments) do
+          default_fields
+        end
+      end
+      tab.nested_fields_of(:comments).size.should > 0
+    end
+
+    it "should have nested forms" do
+      tab = default_tab do
+        default_fields
+        nested_fields_for(:comments) do
+          default_fields
+        end
+      end
+      tab.nested_forms.should have(1).item
+      tab.nested_forms[0].fields.size.should > 0
+    end 
+
+    it "should return nested field sets" do
+      tab = default_tab do
+        field :name => "one"
+        nested_fields_for(:comments) do
+          default_fields
+        end
+        field :name => "two"
+        field :name => "last"
+      end
+
+      tab.fields_in_groups.size.should == 3
+      tab.fields_in_groups[1].first.dbi == Comment
+    end
+
+  end
+
+  it "should return field with given name" do
+    tab=default_tab do
+      default_fields
+    end
+    tab.fields.by_name(:title).name.should == :title
+  end
+
+end
+