lockbox_middleware 1.2.1 → 1.2.2

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

@@ -1,64 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
-
-class AllowValueMatcherTest < ActiveSupport::TestCase # :nodoc:
-
-  context "an attribute with a format validation" do
-    setup do
-      define_model :example, :attr => :string do
-        validates_format_of :attr, :with => /abc/
-      end
-      @model = Example.new
-    end
-
-    should "allow a good value" do
-      assert_accepts allow_value("abcde").for(:attr), @model
-    end
-    
-    should "not allow a bad value" do
-      assert_rejects allow_value("xyz").for(:attr), @model
-    end
-  end
-
-  context "an attribute with a format validation and a custom message" do
-    setup do
-      define_model :example, :attr => :string do
-        validates_format_of :attr, :with => /abc/, :message => 'bad value'
-      end
-      @model = Example.new
-    end
-
-    should "allow a good value" do
-      assert_accepts allow_value('abcde').for(:attr).with_message(/bad/),
-                     @model
-    end
-    
-    should "not allow a bad value" do
-      assert_rejects allow_value('xyz').for(:attr).with_message(/bad/),
-                     @model
-    end
-  end
-
-  context "an attribute with several validations" do
-    setup do
-      define_model :example, :attr => :string do
-        validates_presence_of     :attr
-        validates_length_of       :attr, :within => 1..5
-        validates_numericality_of :attr, :greater_than_or_equal_to => 1,
-                                         :less_than_or_equal_to    => 50000
-      end
-      @model = Example.new
-    end
-
-    should "allow a good value" do
-      assert_accepts allow_value("12345").for(:attr), @model
-    end
-    
-    bad_values = [nil, "", "abc", "0", "50001", "123456"]
-    bad_values.each do |value|
-      should "not allow a bad value (#{value.inspect})" do
-        assert_rejects allow_value(value).for(:attr), @model
-      end
-    end
-  end
-
-end

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

@@ -1,263 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
-
-class AssociationMatcherTest < ActiveSupport::TestCase # :nodoc:
-
-  context "belong_to" do
-    setup do
-      @matcher = belong_to(:parent)
-    end
-
-    should "accept a good association with the default foreign key" do
-      define_model :parent
-      define_model :child, :parent_id => :integer do
-        belongs_to :parent
-      end
-      assert_accepts @matcher, Child.new
-    end
-
-    should "reject a nonexistent association" do
-      define_model :child
-      assert_rejects @matcher, Child.new
-    end
-
-    should "reject an association of the wrong type" do
-      define_model :parent, :child_id => :integer
-      child_class = define_model :child do
-        has_one :parent
-      end
-      assert_rejects @matcher, Child.new
-    end
-
-    should "reject an association that has a nonexistent foreign key" do
-      define_model :parent
-      define_model :child do
-        belongs_to :parent
-      end
-      assert_rejects @matcher, Child.new
-    end
-
-    should "accept an association with an existing custom foreign key" do
-      define_model :parent
-      define_model :child, :guardian_id => :integer do
-        belongs_to :parent, :foreign_key => 'guardian_id'
-      end
-      assert_accepts @matcher, Child.new
-    end
-
-    should "accept a polymorphic association" do
-      define_model :child, :parent_type => :string,
-                                :parent_id   => :integer do
-        belongs_to :parent, :polymorphic => true
-      end
-      assert_accepts @matcher, Child.new
-    end
-
-    should "accept an association with a valid :dependent option" do
-      define_model :parent
-      define_model :child, :parent_id => :integer do
-        belongs_to :parent, :dependent => :destroy
-      end
-      assert_accepts @matcher.dependent(:destroy), Child.new
-    end
-
-    should "reject an association with a bad :dependent option" do
-      define_model :parent
-      define_model :child, :parent_id => :integer do
-        belongs_to :parent
-      end
-      assert_rejects @matcher.dependent(:destroy), Child.new
-    end
-  end
-
-  context "have_many" do
-    setup do
-      @matcher = have_many(:children)
-    end
-
-    should "accept a valid association without any options" do
-      define_model :child, :parent_id => :integer
-      define_model :parent do
-        has_many :children
-      end
-      assert_accepts @matcher, Parent.new
-    end
-
-    should "accept a valid association with a :through option" do
-      define_model :child
-      define_model :conception, :child_id  => :integer,
-                                     :parent_id => :integer do
-        belongs_to :child
-      end
-      define_model :parent do
-        has_many :conceptions
-        has_many :children, :through => :conceptions
-      end
-      assert_accepts @matcher, Parent.new
-    end
-
-    should "accept a valid association with an :as option" do
-      define_model :child, :guardian_type => :string,
-                                :guardian_id   => :integer
-      define_model :parent do
-        has_many :children, :as => :guardian
-      end
-      assert_accepts @matcher, Parent.new
-    end
-
-    should "reject an association that has a nonexistent foreign key" do
-      define_model :child
-      define_model :parent do
-        has_many :children
-      end
-      assert_rejects @matcher, Parent.new
-    end
-
-    should "reject an association with a bad :as option" do
-      define_model :child, :caretaker_type => :string,
-                                :caretaker_id   => :integer
-      define_model :parent do
-        has_many :children, :as => :guardian
-      end
-      assert_rejects @matcher, Parent.new
-    end
-
-    should "reject an association that has a bad :through option" do
-      define_model :child, :parent_id => :integer
-      define_model :parent do
-        has_many :children
-      end
-      assert_rejects @matcher.through(:conceptions),
-        Parent.new,
-        :message => /does not have any relationship to conceptions/
-    end
-
-    should "reject an association that has the wrong :through option" do
-      define_model :child
-      define_model :conception, :child_id  => :integer,
-                                     :parent_id => :integer do
-        belongs_to :child
-      end
-      define_model :parent do
-        has_many :conceptions
-        has_many :relationships
-        has_many :children, :through => :conceptions
-      end
-      assert_rejects @matcher.through(:relationships),
-                     Parent.new,
-                     :message => /through relationships, but got it through conceptions/
-    end
-
-    should "accept an association with a valid :dependent option" do
-      define_model :child, :parent_id => :integer
-      define_model :parent do
-        has_many :children, :dependent => :destroy
-      end
-      assert_accepts @matcher.dependent(:destroy), Parent.new
-    end
-
-    should "reject an association with a bad :dependent option" do
-      define_model :child, :parent_id => :integer
-      define_model :parent do
-        has_many :children
-      end
-      assert_rejects @matcher.dependent(:destroy), Parent.new
-    end
-  end
-
-  context "have_one" do
-    setup do
-      @matcher = have_one(:profile)
-    end
-
-    should "accept a valid association without any options" do
-      define_model :profile, :person_id => :integer
-      define_model :person do
-        has_one :profile
-      end
-      assert_accepts @matcher, Person.new
-    end
-
-    should "accept a valid association with an :as option" do
-      define_model :profile, :profilable_id   => :integer,
-                                  :profilable_type => :string
-      define_model :person do
-        has_one :profile, :as => :profilable
-      end
-      assert_accepts @matcher, Person.new
-    end
-
-    should "reject an association that has a nonexistent foreign key" do
-      define_model :profile
-      define_model :person do
-        has_one :profile
-      end
-      assert_rejects @matcher, Person.new
-    end
-
-    should "reject an association with a bad :as option" do
-      define_model :profile, :profilable_id   => :integer,
-                                  :profilable_type => :string
-      define_model :person do
-        has_one :profile, :as => :describable
-      end
-      assert_rejects @matcher, Person.new
-    end
-
-    should "accept an association with a valid :dependent option" do
-      define_model :profile, :person_id => :integer
-      define_model :person do
-        has_one :profile, :dependent => :destroy
-      end
-      assert_accepts @matcher.dependent(:destroy), Person.new
-    end
-
-    should "reject an association with a bad :dependent option" do
-      define_model :profile, :person_id => :integer
-      define_model :person do
-        has_one :profile
-      end
-      assert_rejects @matcher.dependent(:destroy), Person.new
-    end
-  end
-
-  context "have_and_belong_to_many" do
-    setup do
-      @matcher = have_and_belong_to_many(:relatives)
-    end
-
-    should "accept a valid association" do
-      define_model :relatives
-      define_model :person do
-        has_and_belongs_to_many :relatives
-      end
-      define_model :people_relative, :person_id   => :integer,
-                                          :relative_id => :integer
-      assert_accepts @matcher, Person.new
-    end
-
-    should "reject a nonexistent association" do
-      define_model :relatives
-      define_model :person
-      define_model :people_relative, :person_id   => :integer,
-                                          :relative_id => :integer
-      assert_rejects @matcher, Person.new
-    end
-
-    should "reject an association with a nonexistent join table" do
-      define_model :relatives
-      define_model :person do
-        has_and_belongs_to_many :relatives
-      end
-      assert_rejects @matcher, Person.new
-    end
-
-    should "reject an association of the wrong type" do
-      define_model :relatives, :person_id => :integer
-      define_model :person do
-        has_many :relatives
-      end
-      assert_rejects @matcher, Person.new
-    end
-  end
-
-end

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

@@ -1,80 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
-
-class EnsureInclusionOfMatcherTest < ActiveSupport::TestCase # :nodoc:
-
-  context "an attribute which must be included in a range" do
-    setup do
-      @model = define_model(:example, :attr => :integer) do
-        validates_inclusion_of :attr, :in => 2..5
-      end.new
-    end
-
-    should "accept ensuring the correct range" do
-      assert_accepts ensure_inclusion_of(:attr).in_range(2..5), @model
-    end
-
-    should "reject ensuring a lower minimum value" do
-      assert_rejects ensure_inclusion_of(:attr).in_range(1..5), @model
-    end
-
-    should "reject ensuring a higher minimum value" do
-      assert_rejects ensure_inclusion_of(:attr).in_range(3..5), @model
-    end
-
-    should "reject ensuring a lower maximum value" do
-      assert_rejects ensure_inclusion_of(:attr).in_range(2..4), @model
-    end
-
-    should "reject ensuring a higher maximum value" do
-      assert_rejects ensure_inclusion_of(:attr).in_range(2..6), @model
-    end
-
-    should "not override the default message with a blank" do
-      assert_accepts ensure_inclusion_of(:attr).
-                       in_range(2..5).
-                       with_message(nil),
-                     @model
-    end
-  end
-
-  context "an attribute with a custom ranged value validation" do
-    setup do
-      @model = define_model(:example, :attr => :string) do
-        validates_inclusion_of :attr, :in => 2..4, :message => 'not good'
-
-      end.new
-    end
-
-    should "accept ensuring the correct range" do
-      assert_accepts ensure_inclusion_of(:attr).
-                       in_range(2..4).
-                       with_message(/not good/),
-                     @model
-    end
-  end
-
-  context "an attribute with custom range validations" do
-    setup do
-      define_model :example, :attr => :integer do
-        def validate
-          if attr < 2
-            errors.add(:attr, 'too low')
-          elsif attr > 5
-            errors.add(:attr, 'too high')
-          end
-        end
-      end
-      @model = Example.new
-    end
-
-    should "accept ensuring the correct range and messages" do
-      assert_accepts ensure_inclusion_of(:attr).
-                       in_range(2..5).
-                       with_low_message(/low/).
-                       with_high_message(/high/),
-                     @model
-    end
-
-  end
-
-end

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

@@ -1,158 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
-
-class EnsureLengthOfMatcher < ActiveSupport::TestCase # :nodoc:
-
-  context "an attribute with a non-zero minimum length validation" do
-    setup do
-      @model = define_model(:example, :attr => :string) do
-        validates_length_of :attr, :minimum => 4
-      end.new
-    end
-
-    should "accept ensuring the correct minimum length" do
-      assert_accepts ensure_length_of(:attr).is_at_least(4), @model
-    end
-
-    should "reject ensuring a lower minimum length with any message" do
-      assert_rejects ensure_length_of(:attr).
-                       is_at_least(3).
-                       with_short_message(/.*/),
-                     @model
-    end
-
-    should "reject ensuring a higher minimum length with any message" do
-      assert_rejects ensure_length_of(:attr).
-                       is_at_least(5).
-                       with_short_message(/.*/),
-                     @model
-    end
-
-    should "not override the default message with a blank" do
-      assert_accepts ensure_length_of(:attr).
-                       is_at_least(4).
-                       with_short_message(nil),
-                     @model
-    end
-  end
-
-  context "an attribute with a minimum length validation of 0" do
-    setup do
-      @model = define_model(:example, :attr => :string) do
-        validates_length_of :attr, :minimum => 0
-      end.new
-    end
-
-    should "accept ensuring the correct minimum length" do
-      assert_accepts ensure_length_of(:attr).is_at_least(0), @model
-    end
-  end
-
-  context "an attribute with a maximum length" do
-    setup do
-      @model = define_model(:example, :attr => :string) do
-        validates_length_of :attr, :maximum => 4
-      end.new
-    end
-
-    should "accept ensuring the correct maximum length" do
-      assert_accepts ensure_length_of(:attr).is_at_most(4), @model
-    end
-
-    should "reject ensuring a lower maximum length with any message" do
-      assert_rejects ensure_length_of(:attr).
-                       is_at_most(3).
-                       with_long_message(/.*/),
-                     @model
-    end
-
-    should "reject ensuring a higher maximum length with any message" do
-      assert_rejects ensure_length_of(:attr).
-                       is_at_most(5).
-                       with_long_message(/.*/),
-                     @model
-    end
-
-    should "not override the default message with a blank" do
-      assert_accepts ensure_length_of(:attr).
-                       is_at_most(4).
-                       with_long_message(nil),
-                     @model
-    end
-  end
-
-  context "an attribute with a required exact length" do
-    setup do
-      @model = define_model(:example, :attr => :string) do
-        validates_length_of :attr, :is => 4
-      end.new
-    end
-
-    should "accept ensuring the correct length" do
-      assert_accepts ensure_length_of(:attr).is_equal_to(4), @model
-    end
-
-    should "reject ensuring a lower maximum length with any message" do
-      assert_rejects ensure_length_of(:attr).
-                       is_equal_to(3).
-                       with_message(/.*/),
-                     @model
-    end
-
-    should "reject ensuring a higher maximum length with any message" do
-      assert_rejects ensure_length_of(:attr).
-                       is_equal_to(5).
-                       with_message(/.*/),
-                     @model
-    end
-
-    should "not override the default message with a blank" do
-      assert_accepts ensure_length_of(:attr).
-                       is_equal_to(4).
-                       with_message(nil),
-                     @model
-    end
-  end
-
-  context "an attribute with a custom minimum length validation" do
-    setup do
-      @model = define_model(:example, :attr => :string) do
-        validates_length_of :attr, :minimum => 4, :too_short => 'short'
-      end.new
-    end
-
-    should "accept ensuring the correct minimum length" do
-      assert_accepts ensure_length_of(:attr).
-                       is_at_least(4).
-                       with_short_message(/short/),
-                     @model
-    end
-
-  end
-
-  context "an attribute with a custom maximum length validation" do
-    setup do
-      @model = define_model(:example, :attr => :string) do
-        validates_length_of :attr, :maximum => 4, :too_long => 'long'
-      end.new
-    end
-
-    should "accept ensuring the correct minimum length" do
-      assert_accepts ensure_length_of(:attr).
-                       is_at_most(4).
-                       with_long_message(/long/),
-                     @model
-    end
-
-  end
-
-  context "an attribute without a length validation" do
-    setup do
-      @model = define_model(:example, :attr => :string).new
-    end
-
-    should "reject ensuring a minimum length" do
-      assert_rejects ensure_length_of(:attr).is_at_least(1), @model
-    end
-  end
-
-end