mundane-search 0.0.1 → 0.0.2

data/spec/filters/shortcuts_spec.rb

@@ -0,0 +1,15 @@
+require_relative '../minitest_helper'
+
+describe MundaneSearch::Filters::Shortcuts do
+  let(:shortcutted) do
+    shortcutted = Object.new
+    shortcutted.extend(MundaneSearch::Filters::Shortcuts)
+    shortcutted
+  end
+
+  # urg
+  it "should compose a filter with employ" do
+    shortcutted.expects(:use)
+    shortcutted.employ :attribute_filter
+  end
+end

data/spec/filters/typical_spec.rb

@@ -0,0 +1,68 @@
+require_relative '../minitest_helper'
+
+describe MundaneSearch::Filters::Typical do
+  # let(:typical) { MundaneSearch::Filters::Typical.new(collection, params) }
+  let(:standin) { Object.new }
+  def typical(options = {})
+    MundaneSearch::Filters::Typical.new(collection, params, options)
+  end
+
+  describe "#target" do
+    it "should use options[:target]" do
+      typical(target: "foo").target.must_equal "foo"
+    end
+
+    it "should default to param_key" do
+      typical(param_key: "foo").target.must_equal "foo"
+    end
+  end
+
+  describe "#optional?" do
+    it "should use options[:required]" do
+      typical(required: true).must_be :optional?
+    end
+
+    it "should default to optional" do
+      typical.wont_be :optional?
+    end
+  end
+
+  describe "#apply?" do
+    it "should be true if there is a match_value" do
+      filter = typical
+      def filter.match_value ; true ; end
+      assert filter.apply?
+    end
+
+    it "should be true if the filter isn't optional" do
+      filter = typical
+      def filter.match_value ; false ; end
+      def filter.optional?   ; true  ; end
+      assert filter.apply?
+    end
+  end
+
+  describe "#param_key" do
+    it "should take param_key from options" do
+      param_key = Object.new
+      typical(param_key: param_key).param_key.must_equal param_key
+    end
+  end
+
+  describe "#match_value" do
+    it "should return param value matching param_key" do
+      typical(param_key: "foo").match_value.must_equal "bar"
+    end
+  end
+
+  describe "#param_key_type" do
+    it "should default to :string" do
+      typical.param_key_type.must_equal :string
+    end
+
+    it "should use options[:type]" do
+      type = Object.new
+      typical(type: type).param_key_type.must_equal type
+    end
+  end
+end

data/spec/form_integration_spec.rb

@@ -0,0 +1,29 @@
+require_relative 'minitest_helper'
+requirements_for_form_for_tests!
+
+describe "integration with Rails forms" do
+  let(:result_class) { Class.new(MundaneSearch::Result) }
+  let(:result) { result_class.new(open_struct_books, params) }
+  let(:result_model) { result.to_model }
+
+  describe "with Rails' form_for" do
+    let(:formed) { formed_class.new }
+
+    it "should convert to model" do
+      formed.convert_to_model(result).must_equal result.to_model
+    end
+
+    it "should generate form from search result" do
+      form = formed.form_for(result) { }
+      form.must_match %r{<form}
+    end
+
+    it "should extract values from param_key for text_field accessors" do
+      result_class.builder.use MundaneSearch::Filters::AttributeMatch, param_key: 'title'
+      form = formed.form_for(result_model) do |f|
+        f.text_field :title
+      end
+      form.must_match %{<input id="#{search_prefix}_title" name="#{search_prefix}[title]" size="30" type="text" />}
+    end
+  end
+end

data/spec/initial_stack_spec.rb

@@ -0,0 +1,13 @@
+require_relative 'minitest_helper'
+
+describe MundaneSearch::InitialStack do
+  let(:initial) { MundaneSearch::InitialStack.new(collection, params) }
+
+  it "should take a collection and params" do
+    initial.must_be_kind_of MundaneSearch::InitialStack
+  end
+
+  it "should always return empty array on filters" do
+    initial.all_filters.must_equal []
+  end
+end

data/spec/minitest_helper.rb

@@ -1,17 +1,67 @@
 require 'rubygems'
-gem 'minitest' # ensures you're using the gem, and not the built in MT
+gem 'minitest' # ensures we're using the gem, and not the built in MT
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
 require 'minitest/autorun'
 require 'minitest/spec'
 require 'minitest/mock'
+require "mocha/setup"
 
 require 'mundane-search'
 require 'pry' rescue nil
 
-class NothingFilterForTest
-  def initialize(a=nil) ; end
-  def call(c,p) ; [c,p] ; end
+class AgressiveBacktraceFilter < Minitest::BacktraceFilter
+  def gem_paths
+    return @gem_paths if @gem_paths
+    raw_paths = `gem env gempath`
+    @gem_paths = raw_paths.split(':')
+  end
+
+  def project_path
+    @project_path ||= File.expand_path(File.dirname(__FILE__) + "/../")
+  end
+
+  def filter_paths
+    gem_paths + [project_path]
+  end
+
+  def filter(bt)
+    original_filter = super(bt)
+    original_filter.collect do |line|
+      filter_paths.inject(line) do |sum, path|
+        sum.sub(/\A#{path}/,'')
+      end
+    end
+  end
+end
+
+Minitest.backtrace_filter = AgressiveBacktraceFilter.new
+
+# fail_fast hack
+module MiniTest
+  class Unit
+    def puke_with_immediate_feedback(klass, meth, e)
+      # Workaround for minitest weirdness: When puke gets called *again* after
+      # @exiting has been set to true down below, exit immediately so we don't
+      # get an extra SystemExit stack trace.  Exiting without exclamation mark
+      # doesn't get the non-zero exit code through, but all teardown handlers
+      # have been run at this point, so it's OK to use a hard exit here.
+      exit! 1 if @exiting_from_puke
+      result = puke_without_immediate_feedback(klass, meth, e)
+      unless e.is_a?(MiniTest::Skip)
+        # Failure or Error, so print the report we just wrote and exit.
+        puts "\n#{@report.pop}\n"
+        @exiting_from_puke = true
+        exit 1
+      end
+      result
+    end
+    alias_method_chain :puke, :immediate_feedback
+  end
 end
 
+
 def collection
   %w(foo bar baz)
 end
@@ -19,3 +69,42 @@ end
 def params
   { 'foo' => 'bar' }
 end
+
+def requirements_for_form_for_tests!
+  require_relative 'demo_data'
+  require 'active_support/concern'
+  %w(capture url sanitize text form).each do |name|
+    require "action_view/helpers/#{name}_helper"
+  end
+  require 'action_controller/record_identifier'
+  require 'action_view'
+  def formed_class
+    Class.new do
+      include ActionView::Helpers::FormHelper
+      include ActionController::RecordIdentifier
+
+      %w(generic_search_path).each do  |path|
+        define_method path do |a=nil,b=nil|
+          "/#{path}"
+        end
+      end
+
+      attr_accessor :output_buffer
+      def protect_against_forgery?
+        false
+      end
+    end
+  end
+
+  def search_prefix
+    "generic_search"
+  end
+end
+
+def requirements_for_simple_form!
+  require 'active_support/concern'
+  %w(form_options).each do |name|
+    require "action_view/helpers/#{name}_helper"
+  end
+  require 'simple_form'
+end

data/spec/result_integration_spec.rb

@@ -0,0 +1,24 @@
+require_relative 'minitest_helper'
+
+describe MundaneSearch::Result do
+  let(:result_class) do
+    Class.new(MundaneSearch::Result) do
+      use MundaneSearch::Filters::ExactMatch, param_key: "foo"
+    end
+  end
+
+  let(:result) { result_class.new(collection, params) }
+
+  it "should run search from result class" do
+    result.to_a.must_equal ["bar"]
+  end
+
+  it "should return result in same class" do
+    result.must_be_kind_of result_class
+    result.first.must_equal "bar"
+  end
+
+  it "should return result model" do
+    result.to_model.must_be_kind_of(MundaneSearch::ResultModel)
+  end
+end

data/spec/result_model_spec.rb

@@ -0,0 +1,50 @@
+require_relative 'minitest_helper'
+require 'ostruct'
+
+describe MundaneSearch::ResultModel do
+  let(:builder) do
+    builder, filter_canister = Object.new, Object.new
+    def filter_canister.param_key      ; "foo" ; end
+    def filter_canister.param_key_type ; :date ; end
+    builder.define_singleton_method :filter_canisters, -> { [filter_canister] }
+    builder
+  end
+  let(:result_class) do
+    result_class = OpenStruct.new(builder: builder, options: {})
+  end
+  let(:model_class) { MundaneSearch::ResultModel.model_class_for(result_class) }
+  let(:result_model) { model_class.new(result) }
+  let(:result) do
+    result = OpenStruct.new
+    result.stack = mock_stack
+    result
+  end
+  let(:mock_stack) do
+    stack = Object.new
+    def stack.params ; { "foo" => "bar" } ; end
+    stack
+  end
+
+  describe ".model_class_for" do
+
+    it "should create class based on ResultModel" do
+      model_class.superclass.must_equal MundaneSearch::ResultModel
+    end
+
+    it "should crate class with param_key accessors" do
+      model_class.instance_methods.include?(:foo)
+    end
+  end
+
+  it "should set type to param_key_type" do
+    result_model.column_for_attribute("foo").type.must_equal :date
+  end
+
+  it "should create accessors for params_keys" do
+    result_model.foo.must_equal 'bar'
+  end
+
+  it "should not be considered to be persisted" do
+    result_model.wont_be :persisted?
+  end
+end

data/spec/result_spec.rb

@@ -1,35 +1,17 @@
 require_relative 'minitest_helper'
 
-describe "results" do
-  let(:collection) { %w(foo bar baz)    }
-  let(:params)     { { 'foo' => 'bar' } }
-  let(:initial)    { MundaneSearch::InitialResult.new(collection, params) }
+describe MundaneSearch::Result do
 
-  describe MundaneSearch::InitialResult do
-    InitialResult = MundaneSearch::InitialResult
-    it "should take a collection and params" do
-      initial.must_be_kind_of InitialResult
-    end
-  end
-
-  describe MundaneSearch::Result do
-    Result = MundaneSearch::Result
-
-    let(:result) { Result.new(initial, filter) }
-    let(:filter) { NothingFilterForTest.new    }
+  # Isolate this more.
+  let(:result) { MundaneSearch::Result.new(collection, params) }
 
-    it "should show collection" do
-      result.collection.must_equal collection
-    end
-
-    it "should show params" do
-      result.params.must_equal params
-    end
-
-    it "should be iterateable" do
-      result.first.must_equal collection.first
-      result.count.must_equal collection.count
-    end
+  it "should show collection" do
+    result.to_a.must_equal collection
   end
 
+  it "should be iterateable" do
+    def result.call ; collection ; end
+    result.first.must_equal collection.first
+    result.count.must_equal collection.count
+  end
 end

data/spec/search_form_for_integration_spec.rb

@@ -0,0 +1,19 @@
+require_relative 'minitest_helper'
+requirements_for_form_for_tests!
+
+describe "integration search_form_for" do
+  let(:result_class) { Class.new(MundaneSearch::Result) }
+  let(:result) { result_class.new(open_struct_books, params) }
+  let(:result_model) { result.to_model }
+  let(:search_formed_class) do
+    Class.new(formed_class) do
+      include MundaneSearch::ViewHelpers
+    end
+  end
+  let(:formed) { search_formed_class.new }
+
+  it "should generate form with method=get" do
+    form = formed.search_form_for(result_model) { }
+    form.must_match %r{<form[^>]+method="get"}
+  end
+end

data/spec/simple_form_integration_spec.rb

@@ -0,0 +1,36 @@
+require_relative 'minitest_helper'
+
+requirements_for_form_for_tests!
+requirements_for_simple_form!
+
+describe "intgration with simple_form" do
+  let(:result_class) { Class.new(MundaneSearch::Result) }
+  let(:result) { result_class.new(open_struct_books, params) }
+  let(:result_model) { result.to_model }
+
+  let(:simple_formed_class) do
+    Class.new(formed_class) do
+      include SimpleForm::ActionViewExtensions::FormHelper
+
+      # In simple_form, FormBuilder in lookup_action asks controller for action
+      def controller ; OpenStruct.new(action: :create) ; end
+    end
+  end
+  let(:formed) { simple_formed_class.new }
+
+  it "should generate simple_form" do
+    form = formed.simple_form_for(result) { }
+    form.must_match %r{<form}
+  end
+
+  it "should determine input" do
+    result_class.builder.use MundaneSearch::Filters::AttributeMatch, param_key: 'title'
+    form = formed.simple_form_for(result_model) do |f|
+      f.input :title
+    end
+    form.must_match %{<input class="string optional" id="#{search_prefix}_title"
+                             name="#{search_prefix}[title]"
+                             size="50" type="text" />}.gsub(/\s+/,' ')
+  end
+end
+

data/spec/simple_search_form_for_integration_spec.rb

@@ -0,0 +1,25 @@
+require_relative 'minitest_helper'
+
+requirements_for_form_for_tests!
+requirements_for_simple_form!
+
+describe "integration simple_search_form_for" do
+  let(:result_class) { Class.new(MundaneSearch::Result) }
+  let(:result) { result_class.new(open_struct_books, params) }
+  let(:result_model) { result.to_model }
+  let(:search_formed_class) do
+    Class.new(formed_class) do
+      include MundaneSearch::ViewHelpers
+      include SimpleForm::ActionViewExtensions::FormHelper
+
+      # In simple_form, FormBuilder in lookup_action asks controller for action
+      def controller ; OpenStruct.new(action: :create) ; end
+    end
+  end
+  let(:formed) { search_formed_class.new }
+
+  it "should generate form with method=get" do
+    form = formed.simple_search_form_for(result_model) { }
+    form.must_match %r{<form[^>]+method="get"}
+  end
+end