mundane-search 0.0.1 → 0.0.2

data/spec/buildable_integration_spec.rb

@@ -0,0 +1,14 @@
+require_relative 'minitest_helper'
+
+describe MundaneSearch::Buildable do
+  let(:built) do
+    Class.new do
+      include MundaneSearch::Buildable
+    end
+  end
+
+  it "should limit results using exact match filter" do
+    built.use MundaneSearch::Filters::ExactMatch, param_key: "foo"
+    built.call(collection, params).must_equal(['bar'])
+  end
+end

data/spec/buildable_spec.rb

@@ -0,0 +1,19 @@
+require_relative 'minitest_helper'
+
+describe MundaneSearch::Buildable do
+  let(:built) do
+    Class.new do
+      include MundaneSearch::Buildable
+    end
+  end
+
+  it "should have a search builder object" do
+    built.builder.must_be_kind_of MundaneSearch::Builder
+  end
+
+  it "should add proxy methods" do
+    [:use, :result_for, :call, :employ].each do |method|
+      built.must_respond_to method
+    end
+  end
+end

data/spec/builder_integration_spec.rb

@@ -1,14 +1,35 @@
 require_relative 'minitest_helper'
 
 describe MundaneSearch::Builder do
-  Builder = MundaneSearch::Builder
+  let(:built) { MundaneSearch::Builder.new }
+
+  it "should return unchanged collection on call" do
+    built.call(collection, params).must_equal(collection)
+  end
+
+  it "should tollerate nil params (convert to empty hash)" do
+    built.call(collection, nil).must_equal(collection)
+  end
 
   it "should limit results using exact match filter" do
+    built.use MundaneSearch::Filters::ExactMatch, param_key: "foo"
+    built.call(collection, params).must_equal(['bar'])
+  end
 
-    built = Builder.new do
-      use MundaneSearch::Filters::ExactMatch, param_key: "foo"
-    end
+  it "should translate symbols into MundaneSearch::Filter class (if available)" do
+    built.use :exact_match, param_key: "foo"
+    built.call(collection, params).must_equal(['bar'])
+  end
+
+  it "should translate strings into MundaneSearch::Filter class (if available)" do
+    built.use "exact_match", param_key: "foo"
+    built.call(collection, params).must_equal(['bar'])
+  end
 
+  it "should looks for Object:: level filters when translating strings" do
+    Object.const_set :MockFilter, Class.new(MundaneSearch::Filters::ExactMatch)
+    built.use :mock_filter, param_key: "foo"
     built.call(collection, params).must_equal(['bar'])
+    Object.send(:remove_const, :MockFilter)
   end
-end
+end

data/spec/builder_spec.rb

@@ -1,25 +1,20 @@
 require_relative 'minitest_helper'
 
 describe MundaneSearch::Builder do
-  Builder = MundaneSearch::Builder
+  let(:built)  { MundaneSearch::Builder.new }
+  let(:null_filter) { Object.new }
+  let(:canister) { Minitest::Mock.new }
 
-  let(:collection) { %w(foo bar baz)    }
-  let(:params)     { { 'foo' => 'bar' } }
-
-  describe "empty search" do
-    let(:builder) { Builder.new }
-
-    it "should return unchanged collection on call" do
-      builder.call(collection, params).must_equal(collection)
-    end
-  end
+  # what does a builder actually do?
+  # 1. Store search configuration (use, result_class, filter_canister)
+  #   a. Can "use" (et al) be called?
+  #     i. use can be verified
+  # 2. Run search (call, result_for)
+  #   a. ... by creating a result object
 
   it "should use middleware" do
-    builder = Builder.new do
-      use NothingFilterForTest
-    end
-    canister = builder.filters.first
-    canister.must_be_kind_of MundaneSearch::FilterCanister
-    canister.filter.must_equal NothingFilterForTest
+    expectation = ->(filter, *args) { filter.must_equal null_filter }
+    built.define_singleton_method :build_filter_canister, ->{ expectation }
+    built.use(null_filter)
   end
-end
+end

data/spec/columns_hash_spec.rb

@@ -0,0 +1,37 @@
+require_relative 'minitest_helper'
+
+describe ColumnsHash do
+  [:binary, :boolean, :date, :datetime, :decimal, :float, :integer, :primary_key, :string, :text, :time, :timestamp].each do |type|
+    it "should respond to all ActiveRecord type #{type}" do
+      ColumnsHash.generate({type: type}).must_be_kind_of ColumnsHash::Attribute
+    end
+  end
+
+  it "should have 255 limit when string" do
+    ColumnsHash.generate({type: :string}).limit.must_equal 255
+  end
+
+  [:float, :integer].each do |type|
+    it "should be number? true when #{type}" do
+      ColumnsHash.generate({type: type}).number?.must_equal true
+    end
+  end
+
+  describe "applied to class" do
+    let(:columned_class) do
+      Class.new do
+        include ColumnsHash
+      end
+    end
+    let(:columned) { columned_class.new }
+
+    it "should have a columns_hash" do
+      columned_class.columns_hash.must_be_kind_of Hash
+    end
+
+    it "should store (and retrieve) a column type" do
+      columned_class.attribute_column(:title, :string)
+      columned.column_for_attribute(:title).type.must_equal :string
+    end
+  end
+end

data/spec/demo_data.rb

@@ -0,0 +1,50 @@
+def demo_data
+  [
+    {
+      title: "A Tale of Two Cities",
+      author: "Charles Dickens",
+      publication_date: Date.parse('31-12-1859'),
+      first_purchased_at: Time.utc(1859,"jan",1,20,15,1),
+      sold: 200_000_000
+    },
+    {
+      title: "The Lord of the Rings",
+      author: "J. R. R. Tolkien",
+      publication_date: Date.parse('31-12-1954'),
+      first_purchased_at: Time.utc(1954,"jan",1,20,15,1),
+      sold: 150_000_000
+    },
+    {
+      title: "The Little Prince (Le Petit Prince)",
+      author: "Antoine de Saint-Exupery",
+      publication_date: Date.parse('31-12-1943'),
+      first_purchased_at: Time.utc(1943,"jan",1,20,15,1),
+      sold: 140_000_000
+    },
+    {
+      title: "The Hobbit",
+      author: "J. R. R. Tolkien",
+      publication_date: Date.parse('31-12-1937'),
+      first_purchased_at: Time.utc(1937,"jan",1,20,15,1),
+      sold: 100_000_000
+    },
+    {
+      title: "Hong lou meng (Dream of the Red Chamber/The Story of the Stone)",
+      author: "Cao Xueqin",
+      publication_date: Date.parse('31-12-1754'),
+      first_purchased_at: Time.utc(1754,"jan",1,20,15,1),
+      sold: 100_000_000
+    },
+    {
+      title: "And Then There Were None",
+      author: "Agatha Christie",
+      publication_date: Date.parse('31-12-1939'),
+      first_purchased_at: Time.utc(1939,"jan",1,20,15,1),
+      sold: 100_000_000
+    }
+  ]
+end
+
+def open_struct_books
+  demo_data.collect {|d| OpenStruct.new(d) }
+end

data/spec/filter_canister_spec.rb

@@ -0,0 +1,46 @@
+require_relative 'minitest_helper'
+
+describe MundaneSearch::FilterCanister do
+  it "should build filters with options" do
+    filter = Minitest::Mock.new
+    options = {param_key: 'baz'}
+    result = Object.new
+    filter.expect(:constants, [])
+    filter.expect(:new, result, [collection, params, options])
+    filter_canister = MundaneSearch::FilterCanister.new(filter, options)
+    filter_canister.build(collection, params).must_equal(result)
+    filter.verify
+  end
+
+  it "should use subconstant based on class of collection" do
+    object_filter = Minitest::Mock.new
+    collection, result, options = Object.new, Object.new, Object.new
+    object_filter.expect(:new, result, [collection, params, options])
+
+    base_filter = Class.new
+    base_filter::Object = object_filter
+
+    filter_canister = MundaneSearch::FilterCanister.new(base_filter, options)
+    filter_canister.build(collection, params).must_equal(result)
+    object_filter.verify
+  end
+
+  it "should report param_key" do
+    param_key = Object.new
+    filter_canister = MundaneSearch::FilterCanister.new(nil, param_key: param_key)
+    filter_canister.param_key.must_equal param_key
+  end
+
+  it "should report param_key_type" do
+    param_key_type = Object.new
+    filter_canister = MundaneSearch::FilterCanister.new(nil, param_key_type: param_key_type)
+    filter_canister.param_key_type.must_equal param_key_type
+  end
+
+  it "should take param_key_type from filter, if not supplied in options" do
+    filter = Minitest::Mock.new
+    filter.expect(:param_key_type, :date)
+    filter_canister = MundaneSearch::FilterCanister.new(filter)
+    filter_canister.param_key_type.must_equal :date
+  end
+end

data/spec/filters/attribute_match_integration_spec.rb

@@ -10,8 +10,8 @@ describe MundaneSearch::Filters::AttributeMatch do
   let(:all_books) { Book.scoped }
   let(:a_tale_of_two_cities) { Book.first }
 
-  it "should something" do
-    built = Builder.new do
+  it "should match based on param_key" do
+    built = MundaneSearch::Builder.new do
       use MundaneSearch::Filters::AttributeMatch, param_key: "author"
     end
 

data/spec/filters/attribute_match_spec.rb

@@ -0,0 +1,27 @@
+require_relative '../minitest_helper'
+require_relative '../demo_data'
+
+describe MundaneSearch::Filters::AttributeMatch do
+  let(:books)  { open_struct_books }
+  let(:a_tale) { books.first }
+  it "should match param key" do
+    am = MundaneSearch::Filters::AttributeMatch
+    filter = am.new(books, {'title' => "A Tale of Two Cities"}, {param_key: 'title'})
+
+    filter.filtered_collection.must_equal([a_tale])
+  end
+
+  describe MundaneSearch::Filters::AttributeMatch::ActiveRecord do
+    let(:am) { MundaneSearch::Filters::AttributeMatch::ActiveRecord }
+    it "should filter with 'where'" do
+      collection = Minitest::Mock.new
+      params = { 'title' => "A Tale of Two Cities" }
+      result = Object.new
+
+      filter = am.new(collection, params, param_key: 'title')
+      collection.expect(:where, result, [params])
+      filter.filtered_collection.must_equal(result)
+      collection.verify
+    end
+  end
+end

data/spec/filters/attribute_substring_spec.rb

@@ -0,0 +1,27 @@
+require_relative '../minitest_helper'
+require_relative '../demo_data'
+
+describe MundaneSearch::Filters::AttributeSubstring do
+  let(:books)  { open_struct_books }
+  let(:a_tale) { books.first }
+  it "should match param key" do
+    am = MundaneSearch::Filters::AttributeSubstring
+    filter = am.new(books, {'title' => "Tale of Two"}, {param_key: 'title'})
+
+    filter.filtered_collection.must_equal([a_tale])
+  end
+
+  describe MundaneSearch::Filters::AttributeSubstring::ActiveRecord do
+    let(:am) { MundaneSearch::Filters::AttributeSubstring::ActiveRecord }
+    it "should filter with 'where'" do
+      collection = Minitest::Mock.new
+      params = { 'title' => "Tale of Two" }
+      result = Object.new
+
+      filter = am.new(collection, params, param_key: 'title')
+      collection.expect(:where, result, [["title LIKE ?", "%Tale of Two%"]])
+      filter.filtered_collection.must_equal(result)
+      collection.verify
+    end
+  end
+end

data/spec/filters/base_spec.rb

@@ -1,13 +1,45 @@
 require_relative '../minitest_helper'
 
 describe MundaneSearch::Filters::Base do
-  Base = MundaneSearch::Filters::Base
+  let(:base) { MundaneSearch::Filters::Base.new(collection, params) }
+  let(:standin) { Object.new }
 
-  let(:collection) { %w(foo bar baz)    }
-  let(:params)     { { 'foo' => 'bar' } }
+  describe "#call" do
+    it "should equal [filtered_collection, filtered_params]" do
+      collection, params = Object.new, Object.new
+      base.expects(:filtered_collection).returns(collection)
+      base.expects(:filtered_params).returns(params)
+      base.call.must_equal [collection, params]
+    end
 
-  it "should pass through" do
-    base = Base.new(collection, params)
-    base.call.must_equal [collection, params]
+    it "should equal [collection, params] when apply? is false" do
+      collection, params = Object.new, Object.new
+      def base.filtered_params     ; end
+      def base.filtered_collection ; end
+      base.expects(:apply?).returns(false)
+      base.expects(:collection).returns(collection)
+      base.expects(:params).returns(params)
+      base.call.must_equal [collection, params]
+    end
   end
-end
+
+  describe "#apply?" do
+    it "should be true" do
+      assert base.apply?
+    end
+  end
+
+  describe "#filtered_collection" do
+    it "should contain collection" do
+      base.expects(:collection).returns(standin)
+      base.filtered_collection.must_equal standin
+    end
+  end
+
+  describe "#filtered_params" do
+    it "should contain params" do
+      base.expects(:params).returns(standin)
+      base.filtered_params.must_equal standin
+    end
+  end
+end

data/spec/filters/blank_params_are_nil_spec.rb

@@ -0,0 +1,11 @@
+require_relative '../minitest_helper'
+
+describe MundaneSearch::Filters::BlankParamsAreNil do
+  it "should remove empty values from params" do
+    params = { empty_string: '', empty_array: [], empty_hash: {} }
+    bpan = MundaneSearch::Filters::BlankParamsAreNil.new([], params)
+    bpan.filtered_params[:empty_string].must_be_nil
+    bpan.filtered_params[:empty_array].must_be_nil
+    bpan.filtered_params[:empty_hash].must_be_nil
+  end
+end

data/spec/filters/operator_integration_spec.rb

@@ -0,0 +1,20 @@
+require_relative '../minitest_helper'
+require_relative '../active_record_setup'
+
+describe MundaneSearch::Filters::Operator do
+  before do
+    DatabaseCleaner.clean
+    populate_books!
+  end
+
+  let(:all_books) { Book.scoped }
+  let(:a_tale_of_two_cities) { Book.first }
+
+  it "should match based on param_key" do
+    built = MundaneSearch::Builder.new do
+      use MundaneSearch::Filters::Operator, { param_key: 'sold', operator: :> }
+    end
+
+    built.call(all_books, {"sold" => 199_999_999}).must_equal([a_tale_of_two_cities])
+  end
+end

data/spec/filters/operator_spec.rb

@@ -0,0 +1,28 @@
+require_relative '../minitest_helper'
+require_relative '../demo_data'
+
+describe MundaneSearch::Filters::Operator do
+  let(:books)  { open_struct_books }
+  let(:a_tale) { books.first }
+
+  it "should match param key" do
+    o = MundaneSearch::Filters::Operator
+    filter = o.new(books, {'sold' => 199_999_999}, { param_key: 'sold', operator: :> })
+
+    filter.filtered_collection.must_equal([a_tale])
+  end
+
+  describe MundaneSearch::Filters::Operator::ActiveRecord do
+    let(:o) { MundaneSearch::Filters::Operator::ActiveRecord }
+    it "should filter with 'where'" do
+      collection = Minitest::Mock.new
+      params = { 'sold' => 199_999_999 }
+      result = Object.new
+
+      filter = o.new(collection, params, { param_key: 'sold', operator: :> })
+      collection.expect(:where, result, [["sold > ?", 199_999_999]])
+      filter.filtered_collection.must_equal(result)
+      collection.verify
+    end
+  end
+end

data/spec/filters/shortcuts_integration_spec.rb

@@ -0,0 +1,16 @@
+require_relative '../minitest_helper'
+require_relative '../demo_data'
+
+describe MundaneSearch::Filters::Shortcuts do
+
+  let(:all_books) { open_struct_books }
+  let(:a_tale_of_two_cities) { all_books.first }
+
+  it "should match based on param_key" do
+    built = MundaneSearch::Builder.new do
+      employ :attribute_filter, param_key: 'title'
+    end
+
+    built.call(all_books, {"title" => "A Tale of Two Cities"}).must_equal([a_tale_of_two_cities])
+  end
+end