lockbox_middleware 1.2.1 → 1.2.2

data/vendor/gems/shoulda-2.10.2/test/matchers/active_record/validate_uniqueness_of_matcher_test.rb

@@ -1,147 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
-
-class ValidateUniquenessOfMatcherTest < ActiveSupport::TestCase # :nodoc:
-
-  context "a unique attribute" do
-    setup do
-      @model = define_model(:example, :attr  => :string,
-                                           :other => :integer) do
-        validates_uniqueness_of :attr
-      end.new
-    end
-
-    context "with an existing value" do
-      setup do
-        @existing = Example.create!(:attr => 'value', :other => 1)
-      end
-
-      should "require a unique value for that attribute" do
-        assert_accepts validate_uniqueness_of(:attr), @model
-      end
-
-      should "pass when the subject is an existing record" do
-        assert_accepts validate_uniqueness_of(:attr), @existing
-      end
-
-      should "fail when a scope is specified" do
-        assert_rejects validate_uniqueness_of(:attr).scoped_to(:other), @model
-      end
-    end
-
-    context "without an existing value" do
-      setup do
-        assert_nil Example.find(:first)
-        @matcher = validate_uniqueness_of(:attr)
-      end
-
-      should "fail to require a unique value" do
-        assert_rejects @matcher, @model
-      end
-
-      should "alert the tester that an existing value is not present" do
-        @matcher.matches?(@model)
-        assert @matcher.negative_failure_message =~ /^Can't find first .*/
-      end
-    end
-  end
-
-  context "a unique attribute with a custom error and an existing value" do
-    setup do
-      @model = define_model(:example, :attr => :string) do
-        validates_uniqueness_of :attr, :message => 'Bad value'
-      end.new
-      Example.create!
-    end
-
-    should "fail when checking the default message" do
-      assert_rejects validate_uniqueness_of(:attr), @model
-    end
-
-    should "fail when checking a message that doesn't match" do
-      assert_rejects validate_uniqueness_of(:attr).with_message(/abc/i), @model
-    end
-
-    should "pass when checking a message that matches" do
-      assert_accepts validate_uniqueness_of(:attr).with_message(/bad/i), @model
-    end
-  end
-
-  context "a scoped unique attribute with an existing value" do
-    setup do
-      @model = define_model(:example, :attr   => :string,
-                                           :scope1 => :integer,
-                                           :scope2 => :integer) do
-        validates_uniqueness_of :attr, :scope => [:scope1, :scope2]
-      end.new
-      @existing = Example.create!(:attr => 'value', :scope1 => 1, :scope2 => 2)
-    end
-
-    should "pass when the correct scope is specified" do
-      assert_accepts validate_uniqueness_of(:attr).scoped_to(:scope1, :scope2),
-        @model
-    end
-
-    should "pass when the subject is an existing record" do
-      assert_accepts validate_uniqueness_of(:attr).scoped_to(:scope1, :scope2),
-        @existing
-    end
-
-    should "fail when a different scope is specified" do
-      assert_rejects validate_uniqueness_of(:attr).scoped_to(:scope1), @model
-    end
-
-    should "fail when no scope is specified" do
-      assert_rejects validate_uniqueness_of(:attr), @model
-    end
-
-    should "fail when a non-existent attribute is specified as a scope" do
-      assert_rejects validate_uniqueness_of(:attr).scoped_to(:fake), @model
-    end
-  end
-
-  context "a non-unique attribute with an existing value" do
-    setup do
-      @model = define_model(:example, :attr => :string).new
-      Example.create!(:attr => 'value')
-    end
-
-    should "not require a unique value for that attribute" do
-      assert_rejects validate_uniqueness_of(:attr), @model
-    end
-  end
-
-  context "a case sensitive unique attribute with an existing value" do
-    setup do
-      @model = define_model(:example, :attr  => :string) do
-        validates_uniqueness_of :attr, :case_sensitive => true
-      end.new
-      Example.create!(:attr => 'value')
-    end
-
-    should "not require a unique, case-insensitive value for that attribute" do
-      assert_rejects validate_uniqueness_of(:attr).case_insensitive, @model
-    end
-
-    should "require a unique, case-sensitive value for that attribute" do
-      assert_accepts validate_uniqueness_of(:attr), @model
-    end
-  end
-
-  context "a case sensitive unique integer attribute with an existing value" do
-    setup do
-      @model = define_model(:example, :attr  => :integer) do
-        validates_uniqueness_of :attr, :case_sensitive => true
-      end.new
-      Example.create!(:attr => 'value')
-    end
-
-    should "require a unique, case-insensitive value for that attribute" do
-      assert_accepts validate_uniqueness_of(:attr).case_insensitive, @model
-    end
-
-    should "require a unique, case-sensitive value for that attribute" do
-      assert_accepts validate_uniqueness_of(:attr), @model
-    end
-  end
-
-end

data/vendor/gems/shoulda-2.10.2/test/matchers/controller/assign_to_matcher_test.rb

@@ -1,35 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
-
-class AssignToMatcherTest < ActionController::TestCase # :nodoc:
-
-  context "a controller that assigns to an instance variable" do
-    setup do
-      @controller = build_response { @var = 'value' }
-    end
-
-    should "accept assigning to that variable" do
-      assert_accepts assign_to(:var), @controller
-    end
-
-    should "accept assigning to that variable with the correct class" do
-      assert_accepts assign_to(:var).with_kind_of(String), @controller
-    end
-
-    should "reject assigning to that variable with another class" do
-      assert_rejects assign_to(:var).with_kind_of(Fixnum), @controller
-    end
-
-    should "accept assigning the correct value to that variable" do
-      assert_accepts assign_to(:var).with('value'), @controller
-    end
-
-    should "reject assigning another value to that variable" do
-      assert_rejects assign_to(:var).with('other'), @controller
-    end
-
-    should "reject assigning to another variable" do
-      assert_rejects assign_to(:other), @controller
-    end
-  end
-
-end

data/vendor/gems/shoulda-2.10.2/test/matchers/controller/filter_param_matcher_test.rb

@@ -1,32 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
-
-class FilterParamMatcherTest < ActionController::TestCase # :nodoc:
-
-  context "a controller that filters no parameters" do
-    setup do
-      @controller = define_controller(:examples).new
-    end
-
-    should "reject filtering any parameter" do
-      assert_rejects filter_param(:any), @controller
-    end
-  end
-
-  context "a controller that filters a parameter" do
-    setup do
-      @controller = define_controller :examples do
-        filter_parameter_logging :password
-      end.new
-    end
-
-    should "accept filtering that parameter" do
-      assert_accepts filter_param(:password), @controller
-    end
-
-    should "reject filtering another parameter" do
-      assert_rejects filter_param(:other), @controller
-    end
-  end
-
-end
-

data/vendor/gems/shoulda-2.10.2/test/matchers/controller/render_with_layout_matcher_test.rb

@@ -1,33 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
-
-class RenderWithLayoutMatcherTest < ActionController::TestCase # :nodoc:
-
-  context "a controller that renders with a layout" do
-    setup do
-      @controller = build_response { render :layout => 'wide' }
-    end
-
-    should "accept rendering with any layout" do
-      assert_accepts render_with_layout, @controller
-    end
-
-    should "accept rendering with that layout" do
-      assert_accepts render_with_layout(:wide), @controller
-    end
-
-    should "reject rendering with another layout" do
-      assert_rejects render_with_layout(:other), @controller
-    end
-  end
-
-  context "a controller that renders without a layout" do
-    setup do
-      @controller = build_response { render :layout => false }
-    end
-
-    should "reject rendering with a layout" do
-      assert_rejects render_with_layout, @controller
-    end
-  end
-
-end

data/vendor/gems/shoulda-2.10.2/test/matchers/controller/respond_with_content_type_matcher_test.rb

@@ -1,32 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
-
-class RespondWithContentTypeMatcherTest < ActionController::TestCase # :nodoc:
-
-  context "a controller responding with content type :xml" do
-    setup do
-      @controller = build_response { render :xml => { :user => "thoughtbot" }.to_xml }
-    end
-
-    should "accept responding with content type :xml" do
-      assert_accepts respond_with_content_type(:xml), @controller
-    end
-
-    should "accept responding with content type 'application/xml'" do
-      assert_accepts respond_with_content_type('application/xml'), @controller
-    end
-
-    should "accept responding with content type /xml/" do
-      assert_accepts respond_with_content_type(/xml/), @controller
-    end
-
-    should "reject responding with another content type" do
-      assert_rejects respond_with_content_type(:json), @controller
-    end
-  end
-
-  should "generate the correct test name" do
-    assert_equal "respond with content type of application/xml",
-                 respond_with_content_type(:xml).description
-  end
-
-end

data/vendor/gems/shoulda-2.10.2/test/matchers/controller/respond_with_matcher_test.rb

@@ -1,106 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
-
-class RespondWithMatcherTest < ActionController::TestCase # :nodoc:
-
-  context "a controller responding with success" do
-    setup do
-      @controller = build_response { render :text => "text", :status => 200 }
-    end
-
-    should "accept responding with 200" do
-      assert_accepts respond_with(200), @controller
-    end
-    
-    should "accept responding with :success" do
-      assert_accepts respond_with(:success), @controller
-    end
-    
-    should "reject responding with another status" do
-      assert_rejects respond_with(:error), @controller
-    end
-  end
-  
-  context "a controller responding with redirect" do
-    setup do
-      @controller = build_response { render :text => "text", :status => 301 }
-    end
-
-    should "accept responding with 301" do
-      assert_accepts respond_with(301), @controller
-    end
-    
-    should "accept responding with :redirect" do
-      assert_accepts respond_with(:redirect), @controller
-    end
-    
-    should "reject responding with another status" do
-      assert_rejects respond_with(:error), @controller
-    end
-  end
-  
-  context "a controller responding with missing" do
-    setup do
-      @controller = build_response { render :text => "text", :status => 404 }
-    end
-
-    should "accept responding with 404" do
-      assert_accepts respond_with(404), @controller
-    end
-    
-    should "accept responding with :missing" do
-      assert_accepts respond_with(:missing), @controller
-    end
-    
-    should "reject responding with another status" do
-      assert_rejects respond_with(:success), @controller
-    end
-  end
-  
-  context "a controller responding with error" do
-    setup do
-      @controller = build_response { render :text => "text", :status => 500 }
-    end
-
-    should "accept responding with 500" do
-      assert_accepts respond_with(500), @controller
-    end
-    
-    should "accept responding with :error" do
-      assert_accepts respond_with(:error), @controller
-    end
-    
-    should "reject responding with another status" do
-      assert_rejects respond_with(:success), @controller
-    end
-  end
-  
-  context "a controller responding with not implemented" do
-    setup do
-      @controller = build_response { render :text => "text", :status => 501 }
-    end
-
-    should "accept responding with 501" do
-      assert_accepts respond_with(501), @controller
-    end
-    
-    should "accept responding with :not_implemented" do
-      assert_accepts respond_with(:not_implemented), @controller
-    end
-    
-    should "reject responding with another status" do
-      assert_rejects respond_with(:success), @controller
-    end
-  end
-  
-  context "a controller raising an error" do
-    setup do
-      @controller = build_response { raise RailsError }
-    end
-
-    should "reject responding with any status" do
-      assert_rejects respond_with(:success), @controller
-    end
-  end
-
-end
-

data/vendor/gems/shoulda-2.10.2/test/matchers/controller/route_matcher_test.rb

@@ -1,58 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
-
-class RouteToMatcherTest < ActionController::TestCase # :nodoc:
-
-  context "given a controller with a defined route" do
-    setup do
-      @controller = define_controller('Examples').new
-      define_routes do |map|
-        map.connect 'examples/:id', :controller => 'examples',
-                                    :action     => 'example'
-      end
-    end
-
-    should "accept routing the correct path to the correct parameters" do
-      assert_accepts route(:get, '/examples/1').
-                       to(:action => 'example', :id => '1'),
-                     @controller
-    end
-
-    should "accept a symbol controller" do
-      assert_accepts route(:get, '/examples/1').
-                       to(:controller => :examples, 
-                          :action     => 'example',
-                          :id         => '1'),
-                     self
-    end
-
-    should "accept a symbol action" do
-      assert_accepts route(:get, '/examples/1').
-                       to(:action => :example, :id => '1'), 
-                     @controller
-    end
-
-    should "accept a non-string parameter" do
-      assert_accepts route(:get, '/examples/1').
-                       to(:action => 'example', :id => 1),
-                     @controller
-    end
-
-    should "reject an undefined route" do
-      assert_rejects route(:get, '/bad_route').to(:var => 'value'), @controller
-    end
-
-    should "reject a route for another controller" do
-      @other = define_controller('Other').new
-      assert_rejects route(:get, '/examples/1').
-                       to(:action => 'example', :id => '1'),
-                     @other
-    end
-
-    should "reject a route for different parameters" do
-      assert_rejects route(:get, '/examples/1').
-                       to(:action => 'other', :id => '1'),
-                     @controller
-    end
-  end
-
-end

data/vendor/gems/shoulda-2.10.2/test/matchers/controller/set_session_matcher_test.rb

@@ -1,38 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
-
-class SetSessionMatcherTest < ActionController::TestCase # :nodoc:
-
-  context "a controller that sets a session variable" do
-    setup do
-      @controller = build_response do
-        session[:var] = 'value'
-        session[:false_var] = false
-      end
-    end
-
-    should "accept assigning to that variable" do
-      assert_accepts set_session(:var), @controller
-    end
-
-    should "accept assigning the correct value to that variable" do
-      assert_accepts set_session(:var).to('value'), @controller
-    end
-
-    should "reject assigning another value to that variable" do
-      assert_rejects set_session(:var).to('other'), @controller
-    end
-
-    should "reject assigning to another variable" do
-      assert_rejects set_session(:other), @controller
-    end
-
-    should "accept assigning nil to another variable" do
-      assert_accepts set_session(:other).to(nil), @controller
-    end
-
-    should "accept assigning false to that variable" do
-      assert_accepts set_session(:false_var).to(false), @controller
-    end
-  end
-
-end

data/vendor/gems/shoulda-2.10.2/test/matchers/controller/set_the_flash_matcher.rb

@@ -1,41 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
-
-class SetTheFlashMatcherTest < ActionController::TestCase # :nodoc:
-
-  context "a controller that sets a flash message" do
-    setup do
-      @controller = build_response { flash[:notice] = 'value' }
-    end
-
-    should "accept setting any flash message" do
-      assert_accepts set_the_flash, @controller
-    end
-
-    should "accept setting the exact flash message" do
-      assert_accepts set_the_flash.to('value'), @controller
-    end
-
-    should "accept setting a matched flash message" do
-      assert_accepts set_the_flash.to(/value/), @controller
-    end
-
-    should "reject setting a different flash message" do
-      assert_rejects set_the_flash.to('other'), @controller
-    end
-
-    should "reject setting a different pattern" do
-      assert_rejects set_the_flash.to(/other/), @controller
-    end
-  end
-
-  context "a controller that doesn't set a flash message" do
-    setup do
-      @controller = build_response
-    end
-
-    should "reject setting any flash message" do
-      assert_rejects set_the_flash, @controller
-    end
-  end
-
-end

data/vendor/gems/shoulda-2.10.2/test/model_builder.rb

@@ -1,106 +0,0 @@
-class ActiveSupport::TestCase  
-  def create_table(table_name, &block)
-    connection = ActiveRecord::Base.connection
-    
-    begin
-      connection.execute("DROP TABLE IF EXISTS #{table_name}")
-      connection.create_table(table_name, &block)
-      @created_tables ||= []
-      @created_tables << table_name
-      connection
-    rescue Exception => e
-      connection.execute("DROP TABLE IF EXISTS #{table_name}")
-      raise e
-    end
-  end
-
-  def define_constant(class_name, base, &block)
-    class_name = class_name.to_s.camelize
-
-    klass = Class.new(base)
-    Object.const_set(class_name, klass)
-
-    klass.class_eval(&block) if block_given?
-
-    @defined_constants ||= []
-    @defined_constants << class_name
-
-    klass
-  end
-
-  def define_model_class(class_name, &block)
-    define_constant(class_name, ActiveRecord::Base, &block)
-  end
-
-  def define_model(name, columns = {}, &block)
-    class_name = name.to_s.pluralize.classify
-    table_name = class_name.tableize
-
-    create_table(table_name) do |table|
-      columns.each do |name, type|
-        table.column name, type
-      end
-    end
-
-    define_model_class(class_name, &block)
-  end
-
-  def define_controller(class_name, &block)
-    class_name = class_name.to_s
-    class_name << 'Controller' unless class_name =~ /Controller$/
-    define_constant(class_name, ActionController::Base, &block)
-  end
-
-  def define_routes(&block)
-    @replaced_routes = ActionController::Routing::Routes
-    new_routes = ActionController::Routing::RouteSet.new
-    silence_warnings do
-      ActionController::Routing.const_set('Routes', new_routes)
-    end
-    new_routes.draw(&block)
-  end
-
-  def build_response(&block)
-    klass = define_controller('Examples')
-    block ||= lambda { render :nothing => true }
-    klass.class_eval { define_method(:example, &block) }
-    define_routes do |map| 
-      map.connect 'examples', :controller => 'examples', :action => 'example'
-    end
-
-    @controller = klass.new
-    @request    = ActionController::TestRequest.new
-    @response   = ActionController::TestResponse.new
-    get :example
-
-    @controller
-  end
-
-  def teardown_with_models
-    if @defined_constants
-      @defined_constants.each do |class_name| 
-        Object.send(:remove_const, class_name)
-      end
-    end
-
-    if @created_tables
-      @created_tables.each do |table_name|
-        ActiveRecord::Base.
-          connection.
-          execute("DROP TABLE IF EXISTS #{table_name}")
-      end
-    end
-
-    if @replaced_routes
-      ActionController::Routing::Routes.clear!
-      silence_warnings do
-        ActionController::Routing.const_set('Routes', @replaced_routes)
-      end
-      @replaced_routes.reload!
-    end
-
-    teardown_without_models
-  end
-  alias_method :teardown_without_models, :teardown
-  alias_method :teardown, :teardown_with_models
-end

data/vendor/gems/shoulda-2.10.2/test/other/autoload_macro_test.rb

@@ -1,18 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'test_helper')
-
-class AutoloadMacroTest < ActiveSupport::TestCase # :nodoc:
-  context "The macro auto-loader" do
-    should "load macros from the plugins" do
-      assert self.class.respond_to?('plugin_macro')
-    end
-
-    should "load macros from the gems" do
-      assert self.class.respond_to?('gem_macro')
-    end
-
-    should "load custom macros from ROOT/test/shoulda_macros" do
-      assert self.class.respond_to?('custom_macro')
-    end
-  end
-end
-