contracts 0.13.0 → 0.17

data/lib/contracts/method_reference.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Contracts
   # MethodReference represents original method reference that was
   # decorated by contracts.ruby. Used for instance methods.
@@ -39,8 +41,8 @@ module Contracts
 
     # Calls original method on specified `this` argument with
     # specified arguments `args` and block `&blk`.
-    def send_to(this, *args, &blk)
-      this.send(aliased_name, *args, &blk)
+    def send_to(this, *args, **kargs, &blk)
+      this.send(aliased_name, *args, **kargs, &blk)
     end
 
     private

data/lib/contracts/support.rb

@@ -1,18 +1,16 @@
+# frozen_string_literal: true
+
 module Contracts
   module Support
     class << self
       def method_position(method)
         return method.method_position if method.is_a?(MethodReference)
 
-        if RUBY_VERSION =~ /^1\.8/
-          if method.respond_to?(:__file__)
-            method.__file__ + ":" + method.__line__.to_s
-          else
-            method.inspect
-          end
+        file, line = method.source_location
+        if file.nil? || line.nil?
+          ""
         else
-          file, line = method.source_location
-          file + ":" + line.to_s
+          "#{file}:#{line}"
         end
       end
 
@@ -34,8 +32,7 @@ module Contracts
       end
 
       def eigenclass_hierarchy_supported?
-        return false if RUBY_PLATFORM == "java" && RUBY_VERSION.to_f < 2.0
-        RUBY_VERSION.to_f > 1.8
+        RUBY_PLATFORM != "java" || RUBY_VERSION.to_f >= 2.0
       end
 
       def eigenclass_of(target)
@@ -47,6 +44,13 @@ module Contracts
           target <= eigenclass_of(Object)
       end
 
+      def indent_string(string, amount)
+        string.gsub(
+          /^(?!$)/,
+          (string[/^[ \t]/] || " ") * amount,
+        )
+      end
+
       private
 
       # Module eigenclass can be detected by its ancestor chain

data/lib/contracts/validators.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Contracts
   module Validators
     DEFAULT_VALIDATOR_STRATEGIES = {
@@ -9,6 +11,7 @@ module Contracts
       Array => lambda do |contract|
         lambda do |arg|
           return false unless arg.is_a?(Array) && arg.length == contract.length
+
           arg.zip(contract).all? do |_arg, _contract|
             Contract.valid?(_arg, _contract)
           end
@@ -19,6 +22,7 @@ module Contracts
       Hash => lambda do |contract|
         lambda do |arg|
           return false unless arg.is_a?(Hash)
+
           contract.keys.all? do |k|
             Contract.valid?(arg[k], contract[k])
           end
@@ -59,7 +63,7 @@ module Contracts
 
       :default => lambda do |contract|
         lambda { |arg| contract == arg }
-      end
+      end,
     }.freeze
 
     # Allows to override validator with custom one.
@@ -90,7 +94,7 @@ module Contracts
             else
               if contract.respond_to? :valid?
                 :valid
-              elsif klass == Class || klass == Module
+              elsif [Class, Module].include?(klass)
                 :class
               else
                 :default

data/lib/contracts/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Contracts
-  VERSION = "0.13.0"
+  VERSION = "0.17"
 end

data/spec/attrs_spec.rb

@@ -0,0 +1,119 @@
+RSpec.describe "Contracts:" do
+  describe "Attrs:" do
+    class Person
+      include Contracts::Core
+      include Contracts::Attrs
+      include Contracts::Builtin
+
+      def initialize(name)
+        @name_r = name
+        @name_w = name
+        @name_rw = name
+
+        @name_r_2 = name
+        @name_w_2 = name
+        @name_rw_2 = name
+      end
+
+      attr_reader_with_contract :name_r, :name_r_2, String
+      attr_writer_with_contract :name_w, :name_w_2, String
+      attr_accessor_with_contract :name_rw, :name_rw_2, String
+    end
+
+    context "attr_reader_with_contract" do
+      it "getting valid type" do
+        expect(Person.new("bob").name_r)
+          .to(eq("bob"))
+      end
+
+      it "getting invalid type" do
+        expect { Person.new(1.3).name_r }
+          .to(raise_error(ReturnContractError))
+      end
+
+      it "getting valid type for second val" do
+        expect(Person.new("bob").name_r_2)
+          .to(eq("bob"))
+      end
+
+      it "getting invalid type for second val" do
+        expect { Person.new(1.3).name_r_2 }
+          .to(raise_error(ReturnContractError))
+      end
+
+      it "setting" do
+        expect { Person.new("bob").name_r = "alice" }
+          .to(raise_error(NoMethodError))
+      end
+    end
+
+    context "attr_writer_with_contract" do
+      it "getting" do
+        expect { Person.new("bob").name_w }
+          .to(raise_error(NoMethodError))
+      end
+
+      it "setting valid type" do
+        expect(Person.new("bob").name_w = "alice")
+          .to(eq("alice"))
+      end
+
+      it "setting invalid type" do
+        expect { Person.new("bob").name_w = 1.2 }
+          .to(raise_error(ParamContractError))
+      end
+
+      it "setting valid type for second val" do
+        expect(Person.new("bob").name_w_2 = "alice")
+          .to(eq("alice"))
+      end
+
+      it "setting invalid type for second val" do
+        expect { Person.new("bob").name_w_2 = 1.2 }
+          .to(raise_error(ParamContractError))
+      end
+    end
+
+    context "attr_accessor_with_contract" do
+      it "getting valid type" do
+        expect(Person.new("bob").name_rw)
+          .to(eq("bob"))
+      end
+
+      it "getting invalid type" do
+        expect { Person.new(1.2).name_rw }
+          .to(raise_error(ReturnContractError))
+      end
+
+      it "setting valid type" do
+        expect(Person.new("bob").name_rw = "alice")
+          .to(eq("alice"))
+      end
+
+      it "setting invalid type" do
+        expect { Person.new("bob").name_rw = 1.2 }
+          .to(raise_error(ParamContractError))
+      end
+
+      it "getting valid type for second val" do
+        expect(Person.new("bob").name_rw_2)
+          .to(eq("bob"))
+      end
+
+      it "getting invalid type for second val" do
+        expect { Person.new(1.2).name_rw_2 }
+          .to(raise_error(ReturnContractError))
+      end
+
+      it "setting valid type for second val" do
+        expect(Person.new("bob").name_rw_2 = "alice")
+          .to(eq("alice"))
+      end
+
+      it "setting invalid type for second val" do
+        expect { Person.new("bob").name_rw_2 = 1.2 }
+          .to(raise_error(ParamContractError))
+      end
+    end
+  end
+end

data/spec/builtin_contracts_spec.rb

@@ -3,278 +3,304 @@ RSpec.describe "Contracts:" do
     @o = GenericExample.new
   end
 
+  def fails(&some)
+    expect { some.call }.to raise_error(ContractError)
+  end
+
+  def passes(&some)
+    expect { some.call }.to_not raise_error
+  end
+
+  describe "DescendantOf:" do
+    it "should pass for Array" do
+      passes { @o.enumerable_descendant_test(Array) }
+    end
+
+    it "should pass for a hash" do
+      passes { @o.enumerable_descendant_test(Hash) }
+    end
+
+    it "should fail for a number class" do
+      fails { @o.enumerable_descendant_test(Integer) }
+    end
+
+    it "should fail for a non-class" do
+      fails { @o.enumerable_descendant_test(1) }
+    end
+  end
+
   describe "Num:" do
     it "should pass for Fixnums" do
-      expect { @o.double(2) }.to_not raise_error
+      passes { @o.double(2) }
     end
 
     it "should pass for Floats" do
-      expect { @o.double(2.2) }.to_not raise_error
+      passes { @o.double(2.2) }
     end
 
     it "should fail for nil and other data types" do
-      expect { @o.double(nil) }.to raise_error(ContractError)
-      expect { @o.double(:x)  }.to raise_error(ContractError)
-      expect { @o.double("x") }.to raise_error(ContractError)
-      expect { @o.double(/x/) }.to raise_error(ContractError)
+      fails { @o.double(nil) }
+      fails { @o.double(:x) }
+      fails { @o.double("x") }
+      fails { @o.double(/x/) }
     end
   end
 
   describe "Pos:" do
     it "should pass for positive numbers" do
-      expect { @o.pos_test(1) }.to_not raise_error
-      expect { @o.pos_test(1.6) }.to_not raise_error
+      passes { @o.pos_test(1) }
+      passes { @o.pos_test(1.6) }
     end
 
     it "should fail for 0" do
-      expect { @o.pos_test(0) }.to raise_error(ContractError)
+      fails { @o.pos_test(0) }
     end
 
     it "should fail for negative numbers" do
-      expect { @o.pos_test(-1) }.to raise_error(ContractError)
-      expect { @o.pos_test(-1.6) }.to raise_error(ContractError)
+      fails { @o.pos_test(-1) }
+      fails { @o.pos_test(-1.6) }
     end
 
     it "should fail for nil and other data types" do
-      expect { @o.pos_test(nil) }.to raise_error(ContractError)
-      expect { @o.pos_test(:x)  }.to raise_error(ContractError)
-      expect { @o.pos_test("x") }.to raise_error(ContractError)
-      expect { @o.pos_test(/x/) }.to raise_error(ContractError)
+      fails { @o.pos_test(nil) }
+      fails { @o.pos_test(:x)  }
+      fails { @o.pos_test("x") }
+      fails { @o.pos_test(/x/) }
     end
   end
 
   describe "Neg:" do
     it "should pass for negative numbers" do
-      expect { @o.neg_test(-1) }.to_not raise_error
-      expect { @o.neg_test(-1.6) }.to_not raise_error
+      passes { @o.neg_test(-1) }
+      passes { @o.neg_test(-1.6) }
     end
 
     it "should fail for 0" do
-      expect { @o.neg_test(0) }.to raise_error(ContractError)
+      fails { @o.neg_test(0) }
     end
 
     it "should fail for positive numbers" do
-      expect { @o.neg_test(1) }.to raise_error(ContractError)
-      expect { @o.neg_test(1.6) }.to raise_error(ContractError)
+      fails { @o.neg_test(1) }
+      fails { @o.neg_test(1.6) }
     end
 
     it "should fail for nil and other data types" do
-      expect { @o.neg_test(nil) }.to raise_error(ContractError)
-      expect { @o.neg_test(:x)  }.to raise_error(ContractError)
-      expect { @o.neg_test("x") }.to raise_error(ContractError)
-      expect { @o.neg_test(/x/) }.to raise_error(ContractError)
+      fails { @o.neg_test(nil) }
+      fails { @o.neg_test(:x)  }
+      fails { @o.neg_test("x") }
+      fails { @o.neg_test(/x/) }
     end
   end
 
   describe "Nat:" do
     it "should pass for 0" do
-      expect { @o.nat_test(0) }.to_not raise_error
+      passes { @o.nat_test(0) }
     end
 
     it "should pass for positive whole numbers" do
-      expect { @o.nat_test(1) }.to_not raise_error
+      passes { @o.nat_test(1) }
     end
 
     it "should fail for positive non-whole numbers" do
-      expect { @o.nat_test(1.5) }.to raise_error(ContractError)
+      fails { @o.nat_test(1.5) }
     end
 
     it "should fail for negative numbers" do
-      expect { @o.nat_test(-1) }.to raise_error(ContractError)
-      expect { @o.nat_test(-1.6) }.to raise_error(ContractError)
+      fails { @o.nat_test(-1) }
+      fails { @o.nat_test(-1.6) }
     end
 
     it "should fail for nil and other data types" do
-      expect { @o.nat_test(nil) }.to raise_error(ContractError)
-      expect { @o.nat_test(:x)  }.to raise_error(ContractError)
-      expect { @o.nat_test("x") }.to raise_error(ContractError)
-      expect { @o.nat_test(/x/) }.to raise_error(ContractError)
+      fails { @o.nat_test(nil) }
+      fails { @o.nat_test(:x)  }
+      fails { @o.nat_test("x") }
+      fails { @o.nat_test(/x/) }
     end
   end
 
   describe "Any:" do
     it "should pass for numbers" do
-      expect { @o.show(1) }.to_not raise_error
+      passes { @o.show(1) }
     end
     it "should pass for strings" do
-      expect { @o.show("bad") }.to_not raise_error
+      passes { @o.show("bad") }
     end
     it "should pass for procs" do
-      expect { @o.show(lambda {}) }.to_not raise_error
+      passes { @o.show(lambda {}) }
     end
     it "should pass for nil" do
-      expect { @o.show(nil) }.to_not raise_error
+      passes { @o.show(nil) }
     end
   end
 
   describe "None:" do
     it "should fail for numbers" do
-      expect { @o.fail_all(1) }.to raise_error(ContractError)
+      fails { @o.fail_all(1) }
     end
     it "should fail for strings" do
-      expect { @o.fail_all("bad") }.to raise_error(ContractError)
+      fails { @o.fail_all("bad") }
     end
     it "should fail for procs" do
-      expect { @o.fail_all(lambda {}) }.to raise_error(ContractError)
+      fails { @o.fail_all(lambda {}) }
     end
     it "should fail for nil" do
-      expect { @o.fail_all(nil) }.to raise_error(ContractError)
+      fails { @o.fail_all(nil) }
     end
   end
 
   describe "Or:" do
     it "should pass for nums" do
-      expect { @o.num_or_string(1) }.to_not raise_error
+      passes { @o.num_or_string(1) }
     end
 
     it "should pass for strings" do
-      expect { @o.num_or_string("bad") }.to_not raise_error
+      passes { @o.num_or_string("bad") }
     end
 
     it "should fail for nil" do
-      expect { @o.num_or_string(nil) }.to raise_error(ContractError)
+      fails { @o.num_or_string(nil) }
     end
   end
 
   describe "Xor:" do
     it "should pass for an object with a method :good" do
-      expect { @o.xor_test(A.new) }.to_not raise_error
+      passes { @o.xor_test(A.new) }
     end
 
     it "should pass for an object with a method :bad" do
-      expect { @o.xor_test(B.new) }.to_not raise_error
+      passes { @o.xor_test(B.new) }
     end
 
     it "should fail for an object with neither method" do
-      expect { @o.xor_test(1) }.to raise_error(ContractError)
+      fails { @o.xor_test(1) }
     end
 
     it "should fail for an object with both methods :good and :bad" do
-      expect { @o.xor_test(F.new) }.to raise_error(ContractError)
+      fails { @o.xor_test(F.new) }
     end
   end
 
   describe "And:" do
     it "should pass for an object of class A that has a method :good" do
-      expect { @o.and_test(A.new) }.to_not raise_error
+      passes { @o.and_test(A.new) }
     end
 
     it "should fail for an object that has a method :good but isn't of class A" do
-      expect { @o.and_test(F.new) }.to raise_error(ContractError)
+      fails { @o.and_test(F.new) }
     end
   end
 
   describe "Enum:" do
     it "should pass for an object that is included" do
-      expect { @o.enum_test(:a) }.to_not raise_error
+      passes { @o.enum_test(:a) }
     end
 
     it "should fail for an object that is not included" do
-      expect { @o.enum_test(:z) }.to raise_error(ContractError)
+      fails { @o.enum_test(:z) }
     end
   end
 
   describe "RespondTo:" do
     it "should pass for an object that responds to :good" do
-      expect { @o.responds_test(A.new) }.to_not raise_error
+      passes { @o.responds_test(A.new) }
     end
 
     it "should fail for an object that doesn't respond to :good" do
-      expect { @o.responds_test(B.new) }.to raise_error(ContractError)
+      fails { @o.responds_test(B.new) }
     end
   end
 
   describe "Send:" do
     it "should pass for an object that returns true for method :good" do
-      expect { @o.send_test(A.new) }.to_not raise_error
+      passes { @o.send_test(A.new) }
     end
 
     it "should fail for an object that returns false for method :good" do
-      expect { @o.send_test(F.new) }.to raise_error(ContractError)
+      fails { @o.send_test(F.new) }
     end
   end
 
   describe "Exactly:" do
     it "should pass for an object that is exactly a Parent" do
-      expect { @o.exactly_test(Parent.new) }.to_not raise_error
+      passes { @o.exactly_test(Parent.new) }
     end
 
     it "should fail for an object that inherits from Parent" do
-      expect { @o.exactly_test(Child.new) }.to raise_error(ContractError)
+      fails { @o.exactly_test(Child.new) }
     end
 
     it "should fail for an object that is not related to Parent at all" do
-      expect { @o.exactly_test(A.new) }.to raise_error(ContractError)
+      fails { @o.exactly_test(A.new) }
     end
   end
 
   describe "Eq:" do
     it "should pass for a class" do
-      expect { @o.eq_class_test(Foo) }
+      passes { @o.eq_class_test(Foo) }
     end
 
     it "should pass for a module" do
-      expect { @o.eq_module_test(Bar) }
+      passes { @o.eq_module_test(Bar) }
     end
 
     it "should pass for other values" do
-      expect { @o.eq_value_test(Baz) }
+      passes { @o.eq_value_test(Baz) }
     end
 
     it "should fail when not equal" do
-      expect { @o.eq_class_test(Bar) }.to raise_error(ContractError)
+      fails { @o.eq_class_test(Bar) }
     end
 
     it "should fail when given instance of class" do
-      expect { @o.eq_class_test(Foo.new) }.to raise_error(ContractError)
+      fails { @o.eq_class_test(Foo.new) }
     end
   end
 
   describe "Not:" do
     it "should pass for an argument that isn't nil" do
-      expect { @o.not_nil(1) }.to_not raise_error
+      passes { @o.not_nil(1) }
     end
 
     it "should fail for nil" do
-      expect { @o.not_nil(nil) }.to raise_error(ContractError)
+      fails { @o.not_nil(nil) }
     end
   end
 
   describe "ArrayOf:" do
     it "should pass for an array of nums" do
-      expect { @o.product([1, 2, 3]) }.to_not raise_error
+      passes { @o.product([1, 2, 3]) }
     end
 
     it "should fail for an array with one non-num" do
-      expect { @o.product([1, 2, 3, "bad"]) }.to raise_error(ContractError)
+      fails { @o.product([1, 2, 3, "bad"]) }
     end
 
     it "should fail for a non-array" do
-      expect { @o.product(1) }.to raise_error(ContractError)
+      fails { @o.product(1) }
     end
   end
 
   describe "RangeOf:" do
     require "date"
     it "should pass for a range of nums" do
-      expect { @o.first_in_range_num(3..10) }.to_not raise_error
+      passes { @o.first_in_range_num(3..10) }
     end
 
     it "should pass for a range of dates" do
       d1 = Date.today
       d2 = d1 + 18
-      expect { @o.first_in_range_date(d1..d2) }.to_not raise_error
+      passes { @o.first_in_range_date(d1..d2) }
     end
 
     it "should fail for a non-range" do
-      expect { @o.first_in_range_num("foo") }.to raise_error(ContractError)
-      expect { @o.first_in_range_num(:foo) }.to raise_error(ContractError)
-      expect { @o.first_in_range_num(5) }.to raise_error(ContractError)
-      expect { @o.first_in_range_num(nil) }.to raise_error(ContractError)
+      fails { @o.first_in_range_num("foo") }
+      fails { @o.first_in_range_num(:foo) }
+      fails { @o.first_in_range_num(5) }
+      fails { @o.first_in_range_num(nil) }
     end
 
     it "should fail for a range with incorrect data type" do
-      expect { @o.first_in_range_num("a".."z") }.to raise_error(ContractError)
+      fails { @o.first_in_range_num("a".."z") }
     end
 
     it "should fail for a badly-defined range" do
@@ -284,8 +310,8 @@ RSpec.describe "Contracts:" do
       # This test guards against ranges with inconsistent data types.
       begin
         d1 = Date.today
-        expect { @o.first_in_range_date(d1..10).to raise_error(ContractError) }
-        expect { @o.first_in_range_num(d1..10).to raise_error(ContractError) }
+        fails { @o.first_in_range_date(d1..10) }
+        fails { @o.first_in_range_num(d1..10) }
       rescue ArgumentError
         # If Ruby doesn't like the range, we ignore the test.
         :nop
@@ -295,26 +321,26 @@ RSpec.describe "Contracts:" do
 
   describe "SetOf:" do
     it "should pass for a set of nums" do
-      expect { @o.product_from_set(Set.new([1, 2, 3])) }.to_not raise_error
+      passes { @o.product_from_set(Set.new([1, 2, 3])) }
     end
 
     it "should fail for an array with one non-num" do
-      expect { @o.product_from_set(Set.new([1, 2, 3, "bad"])) }.to raise_error(ContractError)
+      fails { @o.product_from_set(Set.new([1, 2, 3, "bad"])) }
     end
 
     it "should fail for a non-array" do
-      expect { @o.product_from_set(1) }.to raise_error(ContractError)
+      fails { @o.product_from_set(1) }
     end
   end
 
   describe "Bool:" do
     it "should pass for an argument that is a boolean" do
-      expect { @o.bool_test(true) }.to_not raise_error
-      expect { @o.bool_test(false) }.to_not raise_error
+      passes { @o.bool_test(true) }
+      passes { @o.bool_test(false) }
     end
 
     it "should fail for nil" do
-      expect { @o.bool_test(nil) }.to raise_error(ContractError)
+      fails { @o.bool_test(nil) }
     end
   end
 
@@ -328,27 +354,27 @@ RSpec.describe "Contracts:" do
     end
 
     it "should fail for strings" do
-      expect { @o.maybe_double("foo") }.to raise_error(ContractError)
+      fails { @o.maybe_double("foo") }
     end
   end
 
   describe "KeywordArgs:" do
     it "should pass for exact correct input" do
-      expect { @o.person_keywordargs(:name => "calvin", :age => 10) }.to_not raise_error
+      passes { @o.person_keywordargs(:name => "calvin", :age => 10) }
     end
 
     it "should fail if some keys don't have contracts" do
-      expect { @o.person_keywordargs(:name => "calvin", :age => 10, :foo => "bar") }.to raise_error(ContractError)
+      fails { @o.person_keywordargs(:name => "calvin", :age => 10, :foo => "bar") }
     end
 
     it "should fail if a key with a contract on it isn't provided" do
-      expect { @o.person_keywordargs(:name => "calvin") }.to raise_error(ContractError)
+      fails { @o.person_keywordargs(:name => "calvin") }
     end
 
     it "should fail for incorrect input" do
-      expect { @o.person_keywordargs(:name => 50, :age => 10) }.to raise_error(ContractError)
-      expect { @o.hash_keywordargs(:hash => nil) }.to raise_error(ContractError)
-      expect { @o.hash_keywordargs(:hash => 1) }.to raise_error(ContractError)
+      fails { @o.person_keywordargs(:name => 50, :age => 10) }
+      fails { @o.hash_keywordargs(:hash => nil) }
+      fails { @o.hash_keywordargs(:hash => 1) }
     end
   end
 
@@ -375,15 +401,15 @@ RSpec.describe "Contracts:" do
     end
 
     context "given a fulfilled contract" do
-      it { expect(@o.gives_max_value(:panda => 1, :bamboo => 2)).to eq(2) }
-      it { expect(@o.pretty_gives_max_value(:panda => 1, :bamboo => 2)).to eq(2) }
+      it { expect(@o.gives_max_value({ :panda => 1, :bamboo => 2 })).to eq(2) }
+      it { expect(@o.pretty_gives_max_value({ :panda => 1, :bamboo => 2 })).to eq(2) }
     end
 
     context "given an unfulfilled contract" do
-      it { expect { @o.gives_max_value(:panda => "1", :bamboo => "2") }.to raise_error(ContractError) }
-      it { expect { @o.gives_max_value(nil) }.to raise_error(ContractError) }
-      it { expect { @o.gives_max_value(1) }.to raise_error(ContractError) }
-      it { expect { @o.pretty_gives_max_value(:panda => "1", :bamboo => "2") }.to raise_error(ContractError) }
+      it { fails { @o.gives_max_value({ :panda => "1", :bamboo => "2" }) }  }
+      it { fails { @o.gives_max_value(nil) } }
+      it { fails { @o.gives_max_value(1) } }
+      it { fails { @o.pretty_gives_max_value({ :panda => "1", :bamboo => "2" }) } }
     end
 
     describe "#to_s" do
@@ -396,4 +422,36 @@ RSpec.describe "Contracts:" do
       end
     end
   end
+
+  describe "StrictHash:" do
+    context "when given an exact correct input" do
+      it "does not raise an error" do
+        passes { @o.strict_person({ :name => "calvin", :age => 10 }) }
+      end
+    end
+
+    context "when given an input with correct keys but wrong types" do
+      it "raises an error" do
+        fails { @o.strict_person({ :name => "calvin", :age => "10" }) }
+      end
+    end
+
+    context "when given an input with missing keys" do
+      it "raises an error" do
+        fails { @o.strict_person({ :name => "calvin" }) }
+      end
+    end
+
+    context "when given an input with extra keys" do
+      it "raises an error" do
+        fails { @o.strict_person({ :name => "calvin", :age => 10, :soft => true }) }
+      end
+    end
+
+    context "when given not a hash" do
+      it "raises an error" do
+        fails { @o.strict_person(1337) }
+      end
+    end
+  end
 end