oval 0.0.1

data/oval.gemspec

@@ -0,0 +1,19 @@
+lib = File.expand_path(File.join(File.dirname(__FILE__),'lib'))
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |gem|
+  gem.name          = 'oval'
+  gem.version       = '0.0.1'
+  gem.authors       = ["Pawel Tomulik"]
+  gem.email         = ["ptomulik@meil.pw.edu.pl"]
+  gem.description   = %q{Validate options when passed to methods}
+  gem.summary       = %q{Using hashes to pass options to methods is a very common ruby practice. With **Oval** method authors may restrict callers to pass only declared options that meet requirements described in a hash declaration.}
+  gem.homepage      = "https://github.com/ptomulik/rubygems-oval"
+  gem.license       = "Apache 2.0"
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = []
+  gem.test_files    = gem.files.grep(/^(test|spec|features)/)
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency "rake"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+if RUBY_VERSION >= "1.9"
+  require 'coveralls'
+  Coveralls.wear! do
+    add_filter 'spec/'
+  end
+end
+
+RSpec.configure do |config|
+  config.mock_framework = :mocha
+end
+
+#
+#require 'puppetlabs_spec_helper/module_spec_helper'

data/spec/unit/oval/anything_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'oval/anything'
+describe Oval::Anything do
+  let(:subject) { described_class.instance }
+  context 'the class' do
+    it { described_class.should respond_to :instance }
+    it { described_class.should respond_to :[] }
+    it { described_class.should_not respond_to :new }
+  end
+  context 'an instance' do
+    it { should respond_to :validate }
+  end
+  describe "instance (i.e. class method called instance)" do
+    it "should return singleton" do
+      previous = described_class.instance
+      described_class.instance.should be previous
+    end
+  end
+  describe "[]" do
+    it "should == #{described_class}.instance" do
+      described_class.stubs(:instance).once.with().returns :ok
+      described_class[].should be :ok
+    end
+  end
+  describe "#validate" do
+    # It should accept anything, which is quite hard to test, so I put here
+    # some random stuff ...
+    [
+      :symbol, nil, 1, 2.1, '', Array, NilClass, Object, Module,
+      Class.new, /regex/
+    ].each do |x|
+      context "validate(#{x.inspect})" do
+        let(:x) { x }
+        it { expect { subject.validate(x) }.to_not raise_error }
+      end
+    end
+  end
+end

data/spec/unit/oval/array_item_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper.rb'
+require 'oval/array_item.rb'
+
+describe Oval::ArrayItem do
+  context 'the class' do
+    it { described_class.should respond_to :[] }
+  end
+  context 'an instance' do
+    let(:subject) { described_class[:item_decl0] }
+    it { should respond_to :validate }
+    it { should respond_to :item_decl }
+  end
+
+  describe "[]" do
+    context "#{described_class.name}[:item_decl0]" do
+      it "should == new(:item_decl0)" do
+        described_class.stubs(:new).once.with(:item_decl0).returns :ok
+        described_class[:item_decl0].should be :ok
+      end
+    end
+  end
+
+  describe "item_decl" do
+    let(:subject) { described_class[:item_decl0] }
+    context "#{described_class.name}[:item_decl0].item_decl" do
+      it { subject.item_decl.should be :item_decl0 }
+    end
+    context "when @item_decl = :item_decl1" do
+      before { subject.instance_variable_set(:@item_decl, :item_decl1) }
+      it { subject.item_decl.should be :item_decl1 }
+    end
+  end
+
+  describe "item_decl=" do
+    let(:subject) { described_class[:item_decl0] }
+    context "item_decl = :item_decl1" do
+      it "should assign @item_decl = :item_decl1" do
+        subject.send(:item_decl=, :item_decl1)
+        subject.instance_variable_get(:@item_decl).should be :item_decl1
+      end
+    end
+  end
+
+  describe "#validate" do
+    let(:subject) { described_class[:item_decl0] }
+    context "validate(:item1,0)" do
+      it 'should invoke self.class.ensure_match(:item1,:item_decl0,nil) once' do
+        described_class.expects(:ensure_match).once.with(:item1,:item_decl0,nil)
+        subject.validate(:item1,0)
+      end
+    end
+    context "validate(:item1,0,'foo')" do
+      it 'should invoke self.class.ensure_match(:item1,:item_decl0,"foo[0]") once' do
+        described_class.expects(:ensure_match).once.with(:item1,:item_decl0,"foo[0]")
+        subject.validate(:item1,0,'foo')
+      end
+    end
+  end
+end
+

data/spec/unit/oval/base_spec.rb

@@ -0,0 +1,184 @@
+require 'spec_helper'
+require 'oval/base'
+
+describe Oval::Base do
+  context "the class" do
+    [
+      :ensure_equal,
+      :ensure_match,
+      :[],
+      :for_subject,
+      :enumerate,
+    ].each do |method|
+      it { described_class.should respond_to method }
+    end
+  end
+
+  context "an instance" do
+    let(:subject) { described_class[:shape0] }
+    [
+      :validate,
+      :for_subject,
+      :enumerate,
+    ].each do |method|
+      it { should respond_to method }
+    end
+  end
+
+  describe "ensure_match" do
+    context "ensure_match(:foo,:bar)" do
+      it "should invoke ensure_equal(:foo,:bar,nil) once" do
+        described_class.expects(:ensure_equal).once.with(:foo,:bar,nil)
+        expect { described_class.ensure_match(:foo,:bar) }.to_not raise_error
+      end
+    end
+    context "ensure_match(:foo,:bar,'subj1')" do
+      it "should invoke ensure_equal(:foo,:bar,'subj1') once" do
+        described_class.expects(:ensure_equal).once.with(:foo,:bar,'subj1')
+        expect { described_class.ensure_match(:foo,:bar,'subj1') }.to_not raise_error
+      end
+    end
+    context "ensure_match(:foo,shape)" do
+      let(:shape) { described_class[:shape0] }
+      it "should invoke shape.validate(:foo,nil) once" do
+        shape.expects(:validate).once.with(:foo,nil)
+        expect { described_class.ensure_match(:foo,shape) }.to_not raise_error
+      end
+    end
+    context "ensure_match(:foo,shape,'subj1')" do
+      let(:shape) { described_class[:shape0] }
+      it "should invoke shape.validate(:foo,'subj1') once" do
+        shape.expects(:validate).once.with(:foo,'subj1')
+        expect { described_class.ensure_match(:foo,shape,'subj1') }.to_not raise_error
+      end
+    end
+  end
+
+  describe "[]" do
+    [ [], [:arg1], [:arg1,:arg2] ].each do |args|
+      context "[#{args.map{|x| x.inspect}.join(', ')}]" do
+        let(:args) { args }
+        it "should == new(#{args.map{|x| x.inspect}.join(', ')})" do
+          described_class.expects(:new).once.with(*args).returns :ok
+          described_class[*args].should be :ok
+        end
+      end
+    end
+  end
+
+  describe "#validate" do
+    let(:subject) { described_class[:shape0] }
+    let(:msg) { "This method should be overwritten by a subclass" }
+    [ [], [:arg1,:arg2,:arg3] ].each do |args|
+      context "validate(#{args.map{|x| x.inspect}.join(', ')})" do
+        let(:args) { args }
+        before { described_class.expects(:validate).never }
+        it { expect { subject.validate(*args) }.to raise_error ArgumentError }
+      end
+    end
+    context "validate(:value)" do
+      it { expect { subject.validate(:value) }.to raise_error NotImplementedError, msg}
+    end
+    context "validate(:value,:subj1)" do
+      it { expect { subject.validate(:value,:subj1) }.to raise_error NotImplementedError, msg}
+    end
+  end
+
+##  describe "#validate_shape" do
+##    let(:subject) { described_class[:shape0] }
+##    let(:msg) { "This method should be overwritten by a subclass" }
+##    [ [:arg1,:arg2] ].each do |args|
+##      context "validate_shape(#{args.map{|x| x.inspect}.join(', ')})" do
+##        let(:args) { args }
+##        it { expect { subject.validate_shape(*args) }.to raise_error ArgumentError }
+##      end
+##    end
+##    context "validate_shape()" do
+##      it { expect { subject.validate_shape() }.to raise_error NotImplementedError, msg}
+##    end
+##    context "validate_shape(:subj1)" do
+##      it { expect { subject.validate_shape(:subj1) }.to raise_error NotImplementedError, msg}
+##    end
+##  end
+
+
+##  describe "shape" do
+####    before { described_class.stubs(:validate_shape) }
+##    context "new(:shape0).shape" do
+##      it { described_class.new(:shape0).shape.should be :shape0 }
+##    end
+##    context "when @shape == :shape1" do
+##      let(:subject) { described_class.new(:shape0) }
+##      before { subject.instance_variable_set(:@shape,:shape1) }
+##      it { subject.shape.should be :shape1 }
+##    end
+##  end
+##
+##  describe "#shape=" do
+####    before { described_class.stubs(:validate_shape) }
+##    let(:subject) { described_class.new(:shape0) }
+##    context "#shape = :shape1" do
+####      it "should call self.class.validate_shape(:shape1) once" do
+####        subject # reference before re-stubbing validate_shape
+####        described_class.stubs(:validate_shape).never
+####        described_class.stubs(:validate_shape).once.with(:shape1,'Base')
+####        expect { subject.send(:shape=,:shape1) }.to_not raise_error
+####      end
+##      it "should assign @shape = :shape1" do
+##        subject.send(:shape=, :shape1)
+##        subject.instance_variable_get(:@shape).should be :shape1
+##      end
+##    end
+##  end
+
+  describe "for_subject" do
+    [
+      [nil,""],
+      ["Subj1", " for Subj1"],
+      [:subj, " for subj"],
+    ].each do |arg,res|
+      context "for_subject(#{arg.inspect})" do
+        let(:arg) { arg }
+        let(:res) { res }
+        it { described_class.send(:for_subject,arg).should == res }
+      end
+    end
+  end
+
+  describe "#for_subject" do
+##    before { described_class.stubs(:validate_shape) }
+    let(:subject) { described_class.new(:shape0) }
+    context "for_subject(:subj1)" do
+      it "should == self.class.for_subject(subject)" do
+        described_class.expects(:for_subject).once.with(:subj1).returns :ok
+        subject.send(:for_subject,:subj1).should be :ok
+      end
+    end
+  end
+
+  describe "enumerate" do
+    [
+      [[[],'and'],'none'],
+      [[['one'],'and'],'"one"'],
+      [[['one','two'],'and'],'"one" and "two"'],
+      [[['one','two','three'],'and'],'"one", "two" and "three"'],
+    ].each do |args,res|
+      context "enumerate(#{args.map{|x| x.inspect}.join(', ')})" do
+        let(:args) { args }
+        let(:res) { res }
+        it { described_class.send(:enumerate,*args).should == res }
+      end
+    end
+  end
+
+  describe "#enumerate" do
+##    before { described_class.stubs(:validate_shape) }
+    let(:subject) { described_class.new(:shape0) }
+    context "enumerate([],'and')" do
+      it "should == self.class.enumerate(subject)" do
+        described_class.expects(:enumerate).once.with([],'and').returns :ok
+        subject.send(:enumerate,[],'and').should be :ok
+      end
+    end
+  end
+end

data/spec/unit/oval/class_decl_base_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+require 'oval/class_decl_base'
+
+describe Oval::ClassDeclBase do
+  context "the class" do
+    [
+      :[],
+    ].each do |method|
+      it { described_class.should respond_to method }
+    end
+  end
+
+  context "an instance" do
+    let(:subject) { described_class[:klass0] }
+    before { described_class.any_instance.stubs(:validate_class) }
+    it { should be_kind_of Oval::Base }
+    [
+      :validate_class,
+      :klass,
+      :klass=,
+    ].each do |method|
+      it { should respond_to method }
+    end
+  end
+
+  describe "#validate_class" do
+    let(:subject) { described_class.new(:klass0) }
+    before do
+      described_class.any_instance.stubs(:validate_class)
+      subject
+      described_class.any_instance.unstub(:validate_class)
+    end
+    context "validate_class(:symbol1)" do
+      let(:msg) { "Invalid class :symbol1 for ClassDeclBase" }
+      it { expect { subject.send(:validate_class,:symbol1) }.to raise_error Oval::DeclError, msg }
+    end
+    [ Array, String, NilClass ].each do |klass|
+      context "validate_class(#{klass.name})" do
+        let(:klass) { klass }
+        it { expect { subject.send(:validate_class,klass) }.to_not raise_error }
+      end
+    end
+  end
+
+  describe "klass" do
+    before { described_class.any_instance.stubs(:validate_class) }
+    context "new(:klass0).klass" do
+      it { described_class.new(:klass0).klass.should be :klass0 }
+    end
+    context "when @klass == :klass1" do
+      let(:subject) { described_class.new(:klass0) }
+      before { subject.instance_variable_set(:@klass,:klass1) }
+      it { subject.klass.should be :klass1 }
+    end
+  end
+
+  describe "#klass=" do
+    before { described_class.any_instance.stubs(:validate_class) }
+    let(:subject) { described_class.new(:klass0) }
+    context "#klass = :klass1" do
+      it "should call self.class.validate_class(:klass1) once" do
+        subject # reference before re-stubbing validate_class
+        subject.stubs(:validate_class).never
+        subject.stubs(:validate_class).once.with(:klass1)
+        expect { subject.send(:klass=,:klass1) }.to_not raise_error
+      end
+      it "should assign @klass = :klass1" do
+        subject.send(:klass=, :klass1)
+        subject.instance_variable_get(:@klass).should be :klass1
+      end
+    end
+  end
+end

data/spec/unit/oval/collection_spec.rb

@@ -0,0 +1,267 @@
+require 'spec_helper'
+require 'oval/collection'
+require 'oval/one_of'
+require 'oval/instance_of'
+require 'oval/kind_of'
+
+describe Oval::Collection do
+##  Anything = Oval::Anything
+##  SubclassOf = Oval::SubclassOf
+##  InstanceOf = Oval::InstanceOf
+##  KindOf = Oval::KindOf
+##  OneOf = Oval::OneOf
+##  DeclError = Oval::DeclError
+##  ValueError = Oval::ValueError
+  describe 'the class' do
+    it { described_class.should respond_to :[] }
+    it { described_class.should respond_to :new }
+    it { described_class.should respond_to :validate_class_decl }
+  end
+  describe 'an instance' do
+    let(:subject)  { described_class[Array,nil] }
+    it { should respond_to :validate }
+    it { should respond_to :class_decl }
+    it { should respond_to :class_decl= }
+    it { should respond_to :item_decl }
+    it { should respond_to :item_decl= }
+    it { should respond_to :select_item_validator }
+  end
+
+  describe "[]" do
+    context "[]" do
+      it { expect { described_class[] }.to raise_error ArgumentError, /wrong number of arguments / }
+    end
+    context "[:arg1,:arg2,:arg3]" do
+      it { expect { described_class[:arg1,:arg2,:arg3] }.to raise_error ArgumentError, /wrong number of arguments / }
+    end
+    context "[:arg1]" do
+      it "should == new(:arg1,Oval::Anything[])" do
+        described_class.expects(:new).once.with(:arg1,Oval::Anything[]).returns :ok
+        described_class[:arg1].should be :ok
+      end
+    end
+    context "[:arg1,:arg2]" do
+      it "should == new(:arg1,:arg2)" do
+        described_class.expects(:new).once.with(:arg1,:arg2).returns :ok
+        described_class[:arg1,:arg2].should be :ok
+      end
+    end
+  end
+
+  describe "new" do
+    context "new(:arg1,:arg2)" do
+      it "should assign self.class_decl=:arg1 and self.item_decl=:arg2 in seqence" do
+        seq = sequence('assignments')
+        described_class.any_instance.expects(:class_decl=).once.with(:arg1).in_sequence(seq)
+        described_class.any_instance.expects(:item_decl=).once.with(:arg2).in_sequence(seq)
+        expect { described_class.new(:arg1,:arg2) }.to_not raise_error
+      end
+    end
+  end
+
+  describe "validate_class_decl" do
+    [
+      [Array, "Array"],
+      [Hash, "Hash" ],
+      [Class.new(Array), "Class.new(Array)" ],
+      [Class.new(Hash), "Class.new(Hash)" ],
+      [Oval::SubclassOf[Array], "Oval::SubclassOf[Array]" ],
+      [Oval::SubclassOf[Hash], "Oval::SubclassOf[Hash]" ],
+      [Oval::SubclassOf[Class.new(Array)], "Oval::SubclassOf[Class.new(Array)]" ],
+      [Oval::SubclassOf[Class.new(Hash)], "Oval::SubclassOf[Class.new(Hash)]" ],
+    ].each do |decl,desc|
+      context "validate_class_decl(#{desc})" do
+        let(:decl) { decl }
+        it { expect { described_class.validate_class_decl(decl) }.to_not raise_error }
+      end
+    end
+    [ 'a', nil, 0, {}, [] ].each do |decl|
+      context "validate_class_decl(#{decl.inspect})" do
+        let(:decl) { decl }
+        let(:msg) { "Invalid collection class declarator #{decl.inspect}. Should be a (subclass of) Hash or Array" }
+        it { expect { described_class.validate_class_decl(decl) }.to raise_error Oval::DeclError, msg }
+      end
+    end
+  end
+
+##  describe "validate_item_decl" do
+##    [
+##      [Hash, "Hash"],
+##      [Class.new(Hash), "Class.new(Hash)" ],
+##    ].each do |class_decl,class_desc|
+##      context "validate_item_decl(:decl1, #{class_desc})" do
+##        let(:class_decl) { class_decl }
+##        it "should invoke validate_hash_item_decl(:decl1) once" do
+##          described_class.stubs(:validate_hash_item_decl).once.with(:decl1)
+##          expect { described_class.validate_item_decl(:decl1,class_decl) }.to_not raise_error
+##        end
+##      end
+##    end
+##    [
+##      [Array, "Array"],
+##      [Class.new(Array), "Class.new(Array)" ],
+##    ].each do |class_decl,class_desc|
+##      context "validate_item_decl(:decl1, #{class_desc})" do
+##        let(:class_decl) { class_decl }
+##        it "should not invoke validate_hash_item_decl(:decl1)" do
+##          described_class.stubs(:validate_hash_item_decl).never
+##          expect { described_class.validate_item_decl(:decl1,class_decl) }.to_not raise_error
+##        end
+##      end
+##    end
+##  end
+
+  describe "#class_decl" do
+    before do
+      described_class.stubs(:validate_class_decl)
+      described_class.any_instance.stubs(:item_decl=)
+    end
+    context "new(:class_decl0,:item_decl0).class_decl" do
+      it { described_class.new(:class_decl0,:item_decl0).class_decl.should be :class_decl0 }
+    end
+    context "when @class_decl == :class_decl1" do
+      let(:subject) { described_class.new(:class_decl0) }
+      before { subject.instance_variable_set(:@class_decl,:class_decl1) }
+      it { subject.class_decl.should be :class_decl1 }
+    end
+  end
+
+  describe "#class_decl=" do
+    before do
+      described_class.stubs(:validate_class_decl)
+      described_class.any_instance.stubs(:item_decl=)
+    end
+    let(:subject) { described_class.new(:class_decl0,:item_decl0) }
+    context "#class_decl = :class_decl1" do
+      it "should call self.class.validate_class_decl(:class_decl1) once" do
+        subject # reference before re-stubbing validate_class_decl
+        described_class.stubs(:validate_class_decl).never
+        described_class.stubs(:validate_class_decl).once.with(:class_decl1)
+        expect { subject.send(:class_decl=,:class_decl1) }.to_not raise_error
+      end
+      it "should assign @class_decl = :class_decl1" do
+        subject.send(:class_decl=, :class_decl1)
+        subject.instance_variable_get(:@class_decl).should be :class_decl1
+      end
+    end
+  end
+
+  describe "#item_decl" do
+    before do
+      described_class.any_instance.stubs(:class_decl=)
+      described_class.any_instance.stubs(:bind_item_validator)
+    end
+    context "new(:class_decl0, :item_decl0).item_decl" do
+      it { described_class.new(:class_decl0,:item_decl0).item_decl.should be :item_decl0 }
+    end
+    context "when @item_decl == :item_decl1" do
+      let(:subject) { described_class.new(:item_decl0) }
+      before { subject.instance_variable_set(:@item_decl,:item_decl1) }
+      it { subject.item_decl.should be :item_decl1 }
+    end
+  end
+
+  describe "#item_decl=" do
+    let(:subject) { described_class.new(:class_decl0,:item_decl0) }
+    before do
+      described_class.any_instance.stubs(:class_decl=)
+      described_class.any_instance.stubs(:bind_item_validator)
+    end
+    context "#item_decl = :item_decl1" do
+      it "should call bind_item_validator(:item_decl1) once" do
+        subject.expects(:bind_item_validator).once.with(:item_decl1)
+        expect { subject.send(:item_decl=,:item_decl1) }.to_not raise_error
+      end
+      it "should assign @item_decl = :item_decl1" do
+        subject.send(:item_decl=, :item_decl1)
+        subject.instance_variable_get(:@item_decl).should be :item_decl1
+      end
+    end
+  end
+
+  describe "#select_item_validator" do
+    before do
+      described_class.any_instance.stubs(:class_decl=).once.with(:class_decl0)
+      described_class.any_instance.stubs(:item_decl=).once.with(:item_decl0)
+    end
+    let(:subject) { described_class.new(:class_decl0,:item_decl0) }
+    [
+      [Hash, 'Hash'],
+      [Class.new(Hash), 'Class.new(Hash)'],
+    ].each do |klass,desc|
+      context "when #klass == #{desc}" do
+        before { subject.stubs(:klass).with().returns(klass) }
+        it { subject.send(:select_item_validator).should be Oval::HashItem }
+      end
+    end
+    [
+      [Array, 'Array'],
+      [Class.new(Array), 'Class.new(Array)'],
+    ].each do |klass,desc|
+      context "when #klass == #{desc}" do
+        before { subject.stubs(:klass).with().returns(klass) }
+        it { subject.send(:select_item_validator).should be Oval::ArrayItem }
+      end
+    end
+    [ String, Fixnum, 1, nil, 0 ].each do |klass|
+      context "when #klass == #{klass.inspect}" do
+        before { subject.stubs(:klass).with().returns(klass) }
+        let(:msg) { "Invalid class #{klass.inspect} assigned to klass. It seems like we have a bug in #{described_class.name}" }
+        it { expect { subject.send(:select_item_validator) }.to raise_error RuntimeError, msg }
+      end
+    end
+  end
+
+  describe "#validate" do
+    class HashSubclass < Hash; end
+    class ArraySubclass < Array; end
+    # Valid collections
+    [
+      #
+      # Hash
+      #
+      ["Hash", Hash, Oval::Anything[], {:foo => :FOO}],
+      ["Hash", Hash, Oval::Anything, {:foo => :FOO}],
+      ["Hash", Hash, {Oval::Anything => Oval::Anything}, {:foo => :FOO}],
+      ["HashSubclass", HashSubclass, {Oval::Anything => Oval::Anything}, HashSubclass[{:foo => :FOO}]],
+      ["Oval::SubclassOf[Hash]", Oval::SubclassOf[Hash], {Oval::Anything => Oval::Anything}, HashSubclass[{:foo => :FOO}]],
+
+      ["Hash", Hash, {Oval::InstanceOf[Symbol] => Oval::InstanceOf[Symbol]}, {:foo => :FOO}],
+      ["Hash", Hash, {Oval::InstanceOf[String] => Oval::KindOf[Fixnum]}, {'one' => 1, 'two' => 2}],
+      #
+      # Array
+      #
+      ["Array", Array, Oval::Anything[], [:foo, :bar]],
+      ["Array", Array, Oval::Anything, [:foo,:bar]],
+      ["ArraySubclass", ArraySubclass, Oval::Anything, ArraySubclass[:foo,:bar]],
+      ["Oval::SubclassOf[Array]", Oval::SubclassOf[Array], Oval::Anything, ArraySubclass[:foo, :bar]],
+    ].each do |class_desc,class_decl,item_decl,collection|
+      context "#{described_class.name}[#{class_desc},#{item_decl.inspect}].validate(#{collection.inspect},'collection')" do
+        let(:subject) { described_class[class_decl, item_decl] }
+        let(:collection) { collection}
+        it { expect { subject.validate(collection,'collection') }.to_not raise_error }
+      end
+    end
+    # Invalid collections
+    [
+      ["Hash", Hash, {Oval::Anything => Oval::Anything}, :symbol, 'Invalid value Symbol for collection.class. Should be equal Hash'],
+      ["Hash", Hash, {Oval::Anything => Oval::Anything}, [], 'Invalid value Array for collection.class. Should be equal Hash'],
+      ["HashSubclass", HashSubclass, {Oval::Anything => Oval::Anything}, [], 'Invalid value Array for collection.class. Should be equal HashSubclass'],
+      ["HashSubclass", HashSubclass, {Oval::Anything => Oval::Anything}, {:foo => :FOO}, 'Invalid value Hash for collection.class. Should be equal HashSubclass'],
+      ["Array", Array, Oval::Anything, :symbol, 'Invalid value Symbol for collection.class. Should be equal Array'],
+      ["Array", Array, Oval::Anything, {}, 'Invalid value Hash for collection.class. Should be equal Array'],
+      ["ArraySubclass", ArraySubclass, Oval::Anything, {:foo => :FOO}, 'Invalid value Hash for collection.class. Should be equal ArraySubclass'],
+      ["ArraySubclass", ArraySubclass, Oval::Anything, [:foo, :bar], 'Invalid value Array for collection.class. Should be equal ArraySubclass'],
+      ["Hash", Hash, {Oval::InstanceOf[Symbol] => Oval::InstanceOf[Symbol]}, {:foo => :FOO, 'bar' => :BAR}, "Invalid object \"bar\" of type String for collection key. Should be an instance of Symbol"],
+      ["Hash", Hash, {Oval::InstanceOf[String] => Oval::KindOf[Fixnum]}, {'one' => 1, 'two' => :TWO}, "Invalid object :TWO of type Symbol for collection[\"two\"]. Should be a kind of Fixnum"],
+      ["Array", Array, Oval::InstanceOf[String], ['one', :two], "Invalid object :two of type Symbol for collection[1]. Should be an instance of String"],
+    ].each do |class_desc,class_decl,item_decl, collection, msg|
+      context "#{described_class.name}[#{class_desc},#{item_decl.inspect}].validate(#{collection.inspect},'collection')" do
+        let(:subject) { described_class[class_decl, item_decl] }
+        let(:collection) { collection }
+        let(:msg) { msg }
+        it { expect { subject.validate(collection,'collection') }.to raise_error Oval::ValueError, msg}
+      end
+    end
+  end
+end