rails3-jquery-autocomplete 0.3.6 → 0.4.0

data/README.markdown

@@ -1,7 +1,18 @@
 # rails3-jquery-autocomplete
 
-An easy way to use jQuery's autocomplete with Rails 3. You can find a [detailed example](http://github.com/crowdint/rails3-jquery-autocomplete-app) 
-on how to use this gem [here](http://github.com/crowdint/rails3-jquery-autocomplete-app).
+An easy way to use jQuery's autocomplete with Rails 3.
+
+In now supports both ActiveRecord and [mongoid](http://github.com/mongoid/mongoid).
+
+## ActiveRecord
+
+You can find a [detailed example](http://github.com/crowdint/rails3-jquery-autocomplete-app)
+on how to use this gem with ActiveRecord [here](http://github.com/crowdint/rails3-jquery-autocomplete-app).
+
+## MongoID
+
+You can find a [detailed example](http://github.com/crowdint/rails3-jquery-autocomplete-app/tree/mongoid)
+on how to use this gem with MongoID [here](http://github.com/crowdint/rails3-jquery-autocomplete-app/tree/mongoid).
 
 ## Before you start
 

data/lib/rails3-jquery-autocomplete.rb

@@ -1,53 +1,8 @@
-require 'form_helper'
-
-module Rails3JQueryAutocomplete
-  def self.included(base)
-    base.extend(ClassMethods)
-  end
-
-  # Inspired on DHH's autocomplete plugin
-  # 
-  # Usage:
-  # 
-  # class ProductsController < Admin::BaseController
-  #   autocomplete :brand, :name
-  # end
-  #
-  # This will magically generate an action autocomplete_brand_name, so, 
-  # don't forget to add it on your routes file
-  # 
-  #   resources :products do
-  #      get :autocomplete_brand_name, :on => :collection
-  #   end
-  #
-  # Now, on your view, all you have to do is have a text field like:
-  # 
-  #   f.text_field :brand_name, :autocomplete => autocomplete_brand_name_products_path
-  #
-  #
-  module ClassMethods
-    def autocomplete(object, method, options = {})
-      limit = options[:limit] || 10
-      order = options[:order] || "#{method} ASC"
-
-      define_method("autocomplete_#{object}_#{method}") do
-        if params[:term] && !params[:term].empty?
-          items = object.to_s.camelize.constantize.where(["LOWER(#{method}) LIKE ?", "#{(options[:full] ? '%' : '')}#{params[:term].downcase}%"]).limit(limit).order(order)
-        else
-          items = {}
-        end
-
-        render :json => json_for_autocomplete(items, (options[:display_value] ? options[:display_value] : method))
-      end
-    end
-  end
-
-  private
-  def json_for_autocomplete(items, method)
-    items.collect {|i| {"id" => i.id, "label" => i.send(method), "value" => i.send(method)}}
-  end
-end
+require 'rails3-jquery-autocomplete/form_helper'
+require 'rails3-jquery-autocomplete/helpers'
+require 'rails3-jquery-autocomplete/autocomplete'
 
 class ActionController::Base
-  include Rails3JQueryAutocomplete
+  extend Rails3JQueryAutocomplete::ClassMethods
+  include Rails3JQueryAutocomplete::Helpers
 end

data/lib/rails3-jquery-autocomplete/autocomplete.rb

@@ -0,0 +1,42 @@
+module Rails3JQueryAutocomplete
+
+  # Inspired on DHH's autocomplete plugin
+  # 
+  # Usage:
+  # 
+  # class ProductsController < Admin::BaseController
+  #   autocomplete :brand, :name
+  # end
+  #
+  # This will magically generate an action autocomplete_brand_name, so, 
+  # don't forget to add it on your routes file
+  # 
+  #   resources :products do
+  #      get :autocomplete_brand_name, :on => :collection
+  #   end
+  #
+  # Now, on your view, all you have to do is have a text field like:
+  # 
+  #   f.text_field :brand_name, :autocomplete => autocomplete_brand_name_products_path
+  #
+  #
+  module ClassMethods
+    def autocomplete(object, method, options = {})
+
+      define_method("autocomplete_#{object}_#{method}") do
+
+        term = params[:term]
+
+        if term && !term.empty?
+          items = get_items(:model => get_object(object), \
+            :options => options, :term => term, :method => method) 
+        else
+          items = {}
+        end
+
+        render :json => json_for_autocomplete(items, options[:display_value] ||= method)
+      end
+    end
+  end
+
+end

data/lib/{form_helper.rb → rails3-jquery-autocomplete/form_helper.rb}

@@ -53,4 +53,4 @@ class ActionView::Helpers::FormBuilder #:nodoc:
   def autocomplete_field(method, source, options = {})
     @template.autocomplete_field(@object_name, method, source, options)
   end
-end
+end

data/lib/rails3-jquery-autocomplete/helpers.rb

@@ -0,0 +1,81 @@
+module Rails3JQueryAutocomplete
+
+  # Contains utility methods used by autocomplete
+  module Helpers
+
+    # Returns a three keys hash 
+    def json_for_autocomplete(items, method)
+      items.collect {|item| {"id" => item.id, "label" => item.send(method), "value" => item.send(method)}}
+    end
+
+    # Returns parameter model_sym as a constant
+    #
+    #   get_object(:actor)
+    #   # returns a Actor constant supposing it is already defined
+    def get_object(model_sym)
+      object = model_sym.to_s.camelize.constantize
+    end
+
+    # Returns a symbol representing what implementation should be used to query
+    # the database and raises *NotImplementedError* if ORM implementor can not be found
+    def get_implementation(object) 
+      if object.superclass.to_s == 'ActiveRecord::Base'
+        :activerecord
+      elsif object.included_modules.collect(&:to_s).include?('Mongoid::Document')
+        :mongoid
+      else
+        raise NotImplementedError
+      end
+    end
+
+    # Returns the order parameter to be used in the query created by get_items
+    def get_order(implementation, method, options)
+      order = options[:order]
+
+      case implementation
+        when :mongoid then
+          if order 
+            order.split(',').collect do |fields| 
+              sfields = fields.split
+              [sfields[0].downcase.to_sym, sfields[1].downcase.to_sym]
+            end
+          else
+            [[method.to_sym, :asc]]
+          end
+        when :activerecord then 
+          order || "#{method} ASC"
+      end
+    end
+
+    # Returns a limit that will be used on the query    
+    def get_limit(options)
+      options[:limit] ||= 10
+    end
+  
+    # Queries selected database
+    #
+    #   items = get_items(:model => get_object(object), :options => options, :term => term, :method => method) 
+    def get_items(parameters)
+
+      model = parameters[:model]
+      method = parameters[:method]
+      options = parameters[:options]
+      term = parameters[:term]
+      is_full_search = options[:full]
+
+      limit = get_limit(options)
+      implementation = get_implementation(model)
+      order = get_order(implementation, method, options)
+
+      case implementation
+        when :mongoid
+          search = (is_full_search ? '.*' : '^') + term + '.*'
+          items = model.where(method.to_sym => /#{search}/i).limit(limit).order_by(order)
+        when :activerecord
+          items = model.where(["LOWER(#{method}) LIKE ?", "#{(is_full_search ? '%' : '')}#{term.downcase}%"]) \
+            .limit(limit).order(order)
+      end
+    end
+
+  end
+end

data/test/active_record_controller_test.rb

@@ -0,0 +1,100 @@
+require "test_helper"
+require 'support/active_record'
+
+module Rails3JQueryAutocomplete
+  module Test
+    module ActiveRecord
+  
+      class ActorsControllerTest < ActionController::TestCase
+
+        include Rails3JQueryAutocomplete::Test::ActiveRecord
+    
+        setup do
+          @controller = ActorsController.new
+        end
+
+        context "the autocomplete gem" do
+
+          should "be able to access the autocomplete action regardless of the quality of param[:term]" do
+            get :autocomplete_movie_name
+            assert_response :success
+
+            get :autocomplete_movie_name, :term => ''
+            assert_response :success
+
+            get :autocomplete_movie_name, :term => nil
+            assert_response :success
+
+            get :autocomplete_movie_name, :term => 'Al'
+            assert_response :success
+          end
+
+          should "respond with expected json" do
+            get :autocomplete_movie_name, :term => 'Al'
+            json_response = JSON.parse(@response.body)
+            assert_equal(json_response.first["label"], @movie.name)
+            assert_equal(json_response.first["value"], @movie.name)
+            assert_equal(json_response.first["id"], @movie.id)
+          end
+
+          should "return results in alphabetical order by default" do
+            get :autocomplete_movie_name, :term => 'Al'
+            json_response = JSON.parse(@response.body)
+            assert_equal(json_response.first["label"], "Alpha")
+            assert_equal(json_response.last["label"], "Alzpha")
+          end
+
+          should "be able to sort in other ways if desired" do
+            ActorsController.send(:autocomplete, :movie, :name, {:order => "name DESC"})
+
+            get :autocomplete_movie_name, :term => 'Al'
+            json_response = JSON.parse(@response.body)
+            assert_equal(json_response.first["label"], "Alzpha")
+            assert_equal(json_response.last["label"], "Alpha")
+          end
+
+          should "be able to limit the results" do
+            ActorsController.send(:autocomplete, :movie, :name, {:limit => 1})
+
+            get :autocomplete_movie_name, :term => 'Al'
+            json_response = JSON.parse(@response.body)
+            assert_equal(json_response.length, 1)
+          end
+
+          should "ignore case of search term and results" do
+            @movie = Movie.create(:name => 'aLpHa')
+
+            ActorsController.send(:autocomplete, :movie, :name)
+
+            get :autocomplete_movie_name, :term => 'Al'
+            json_response = JSON.parse(@response.body)
+            assert_equal(json_response.length, Movie.count)
+            assert_equal(json_response.last["label"], 'aLpHa')
+          end
+
+          should "match term to letters in middle of words when full-text search is on" do
+            ActorsController.send(:autocomplete, :movie, :name, {:full => true})
+
+            get :autocomplete_movie_name, :term => 'ph'
+            json_response = JSON.parse(@response.body)
+            assert_equal(json_response.length, Movie.count)
+            assert_equal(json_response.first["label"], @movie.name)
+          end
+
+          should "be able to customize what is displayed" do
+            ActorsController.send(:autocomplete, :movie, :name, {:display_value => :display_name})
+
+            get :autocomplete_movie_name, :term => 'Al'
+
+            json_response = JSON.parse(@response.body)
+
+            assert_equal(@movie.display_name, json_response.first["label"])
+            assert_equal(@movie.display_name, json_response.first["value"])
+            assert_equal(@movie.id, json_response.first["id"])
+          end
+        end
+      end
+
+    end
+  end
+end

data/test/helpers.rb

@@ -0,0 +1,122 @@
+require 'test_helper'
+
+module Rails3JQueryAutocomplete
+  module Test
+
+    class HelpersTest < ::Test::Unit::TestCase
+
+      assert_structure = lambda do |hash|
+        assert_instance_of(String, hash['label'])
+        assert_instance_of(String, hash['value'])
+      end
+
+      items_exist_assert = lambda do |model|
+          items = Helpers.get_items(:model => model), :term => 'A', :method => 'name') 
+          assert(items)
+          assert_equal(3, items.size)
+      end
+
+      context 'with Mongoid support' do
+
+        require 'support/mongoid'
+
+        context 'passing a Mongoid query result' do
+
+          include Rails3JQueryAutocomplete::Mongoid::Test
+
+          should 'parse items to JSON' do
+            response = Helpers.json_for_autocomplete(Game.all, :name)
+            assert_not_nil(response)
+            response.each(&assert_structure)
+          end
+        end
+    
+        context 'looking for items' do
+
+          include Rails3JQueryAutocomplete::Mongoid::Test
+
+          should 'return items' do
+            items_exist_assert.call(Game)
+          end
+        end
+      end
+
+      context 'with ActiveRecord support' do
+
+        require 'support/active_record'
+
+        context 'passing an ActiveRecord query result' do
+
+          include Rails3JQueryAutocomplete::ActiveRecord::Test
+     
+          should 'parse items to JSON' do
+            response = Helpers.json_for_autocomplete(Game.all, :name)
+            assert_not_nil(response)
+            response.each(&assert_structure)
+          end
+        end
+
+        context 'looking for items' do
+
+          include Rails3JQueryAutocomplete::ActiveRecord::Test
+
+          should 'return items' do
+            items_exist_assert.call(Movie)
+          end
+        end
+      end
+
+      context 'converting a symbol to connstant' do
+        should 'return a defined constant' do
+          ::MyJustDefinedConstant = Class.new
+          assert_equal(::MyJustDefinedConstant, Helpers.get_object(:my_just_defined_constant))
+        end
+      end
+
+      context 'returning one symbol for an implemented adapter' do
+
+        require 'support/active_record'
+        require 'support/mongoid'
+
+        should 'return a symbol for defined interface' do
+          assert_equal(:activerecord, Helpers.get_implementation(::Movie))
+          assert_equal(:mongoid, Helpers.get_implementation(::Game))
+        end
+      end
+
+      context 'returning a limit integer number' do
+
+        should 'return default value of 10' do
+          assert_equal(10, Helpers.get_limit({}))
+        end
+
+        should 'return params value' do
+          assert_equal(1, Helpers.get_limit(:limit => 1))
+        end
+      end
+
+      context 'returning elements ordering' do
+
+        should 'returning default ascending order for activerecord' do
+          assert_equal("name ASC", Helpers.get_order(:activerecord, 'name', {}))
+        end
+
+        should 'returning descending order for activerecord' do
+          assert_equal("thisfield DESC", Helpers.get_order(:activerecord, 'otherfield', :order => 'thisfield DESC'))
+        end
+
+        should 'returning default ascending order for mongoid' do
+          expected = [[:name, :asc]]
+          returned = Helpers.get_order(:mongoid, 'name', {})
+          assert expected.eql?(returned)
+        end
+
+        should 'returning order according paramters for mongoid' do
+          expected = [[:first, :asc], [:second, :desc]]
+          returned = Helpers.get_order(:mongoid, 'name', {:order => 'first asc, second desc'})
+          assert expected.eql?(returned)
+        end
+      end
+    end
+  end
+end

data/test/mongoid_controller_test.rb

@@ -0,0 +1,100 @@
+require "test_helper"
+require 'support/mongoid'
+
+module Rails3JQueryAutocomplete
+  module Test
+    module Mongoid
+
+      class GamesControllerTest < ActionController::TestCase
+
+        include Rails3JQueryAutocomplete::Test::Mongoid
+      
+        setup do
+          @controller = GamesController.new
+        end
+
+        context "the autocomplete gem" do
+
+          should "be able to access the autocomplete action regardless of the quality of param[:term]" do
+            get :autocomplete_game_name
+            assert_response :success
+
+            get :autocomplete_game_name, :term => ''
+            assert_response :success
+
+            get :autocomplete_game_name, :term => nil
+            assert_response :success
+
+            get :autocomplete_game_name, :term => 'Al'
+            assert_response :success
+          end
+
+          should "respond with expected json" do
+            get :autocomplete_game_name, :term => 'Al'
+            json_response = JSON.parse(@response.body)
+            assert_equal(json_response.first["label"], @game.name)
+            assert_equal(json_response.first["value"], @game.name)
+            assert_equal(json_response.first["id"], @game.id.to_s)
+          end
+
+          should "return results in alphabetical order by default" do
+            get :autocomplete_game_name, :term => 'Al'
+            json_response = JSON.parse(@response.body)
+            assert_equal(json_response.first["label"], "Alpha")
+            assert_equal(json_response.last["label"], "Alzpha")
+          end
+
+          should "be able to sort in other ways if desired" do
+            GamesController.send(:autocomplete, :game, :name, {:order => "name DESC"})
+
+            get :autocomplete_game_name, :term => 'Al'
+            json_response = JSON.parse(@response.body)
+            assert_equal(json_response.first["label"], "Alzpha")
+            assert_equal(json_response.last["label"], "Alpha")
+          end
+
+          should "be able to limit the results" do
+            GamesController.send(:autocomplete, :game, :name, {:limit => 1})
+
+            get :autocomplete_game_name, :term => 'Al'
+            json_response = JSON.parse(@response.body)
+            assert_equal(json_response.length, 1)
+          end
+
+          should "ignore case of search term and results" do
+            @game = Game.create(:name => 'aLpHa')
+
+            GamesController.send(:autocomplete, :game, :name)
+
+            get :autocomplete_game_name, :term => 'Al'
+            json_response = JSON.parse(@response.body)
+            assert_equal(json_response.length, Game.count)
+            assert_equal(json_response.last["label"], 'aLpHa')
+          end
+
+          should "match term to letters in middle of words when full-text search is on" do
+            GamesController.send(:autocomplete, :game, :name, {:full => true})
+
+            get :autocomplete_game_name, :term => 'ph'
+            json_response = JSON.parse(@response.body)
+            assert_equal(json_response.length, Game.count)
+            assert_equal(json_response.first["label"], @game.name)
+          end
+
+          should "be able to customize what is displayed" do
+            GamesController.send(:autocomplete, :game, :name, {:display_value => :display_name})
+
+            get :autocomplete_game_name, :term => 'Al'
+
+            json_response = JSON.parse(@response.body)
+
+            assert_equal(@game.display_name, json_response.first["label"])
+            assert_equal(@game.display_name, json_response.first["value"])
+            assert_equal(@game.id.to_s, json_response.first["id"])
+          end
+        end
+      end
+
+    end
+  end
+end

data/test/support/active_record.rb

@@ -0,0 +1,43 @@
+class Actor < ActiveRecord::Base
+  belongs_to :movie
+end
+
+class Movie < ActiveRecord::Base
+  def display_name
+    "Movie: #{name}"
+  end
+end
+
+class ActorsController < ActionController::Base
+  autocomplete :movie, :name                       
+end        
+
+module Rails3JQueryAutocomplete
+  module Test
+    module ActiveRecord
+      def setup
+        ::ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+        ::ActiveRecord::Schema.define(:version => 1) do
+          create_table :movies do |t|
+            t.column :name, :string
+          end
+
+          create_table :actors do |t|
+            t.column :movie_id, :integer
+            t.column :name, :string
+          end
+        end
+
+        @movie  = Movie.create(:name => 'Alpha')
+        @movie2 = Movie.create(:name => 'Alspha')
+        @movie3 = Movie.create(:name => 'Alzpha')
+      end
+
+      def teardown
+        ::ActiveRecord::Base.connection.tables.each do |table|
+          ::ActiveRecord::Base.connection.drop_table(table)
+        end
+      end
+    end
+  end
+end

data/test/support/mongoid.rb

@@ -0,0 +1,41 @@
+class Character
+  include Mongoid::Document
+  field :name, :class => String
+  referenced_in :game
+end
+
+class Game
+  include Mongoid::Document
+  field :name, :class => String
+  references_one :character
+  def display_name
+    "Game: #{name}"
+  end
+end
+
+class GamesController < ActionController::Base
+  autocomplete :game, :name                       
+end        
+
+module Rails3JQueryAutocomplete
+  module Test
+    module Mongoid
+      def setup
+        ::Mongoid.configure do |config|
+          name = "rails3_jquery_autocomplete_test"
+          host = "localhost"
+          config.master = Mongo::Connection.new.db(name)
+          config.logger = nil
+        end
+
+        @game = Game.create(:name => 'Alpha')
+        @game2 = Game.create(:name => 'Alspha')
+        @game3 = Game.create(:name => 'Alzpha')
+      end
+
+      def teardown
+        ::Mongoid.master.collections.select {|c| c.name !~ /system/ }.each(&:drop)
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -1,34 +1,26 @@
 require 'test/unit'
-
 require 'rubygems'
 gem 'rails', '>=3.0.0.rc'
-gem 'sqlite3-ruby'
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 
-require "active_support"
-require "active_record"
-require "active_model"
-require "action_controller"
-require "rails/railtie"
+ENV["RAILS_ENV"] = "test"
 
+require 'rails/all'
+require 'mongoid'
+require 'shoulda'
+require 'redgreen'
+require 'rails/test_help'
 require 'rails3-jquery-autocomplete'
 
-class ApplicationController < ActionController::Base; end
-
-ActionController::Base.view_paths = File.join(File.dirname(__FILE__), 'views')
-
-Rails3JQueryAutocomplete::Routes = ActionDispatch::Routing::RouteSet.new
-Rails3JQueryAutocomplete::Routes.draw do |map|
-  map.connect ':controller/:action/:id'
-  map.connect ':controller/:action'
+module Rails3JQueryAutocomplete
+  class Application < Rails::Application
+  end
 end
 
-ActionController::Base.send :include, Rails3JQueryAutocomplete::Routes.url_helpers
-
-class ActiveSupport::TestCase
-  setup do
-    @routes = Rails3JQueryAutocomplete::Routes
-  end
+Rails3JQueryAutocomplete::Application.routes.draw do
+  match '/:controller(/:action(/:id))'
 end
+
+ActionController::Base.send :include, Rails3JQueryAutocomplete::Application.routes.url_helpers

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rails3-jquery-autocomplete
 version: !ruby/object:Gem::Version 
-  hash: 31
+  hash: 15
   prerelease: false
   segments: 
   - 0
-  - 3
-  - 6
-  version: 0.3.6
+  - 4
+  - 0
+  version: 0.4.0
 platform: ruby
 authors: 
 - David Padilla
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-12 00:00:00 -05:00
+date: 2010-10-22 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -47,13 +47,19 @@ files:
 - README.markdown
 - Rakefile
 - lib/cucumber/autocomplete.rb
-- lib/form_helper.rb
 - lib/generators/autocomplete_generator.rb
 - lib/generators/templates/autocomplete-rails.js
 - lib/rails3-jquery-autocomplete.rb
-- test/autocomplete_generator_test.rb
-- test/controller_module_test.rb
+- lib/rails3-jquery-autocomplete/autocomplete.rb
+- lib/rails3-jquery-autocomplete/form_helper.rb
+- lib/rails3-jquery-autocomplete/helpers.rb
+- test/active_record_controller_test.rb
 - test/form_helper_test.rb
+- test/generators/generator_test.rb
+- test/helpers.rb
+- test/mongoid_controller_test.rb
+- test/support/active_record.rb
+- test/support/mongoid.rb
 - test/test_helper.rb
 - LICENSE
 has_rdoc: true
@@ -91,7 +97,11 @@ signing_key:
 specification_version: 3
 summary: Use jQuery's autocomplete plugin with Rails 3.
 test_files: 
-- test/autocomplete_generator_test.rb
-- test/controller_module_test.rb
+- test/active_record_controller_test.rb
 - test/form_helper_test.rb
+- test/generators/generator_test.rb
+- test/helpers.rb
+- test/mongoid_controller_test.rb
+- test/support/active_record.rb
+- test/support/mongoid.rb
 - test/test_helper.rb

data/test/controller_module_test.rb

@@ -1,138 +0,0 @@
-require "test_helper"
-
-class ActorsController < ApplicationController
-  autocomplete :movie, :name
-end
-
-ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
-
-class Actor < ActiveRecord::Base
-  belongs_to :movie
-end
-
-class Movie < ActiveRecord::Base
-  def display_name
-    "Movie: #{name}"
-  end
-end
-
-def setup_db
-  ActiveRecord::Schema.define(:version => 1) do
-    create_table :movies do |t|
-      t.column :name, :string
-    end
-
-    create_table :actors do |t|
-      t.column :movie_id, :integer
-      t.column :name, :string
-    end
-  end
-end
-
-def teardown_db
-  ActiveRecord::Base.connection.tables.each do |table|
-    ActiveRecord::Base.connection.drop_table(table)
-  end
-end
-
-class ActorsControllerTest < ActionController::TestCase
-  require 'shoulda'
-  require 'redgreen'
-  def setup
-    setup_db
-
-    @controller          = ActorsController.new
-    @controller.request  = @request  = ActionController::TestRequest.new
-    @controller.response = @response = ActionController::TestResponse.new
-  end
-
-  def teardown
-    teardown_db
-  end
-
-  context "the autocomplete gem" do
-    setup do
-      @movie  = Movie.create(:name => 'Alpha')
-      @movie2 = Movie.create(:name => 'Alspha')
-      @movie3 = Movie.create(:name => 'Alzpha')
-    end
-
-    should "be able to access the autocomplete action regardless of the quality of param[:term]" do
-      get :autocomplete_movie_name
-      assert_response :success
-
-      get :autocomplete_movie_name, :term => ''
-      assert_response :success
-
-      get :autocomplete_movie_name, :term => nil
-      assert_response :success
-
-      get :autocomplete_movie_name, :term => 'Al'
-      assert_response :success
-    end
-
-    should "respond with expected json" do
-      get :autocomplete_movie_name, :term => 'Al'
-      json_response = JSON.parse(@response.body)
-      assert_equal(json_response.first["label"], @movie.name)
-      assert_equal(json_response.first["value"], @movie.name)
-      assert_equal(json_response.first["id"], @movie.id)
-    end
-
-    should "return results in alphabetical order by default" do
-      get :autocomplete_movie_name, :term => 'Al'
-      json_response = JSON.parse(@response.body)
-      assert_equal(json_response.first["label"], "Alpha")
-      assert_equal(json_response.last["label"], "Alzpha")
-    end
-
-    should "be able to sort in other ways if desired" do
-      ActorsController.send(:autocomplete, :movie, :name, {:order => "name DESC"})
-
-      get :autocomplete_movie_name, :term => 'Al'
-      json_response = JSON.parse(@response.body)
-      assert_equal(json_response.first["label"], "Alzpha")
-      assert_equal(json_response.last["label"], "Alpha")
-    end
-
-    should "be able to limit the results" do
-      ActorsController.send(:autocomplete, :movie, :name, {:limit => 1})
-
-      get :autocomplete_movie_name, :term => 'Al'
-      json_response = JSON.parse(@response.body)
-      assert_equal(json_response.length, 1)
-    end
-
-    should "ignore case of search term and results" do
-      @movie = Movie.create(:name => 'aLpHa')
-
-      ActorsController.send(:autocomplete, :movie, :name)
-
-      get :autocomplete_movie_name, :term => 'Al'
-      json_response = JSON.parse(@response.body)
-      assert_equal(json_response.length, Movie.count)
-      assert_equal(json_response.last["label"], 'aLpHa')
-    end
-
-    should "match term to letters in middle of words when full-text search is on" do
-      ActorsController.send(:autocomplete, :movie, :name, {:full => true})
-
-      get :autocomplete_movie_name, :term => 'ph'
-      json_response = JSON.parse(@response.body)
-      assert_equal(json_response.length, Movie.count)
-      assert_equal(json_response.first["label"], @movie.name)
-    end
-
-    should "be able to customize what is displayed" do
-      ActorsController.send(:autocomplete, :movie, :name, {:display_value => :display_name})
-
-      get :autocomplete_movie_name, :term => 'Al'
-
-      json_response = JSON.parse(@response.body)
-
-      assert_equal(@movie.display_name, json_response.first["label"])
-      assert_equal(@movie.display_name, json_response.first["value"])
-      assert_equal(@movie.id, json_response.first["id"])
-    end
-  end
-end