adva 0.1.4 → 0.2.0

data/vendor/gems/has_filter/test/has_filter/filter_chain_test.rb

@@ -1,41 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper.rb'
-
-module HasFilter
-  class FilterChainTest < ActiveSupport::TestCase
-    include HasFilter
-    include HasFilter::TestHelper
-    
-    def setup
-      @chain = HasFilterArticle.filter_chain
-    end
-
-    test 'builds a filter chain with an initial set' do
-      assert_equal 'Set', @chain.first.class.name.demodulize
-    end
-    
-    test 'properly duplicates instances when adjusting its size' do
-      @chain.send :adjust_size, 2
-      first, second = *@chain[0, 2]
-      assert_not_equal first.object_id, second.object_id 
-      assert_not_equal first.first.object_id, second.first.object_id 
-      assert_equal first.object_id, first.first.set.object_id 
-      assert_equal second.object_id, second.first.set.object_id 
-    end
-  end
-  
-  class FilterSetTest < ActiveSupport::TestCase
-    def setup
-      @chain = HasFilterArticle.filter_chain
-    end
-
-    test 'set has a text filter for each attribute' do
-      set = HasFilterArticle.filter_chain.first
-      assert_equal %w(body excerpt title), set[0..2].map(&:attribute).map(&:to_s).sort
-    end
-    
-    test 'sorts text filters to the top, not changing their order, followed by the rest ordered by priority' do
-      expected = ['Text', 'Text', 'Text', 'Tagged', 'State', 'Categorized']
-      assert_equal expected, @chain.first.map{ |filter| filter.class.name.demodulize }
-    end
-  end
-end

data/vendor/gems/has_filter/test/has_filter/filter_scopes_test.rb

@@ -1,102 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper.rb'
-
-module HasFilter
-  class FilterScopesTest < ActiveSupport::TestCase
-    include HasFilter
-    include HasFilter::TestHelper
-
-    def setup
-      @first  = HasFilterArticle.find_by_title 'first'
-      @second = HasFilterArticle.find_by_title 'second'
-      @third  = HasFilterArticle.find_by_title 'third'
-      @upcase = HasFilterArticle.find_by_title 'UPCASE'
-    end
-
-    test 'text filter applies scopes to an attribute' do
-      params = [{ :title     => { :scope => 'contains', :query => 'i' },
-                  :body      => { :scope => 'contains', :query => 'x' },
-                  :excerpt   => { :scope => 'contains', :query => 'x' },
-                  :tagged    => 'x',
-                  :selected  => 'title' }]
-      assert_equal [@first, @third], HasFilterArticle.filter_chain.select(params).scope
-    end
-    
-    test 'text filter works with translated columns' do
-      params = [{ :title     => { :scope => 'is', :query => 'UPCASE' },
-                  :body      => { :scope => 'is', :query => 'x' },
-                  :excerpt   => { :scope => 'is', :query => 'x' },
-                  :tagged    => 'x',
-                  :selected  => 'title' }]
-      assert_equal [@upcase], HasFilterArticle.filter_chain.select(params).scope
-    end
-    
-    test 'text filter works with upcase letters' do
-      HasFilterArticle.stubs(:translated?).with(:title).returns true
-      scope = HasFilterArticle.send(:filter_scope, :title, ["first"], "=")
-      expected_scope = {:conditions=>["title = ? AND current = ?", "first", true],
-                        :joins=>:globalize_translations,
-                        :group=>"has_filter_articles.id"}
-      assert_equal expected_scope, scope 
-    end
-
-    test 'text filter applies scopes to multiple attributes' do
-      params = [{ :title     => { :scope => 'starts_with', :query => 'x' },
-                  :body      => { :scope => 'starts_with', :query => 'f' },
-                  :excerpt   => { :scope => 'starts_with', :query => 'x' },
-                  :tagged    => 'x',
-                  :selected  => 'body' },
-                { :title     => { :scope => 'contains', :query => 'i' },
-                  :body      => { :scope => 'contains', :query => 'x' },
-                  :excerpt   => { :scope => 'contains', :query => 'x' },
-                  :tagged    => 'x',
-                  :selected  => 'title' }]
-      assert_equal [@first], HasFilterArticle.filter_chain.select(params).scope
-    end
-    
-    test 'text filter applies multiple scopes to the same attribute' do
-      params = [{ :title     => { :scope => 'starts_with', :query => 'f' },
-                  :body      => { :scope => 'starts_with', :query => 'x' },
-                  :excerpt   => { :scope => 'starts_with', :query => 'x' },
-                  :tagged    => 'x',
-                  :selected  => 'title' },
-                { :title     => { :scope => 'contains', :query => 'i' },
-                  :body      => { :scope => 'contains', :query => 'x' },
-                  :excerpt   => { :scope => 'contains', :query => 'x' },
-                  :tagged    => 'x',
-                  :selected  => 'title' }]
-      assert_equal [@first], HasFilterArticle.filter_chain.select(params).scope
-    end
-    
-    test 'state filter applies multiple state scopes from the same filter' do
-      params = [{ :state => [:published, :approved], :selected  => 'state' }] # should in theory be an OR join
-      assert_equal [@second], HasFilterArticle.filter_chain.select(params).scope
-    end
-    
-    test 'state filter applies multiple state scopes from different filters' do
-      params = [{ :state => [:published], :selected  => 'state' },
-                { :state => [:approved], :selected  => 'state' }]
-      assert_equal [@second], HasFilterArticle.filter_chain.select(params).scope
-    end
-    
-    test 'tags filter applies tags scope' do
-      params = [{ :tagged => ['bar'], :selected => 'tagged' }]
-      assert_equal [@first, @second], HasFilterArticle.filter_chain.select(params).scope
-    end
-    
-    test 'categories filter applies categorized scope (1)' do
-      params = [{ :categorized => @first.categories.map(&:id), :selected => 'categorized' }]
-      assert_equal [@first], HasFilterArticle.filter_chain.select(params).scope
-    end
-    
-    test 'categories filter applies categorized scope (2)' do
-      params = [{ :categorized => @second.categories.map(&:id), :selected => 'categorized' }]
-      assert_equal [@first, @second], HasFilterArticle.filter_chain.select(params).scope
-    end
-    
-    test 'categories filter applies categorized scope (3)' do
-      category = HasFilterCategory.create!(:title => 'new')
-      params = [{ :categorized => category.id, :selected => 'categorized' }]
-      assert_equal [], HasFilterArticle.filter_chain.select(params).scope
-    end
-  end
-end

data/vendor/gems/has_filter/test/has_filter/filter_tags_test.rb

@@ -1,113 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper.rb'
-
-module HasFilter
-  class FilterTagsTest < ActiveSupport::TestCase
-    include HasFilter
-    include HasFilter::TestHelper
-
-    def setup
-      params = [{ :title       => { :scope => 'starts_with', :query => 'foo' },
-                  :body        => { :scope => 'starts_with', :query => '' },
-                  :excerpt     => { :scope => 'starts_with', :query => '' },
-                  :tagged      => '', 
-                  :selected    => 'title' },
-                { :title       => { :scope => 'contains', :query => '' },
-                  :body        => { :scope => 'contains', :query => 'bar' },
-                  :excerpt     => { :scope => 'contains', :query => '' },
-                  :tagged      => '', 
-                  :selected    => 'body' },
-                { :title       => { :scope => 'contains', :query => '' },
-                  :body        => { :scope => 'contains', :query => '' },
-                  :excerpt     => { :scope => 'contains', :query => '' },
-                  :tagged      => 'baz', 
-                  :selected    => 'tagged' },
-                { :title       => { :scope => 'contains', :query => '' },
-                  :body        => { :scope => 'contains', :query => '' },
-                  :excerpt     => { :scope => 'contains', :query => '' },
-                  :state       => [ :published ],
-                  :tagged      => '', 
-                  :selected    => 'state' },
-                { :title       => { :scope => 'contains', :query => '' },
-                  :body        => { :scope => 'contains', :query => '' },
-                  :excerpt     => { :scope => 'contains', :query => '' },
-                  :state       => [ :published ],
-                  :tagged      => '', 
-                  :categorized => [HasFilterCategory.first.id],
-                  :selected    => 'categorized' }]
-
-      @categories = HasFilterCategory.all
-      view = ActionView::Base.new
-      @html = HasFilterArticle.filter_chain.select(params).to_form_fields(view, :categories => @categories).join("\n")
-    end
-
-    test 'the chain has two fieldsets with filters' do
-      assert_html @html, 'fieldset[class=set]', 5
-    end
-
-    test 'one fieldset has the :title filter selected, one has the :body, one has the :tagged filter selected (from params)' do
-      assert_html @html, 'fieldset[class=set] select[id=selected_filter_0] option[value=title][selected=selected]'
-      assert_html @html, 'fieldset[class=set] select[id=selected_filter_1] option[value=body][selected=selected]'
-      assert_html @html, 'fieldset[class=set] select[id=selected_filter_2] option[value=tagged][selected=selected]'
-    end
-
-    test 'fieldsets have a select box for selecting the filter' do
-      assert_html @html, 'select[id=selected_filter_0]' do
-        assert_select 'option[value=title]'
-        assert_select 'option[value=body]'
-        assert_select 'option[value=excerpt]'
-        assert_select 'option[value=tagged]'
-        assert_select 'option[value=state]'
-      end
-    end
-
-    test 'fieldsets have a nested fieldset for each filter' do
-      assert_html @html, 'fieldset[class=set] fieldset[class~=filter][id=filter_title_0]'
-      assert_html @html, 'fieldset[class=set] fieldset[class~=filter][id=filter_tagged_0]'
-      assert_html @html, 'fieldset[class=set] fieldset[class~=filter][id=filter_state_0]'
-      assert_html @html, 'fieldset[class=set] fieldset[class~=filter][id=filter_categorized_0]'
-    end
-
-    test 'one fieldset has the :title fieldset selected, one has the :body fieldset selected (from params)' do
-      assert_html @html, 'fieldset[class=set] fieldset[class~=selected][id=filter_title_0]'
-      assert_html @html, 'fieldset[class=set] fieldset[class~=selected][id=filter_body_1]'
-    end
-
-    test 'text filter has a select box for selecting the scope and a query input' do
-      assert_html @html, 'select[id=filter_body_scope_0][name=?]', 'filters[][body][scope]' do
-        assert 'option[value=contains]'
-        assert 'option[value=starts_with]'
-        assert 'option[value=ends_with]'
-        assert 'option[value=is]'
-        assert 'option[value=is_not]'
-      end
-      assert_html @html, 'input[id=filter_body_query_0][name=?]', 'filters[][body][query]'
-    end
-
-    test 'title text filter has the :starts_with scope selected and query set to "foo" (from params)' do
-      assert_html @html, 'select[id=filter_title_scope_0] option[value=starts_with][selected=selected]'
-      assert_html @html, 'input[id=filter_title_query_0][value=foo]'
-    end
-
-    test 'body text filter has the :contains scope selected and query set to "bar" (from params)' do
-      assert_html @html, 'select[id=filter_body_scope_1] option[value=contains][selected=selected]'
-      assert_html @html, 'input[id=filter_body_query_1][value=bar]'
-    end
-
-    test 'tag filter has a query input set to "baz"' do
-      assert_html @html, 'input[id=filter_tagged_query_2][name=?][value=baz]', 'filters[][tagged]'
-    end
-
-    test 'state filter has checkboxes for possible states' do
-      assert_html @html, 'input[type=checkbox][id=?][name=?][value=?][checked=checked]', 
-        "filter_state_published_3", 'filters[][state][]', 'published'
-      assert_html @html, 'input[type=checkbox][id=?][name=?][value=?]', 
-        "filter_state_unpublished_3", 'filters[][state][]', 'unpublished'
-    end
-
-    test 'categorized filter has a select box selecting a category' do
-      assert_html @html, 'select[id=filter_categorized_id_4][name=?]', 'filters[][categorized][]' do
-        assert_select 'option[value=?][selected=selected]', @categories.first.id, @categories.first.title
-      end
-    end
-  end
-end

data/vendor/gems/has_filter/test/has_filter/integration.rb

@@ -1,15 +0,0 @@
-# require File.expand_path(File.join(File.dirname(__FILE__), '..', 'test_helper' ))
-# 
-# module HasFilter
-#   class IntegrationTest < ActionController::IntegrationTest
-#     def setup
-#     end
-# 
-#     test "foo" do
-#       visit 'has_filter'
-# #      puts @response.body
-#       click_button 'submit'
-# #      p @request.params[:filters]
-#     end
-#   end
-# end

data/vendor/gems/has_filter/test/has_filter/scopes_test.rb

@@ -1,48 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper.rb'
-
-module HasFilter
-  class ScopesTest < ActiveSupport::TestCase
-    def setup
-      @first  = HasFilterArticle.find_by_title 'first'
-      @second = HasFilterArticle.find_by_title 'second'
-      @third  = HasFilterArticle.find_by_title 'third'
-      @upcase = HasFilterArticle.find_by_title 'UPCASE'
-    end
-  
-    test 'scope :is' do
-      assert_equal [@first], HasFilterArticle.is(:title, 'first')
-    end
-  
-    test 'scope :is_not' do
-      assert_equal [@second, @third, @upcase], HasFilterArticle.is_not(:title, 'first')
-    end
-  
-    test 'scope :contains' do
-      assert_equal [@first, @third], HasFilterArticle.contains(:title, 'ir')
-    end
-      
-    test 'scope :does_not_contain' do
-      assert_equal [@second, @upcase], HasFilterArticle.does_not_contain(:title, 'ir')
-    end
-      
-    test 'scope :starts_with' do
-      assert_equal [@first], HasFilterArticle.starts_with(:title, 'fi')
-    end
-      
-    test 'scope :does_not_start_with' do
-      assert_equal [@second, @third, @upcase], HasFilterArticle.does_not_start_with(:title, 'fi')
-    end
-      
-    test 'scope :ends_with' do
-      assert_equal [@first], HasFilterArticle.ends_with(:title, 'st')
-    end
-      
-    test 'scope :does_not_end_with' do
-      assert_equal [@second, @third, @upcase], HasFilterArticle.does_not_end_with(:title, 'st')
-    end
-      
-    test 'scope :contains_all' do
-      assert_equal [@first], HasFilterArticle.contains_all(:title, %w(i r s))
-    end
-  end
-end