oval 0.0.1

data/spec/unit/oval/hash_item_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+require 'oval/hash_item'
+require 'oval/instance_of'
+require 'oval/kind_of'
+
+describe Oval::HashItem do
+  context 'the class' do
+    it { described_class.should respond_to :[] }
+    it { described_class.should respond_to :validate_item_decl }
+  end
+  context 'an instance' do
+    let(:subject) { described_class[{:key_decl0 => :val_decl0}] }
+    it { should respond_to :validate }
+    it { should respond_to :key_decl }
+    it { should respond_to :val_decl }
+    it { subject.private_methods.map{|m| m.is_a?(Symbol) ? m : m.intern}.should include :item_decl= }
+  end
+
+  describe "[]" do
+    context "#{described_class.name}[{:key_decl0 => :val_decl0}]" do
+      it "should == new({:key_decl0 => :val_decl0})" do
+        described_class.stubs(:new).once.with({:key_decl0 => :val_decl0}).returns :ok
+        described_class[{:key_decl0 => :val_decl0}].should be :ok
+      end
+    end
+  end
+
+  describe "validate_item_decl" do
+    [ :foo, [], [:a, :b], {:a => :A, :b => :B}, {}, nil ].each do |decl|
+      context "validate_item_decl(#{decl.inspect})" do
+        let(:decl) { decl }
+        let(:msg) { "Invalid item declaration #{decl.inspect}. Should be one-element Hash of type { key_decl => value_decl }"}
+        it { expect { described_class.validate_item_decl(decl) }.to raise_error Oval::DeclError, msg }
+      end
+    end
+    [ {:a => :A}, {Oval::InstanceOf[String] => Oval::KindOf[Symbol] } ].each do |decl|
+      context "validate_item_decl(#{decl.inspect})" do
+        let(:decl) { decl }
+        it { expect { described_class.validate_item_decl(decl) }.to_not raise_error }
+      end
+    end
+  end
+
+  describe "#key_decl" do
+    let(:subject) { described_class[{:key_decl0 => :val_decl0}] }
+    context "#{described_class.name}[{:key_decl0 => :val_decl0}].key_decl" do
+      it { subject.key_decl.should be :key_decl0 }
+    end
+    context "when @key_decl = :key_decl1" do
+      before { subject.instance_variable_set(:@key_decl, :key_decl1) }
+      it { subject.key_decl.should be :key_decl1 }
+    end
+  end
+
+  describe "#val_decl" do
+    let(:subject) { described_class[:val_decl0] }
+    let(:subject) { described_class[{:key_decl0 => :val_decl0}] }
+    context "#{described_class.name}[{:key_decl0 => :val_decl0}].key_decl" do
+      it { subject.val_decl.should be :val_decl0 }
+    end
+    context "when @val_decl = :val_decl1" do
+      before { subject.instance_variable_set(:@val_decl, :val_decl1) }
+      it { subject.val_decl.should be :val_decl1 }
+    end
+  end
+
+  describe "#item_decl=" do
+    let(:subject) { described_class[:item_decl0] }
+    before do
+      described_class.any_instance.stubs(:item_decl=).once.with(:item_decl0)
+      subject
+      described_class.any_instance.unstub(:item_decl=)
+    end
+    context "item_decl = {:key_decl1 => :val_decl1}" do
+      before do
+        subject
+        described_class.expects(:validate_item_decl).once.with({:key_decl1 => :val_decl1})
+        subject.send(:item_decl=, {:key_decl1 => :val_decl1})
+      end
+      it "should assign @key_decl = :key_decl1" do
+        subject.instance_variable_get(:@key_decl).should be :key_decl1
+      end
+      it "should assign @val_decl = :val_decl1" do
+        subject.instance_variable_get(:@val_decl).should be :val_decl1
+      end
+    end
+    context "item_decl = Oval::Anything" do
+      it "should not invoke validate_item_decl" do
+        described_class.stubs(:validate_item_decl).never
+        subject.send(:item_decl=, Oval::Anything)
+      end
+      it "should assign key_decl=Oval::Anything[]" do
+        subject.send(:item_decl=, Oval::Anything)
+        subject.key_decl.should be Oval::Anything[]
+      end
+      it "should assign val_decl=Oval::Anything[]" do
+        subject.send(:item_decl=, Oval::Anything)
+        subject.val_decl.should be Oval::Anything[]
+      end
+    end
+    context "item_decl = Oval::Anything[]" do
+      it "should not invoke validate_item_decl" do
+        described_class.stubs(:validate_item_decl).never
+        subject.send(:item_decl=, Oval::Anything[])
+      end
+      it "should assign key_decl=Oval::Anything[]" do
+        subject.send(:item_decl=, Oval::Anything[])
+        subject.key_decl.should be Oval::Anything[]
+      end
+      it "should assign val_decl=Oval::Anything[]" do
+        subject.send(:item_decl=, Oval::Anything[])
+        subject.val_decl.should be Oval::Anything[]
+      end
+    end
+  end
+
+  describe "#validate" do
+    # Valid items
+    [
+      [ {:foo => :bar},[[:foo,:bar], 0] ],
+      [ {:foo => :bar},[[:foo,:bar], 0, 'sh'] ],
+      [ {Oval::InstanceOf[String] => Oval::InstanceOf[Symbol]},[['foo',:bar], 0, 'hash'] ],
+    ].each do |item_decl,args|
+      context "#{described_class.name}[#{item_decl.inspect}].validate(#{args.map{|x| x.inspect}.join(', ')})" do
+        let(:subject) { described_class[item_decl] }
+        let(:args) { args }
+        it { expect { subject.validate(*args) }.to_not raise_error }
+      end
+    end
+    [
+      [ {:foo => :bar},[[:geez,:bar], 0], "Invalid value :geez. Should be equal :foo" ],
+      [ {:foo => :bar},[[:foo,:geez], 1], "Invalid value :geez. Should be equal :bar" ],
+      [ {:foo => :bar},[[:geez,:bar], 0,'hash'], "Invalid value :geez for hash key. Should be equal :foo" ],
+      [ {:foo => :bar},[[:foo,:geez], 1,'hash'], "Invalid value :geez for hash[:foo]. Should be equal :bar" ],
+      [ {Oval::InstanceOf[String] => Oval::InstanceOf[Symbol]},[[:foo,:bar], 0, 'hash'], "Invalid object :foo of type Symbol for hash key. Should be an instance of String"],
+      [ {Oval::InstanceOf[String] => Oval::InstanceOf[Symbol]},[['foo','bar'], 0, 'hash'], "Invalid object \"bar\" of type String for hash[\"foo\"]. Should be an instance of Symbol"],
+    ].each do |item_decl,args,msg|
+      context "#{described_class.name}[#{item_decl.inspect}].validate(#{args.map{|x| x.inspect}.join(', ')})" do
+        let(:subject) { described_class[item_decl] }
+        let(:args) { args }
+        let(:msg) { msg }
+        it { expect { subject.validate(*args) }.to raise_error Oval::ValueError, msg }
+      end
+    end
+  end
+end

data/spec/unit/oval/instance_of_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'oval/instance_of'
+
+describe Oval::InstanceOf do
+  describe 'an instance' do
+    let(:subject)  { described_class[:klass] }
+    before { described_class.any_instance.stubs(:validate_class) }
+    it { should respond_to :validate }
+  end
+
+  context "#{described_class.name}[:symbol1]" do
+    let(:subject) { described_class[:symbol1] }
+    let(:msg) { "Invalid class :symbol1 for InstanceOf" }
+    it { expect { subject }.to raise_error Oval::DeclError, msg }
+  end
+
+  describe "#validate" do
+    [
+      [Array, []],
+      [String, "hello"],
+      [Fixnum, 1],
+    ].each do |klass,object|
+      context "#{described_class.name}[#{klass.name}].validate(#{object.inspect})" do
+        let(:subject) { described_class[klass] }
+        let(:object) { object }
+        it { expect { subject.validate(object) }.to_not raise_error }
+      end
+    end
+    [
+      [Array, {}],
+      [String, :symbol1],
+      [Fixnum, "hello"],
+      [Integer, 1],
+      [Object, :obj]
+    ].each do |klass,object|
+      context "#{described_class.name}[#{klass.name}].validate(#{object.inspect})" do
+        let(:subject) { described_class[klass] }
+        let(:object) { object }
+        let(:msg) { "Invalid object #{object.inspect} of type #{object.class.name}. Should be an instance of #{klass.name}" }
+        it { expect { subject.validate(object) }.to raise_error msg }
+      end
+    end
+  end
+end

data/spec/unit/oval/kind_of_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+require 'oval/kind_of'
+
+describe Oval::KindOf do
+  describe 'an instance' do
+    let(:subject)  { described_class[:klass] }
+    before { described_class.any_instance.stubs(:validate_class) }
+    it { should respond_to :validate }
+  end
+
+  context "#{described_class.name}[:symbol1]" do
+    let(:subject) { described_class[:symbol1] }
+    let(:msg) { "Invalid class :symbol1 for KindOf" }
+    it { expect { subject }.to raise_error Oval::DeclError, msg }
+  end
+
+  describe "#validate" do
+    [
+      [Array, []],
+      [String, "hello"],
+      [Fixnum, 1],
+      [Integer, 1],
+      [Object, :symbol]
+    ].each do |klass,object|
+      context "#{described_class.name}[#{klass.name}].validate(#{object.inspect})" do
+        let(:subject) { described_class[klass] }
+        let(:object) { object }
+        it { expect { subject.validate(object) }.to_not raise_error }
+      end
+    end
+    [
+      [Array, {}],
+      [String, :symbol1],
+      [Fixnum, "hello"],
+      [Integer, []],
+    ].each do |klass,object|
+      context "#{described_class.name}[#{klass.name}].validate(#{object.inspect})" do
+        let(:subject) { described_class[klass] }
+        let(:object) { object }
+        let(:msg) { "Invalid object #{object.inspect} of type #{object.class.name}. Should be a kind of #{klass.name}" }
+        it { expect { subject.validate(object) }.to raise_error msg }
+      end
+    end
+  end
+end

data/spec/unit/oval/one_of_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+require 'oval/one_of'
+
+describe Oval::OneOf do
+  context 'the class' do
+    it { described_class.should respond_to :[] }
+  end
+  context 'an instance' do
+    it { should respond_to :validate }
+    it { should respond_to :decls }
+  end
+
+  describe "[]" do
+    [[], [:arg1], [:arg1, :arg2], [:arg1, :arg2, :arg3] ].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 "new" do
+    [[], [:arg1], [:arg1, :arg2], [:arg1, :arg2, :arg3] ].each do |args|
+      context "new(#{args.map{|x| x.inspect}.join(', ')})" do
+        let(:args) { args }
+        it "should invoke decls = #{args.inspect}" do
+          described_class.any_instance.expects(:decls=).once.with(args)
+          expect { described_class.new(*args) }.to_not raise_error
+        end
+      end
+    end
+  end
+
+  describe "#validate" do
+    [
+      [ [:foo ], [:foo] ],
+      [ [:foo, :bar], [:bar] ],
+      [ [:foo, :bar], [:bar,'subj'] ],
+    ].each do |decls,args|
+      context "#{described_class}[#{decls.map{|x| x.inspect}.join(', ')}].validate(#{args.map{|x| x.inspect}.join(', ')})" do
+        let(:args) { args }
+        let(:subject) { described_class[*decls] }
+        it { expect { subject.validate(*args) }.to_not raise_error }
+      end
+    end
+    [
+      [ [:foo ], [:bar], "Invalid value :bar" ],
+      [ [:foo, :bar], [:geez], "Invalid value :geez" ],
+      [ [:foo, :bar], [:geez,'subj'], "Invalid value :geez for subj" ],
+    ].each do |decls,args,msg|
+      context "#{described_class}[#{decls.map{|x| x.inspect}.join(', ')}].validate(#{args.map{|x| x.inspect}.join(', ')})" do
+        let(:args) { args }
+        let(:subject) { described_class[*decls] }
+        let(:msg) { msg }
+        it { expect { subject.validate(*args) }.to raise_error Oval::ValueError, msg }
+      end
+    end
+  end
+end

data/spec/unit/oval/options_spec.rb

@@ -0,0 +1,215 @@
+require 'spec_helper'
+require 'oval/options'
+
+describe Oval::Options do
+  context "the class" do
+    [
+      :validate_decl,
+      :validate_option_name_decl,
+    ].each do |method|
+      it { described_class.should respond_to method }
+    end
+  end
+
+  context "an instance" do
+    let(:subject) { described_class[:decl0] }
+    before { described_class.stubs(:validate_decl).once.with(:decl0) }
+    [
+      :validate,
+      :validate_option,
+      :validate_option_name,
+      :validate_option_value,
+    ].each do |method|
+      it { should respond_to method }
+    end
+  end
+
+  describe "#validate" do
+    context "validate(:symbol)" do
+      let(:subject) { described_class[:decl0] }
+      let(:msg) { "Invalid options :symbol of type Symbol. Should be a Hash" }
+      before do
+        described_class.stubs(:validate_decl).once.with(:decl0)
+        subject.stubs(:validate_option).never
+      end
+      it { expect { subject.validate(:symbol) }.to raise_error Oval::ValueError, msg }
+    end
+    [
+      {},
+      {:a => :A},
+      {:a => :A, :b => :B},
+    ].each do |options|
+      context "validate(#{options.inspect},:subj1)" do
+        let(:options) { options }
+        let(:subject) { described_class[:decl1] }
+        before do
+          described_class.expects(:validate_decl).once.with(:decl1)
+          options.each do |name,value|
+            subject.expects(:validate_option).once.with(name, value, :subj1)
+          end
+        end
+        it "should invoke validate_option(key,value,:subj1) for each key,value in #{options.inspect}" do
+          expect { subject.validate(options,:subj1) }.to_not raise_error
+        end
+      end
+    end
+    context "validate({:a => :A})" do
+      let(:subject) { described_class[:decl1] }
+      before { described_class.expects(:validate_decl).once.with(:decl1) }
+      it "should invoke validate_option(:a,:A,nil) once" do
+        subject.expects(:validate_option).once.with(:a, :A, nil)
+        expect { subject.validate({:a => :A}) }.to_not raise_error
+      end
+    end
+  end
+
+  describe "#validate_option" do
+    before { described_class.expects(:validate_decl).once.with(:decl1) }
+    let(:subject) { described_class[:decl1] }
+    context "validate_option(:name1,:value1,:subj1)" do
+      it "should invoke validate_option_name(name1,:subj1) and validate_option_value(:value,:name1,:subj1) once" do
+        subject.expects(:validate_option_name).once.with(:name1,:subj1)
+        subject.expects(:validate_option_value).once.with(:value1,:name1,:subj1)
+        expect { subject.send(:validate_option,:name1,:value1,:subj1) }.to_not raise_error
+      end
+    end
+    context "validate_option(:name1,:value1)" do
+      it "should invoke validate_option_name(name1,nil) and validate_option_value(:value,:name1,nil) once" do
+        subject.expects(:validate_option_name).once.with(:name1,nil)
+        subject.expects(:validate_option_value).once.with(:value1,:name1,nil)
+        expect { subject.send(:validate_option,:name1,:value1) }.to_not raise_error
+      end
+    end
+  end
+
+  describe "#validate_option_name" do
+    [
+      [
+        {:foo => :X, :bar => :Y},
+        ":bar and :foo",
+        [ :foo, :bar ],
+        [ :geez ],
+      ],
+      [
+        {:foo => :X, :bar => :Y, :geez => :Z},
+        ":bar, :foo and :geez",
+        [ :foo, :bar, :geez ],
+        [ :dood ],
+      ],
+    ].each do |decl, enumerated, valid, invalid|
+      context "on Options[#{decl.inspect}]" do
+        before { described_class.expects(:validate_decl).once.with(decl) }
+        let(:subject) { described_class[decl] }
+        let(:msg1) { "Invalid option #{name.inspect}. Allowed options are #{enumerated}"}
+        let(:msg2) { "Invalid option #{name.inspect} for subj1. Allowed options are #{enumerated}"}
+        valid.each do |name|
+          context "validate_option_name(#{name.inspect})" do
+            let(:name) { name }
+            it { expect { subject.send(:validate_option_name, name) }.to_not raise_error }
+          end
+        end
+        invalid.each do |name|
+          context "validate_option_name(#{name.inspect})" do
+            let(:name) { name }
+            it { expect { subject.send(:validate_option_name, name) }.to raise_error Oval::ValueError, msg1}
+          end
+          context "validate_option_name(#{name.inspect},'subj1')" do
+            let(:name) { name }
+            it { expect { subject.send(:validate_option_name, name, 'subj1') }.to raise_error Oval::ValueError, msg2}
+          end
+        end
+      end
+    end
+  end
+
+  describe "#validate_option_value" do
+    [
+      [
+        {:foo => :X, :bar => :Y},
+        [ :V, :bar ],
+        [ :V, :Y, nil ],
+      ],
+      [
+        {:foo => :X, :bar => :Y, :geez => :Z},
+        [ :V, :geez, 'subj1'],
+        [ :V, :Z, 'subj1[:geez]'],
+      ],
+    ].each do |decl, args, args2|
+      context "on Options[#{decl.inspect}]" do
+        before { described_class.expects(:validate_decl).once.with(decl) }
+        let(:subject) { described_class[decl] }
+        context "validate_option_value(#{args.map{|x| x.inspect}.join(', ')})" do
+          let(:name) { name }
+          it "should invoke self.class.ensure_match(#{args2.map{|x| x.inspect}.join(', ')}) once" do
+            described_class.stubs(:ensure_match).once.with(*args2)
+            expect { subject.send(:validate_option_value,*args) }.to_not raise_error
+          end
+        end
+      end
+    end
+  end
+
+  describe "#validate_decl" do
+    context "validate_decl({:foo => :F, :bar => 4})" do
+      it { expect { described_class.validate_decl({:foo => :F, :bar => 4}) }.to_not raise_error }
+    end
+    context "validate_decl(:decl1)" do
+      let(:msg) { "Invalid declaration :decl1 of type Symbol. Should be a Hash" }
+      it { expect { described_class.validate_decl(:decl1) }.to raise_error Oval::DeclError, msg }
+    end
+    [
+      {},
+      {:one => 1},
+      {:one => 1, :two => "Two"},
+      {:one => "One", :two => 2, :three => [1,2,3]}
+    ].each do |decl|
+      context "validate_decl(#{decl.inspect})" do
+        let(:decl) { decl }
+        before { decl.keys.each {|key| described_class.expects(:validate_option_name_decl).once.with(key) } }
+        it "calls validate_option_name_decl(key) once for each key from #{decl.inspect} " do
+          expect { described_class.validate_decl(decl) }.to_not raise_error
+        end
+      end
+    end
+  end
+
+  describe "validate_option_name_decl" do
+    [ :one, 'two', 3 ].each do |decl|
+      context "validate_option_name_decl(#{decl.inspect})" do
+        let(:decl) { decl }
+        it { expect { described_class.validate_option_name_decl(decl) }.to_not raise_error }
+      end
+    end
+  end
+
+
+  describe "decl" do
+    before { described_class.stubs(:validate_decl) }
+    context "new(:decl0).decl" do
+      it { described_class.new(:decl0).decl.should be :decl0 }
+    end
+    context "when @decl == :decl1" do
+      let(:subject) { described_class.new(:decl0) }
+      before { subject.instance_variable_set(:@decl,:decl1) }
+      it { subject.decl.should be :decl1 }
+    end
+  end
+
+  describe "#decl=" do
+    # first, stub validate_decl to create dummy object
+    before { described_class.stubs(:validate_decl) }
+    let(:subject) { described_class.new(:decl0) }
+    context "#decl = :decl1" do
+      it "should call self.class.validate_decl(:decl1) once" do
+        subject # reference before re-stubbing validate_decl
+        described_class.stubs(:validate_decl).never
+        described_class.stubs(:validate_decl).once.with(:decl1)
+        expect { subject.send(:decl=,:decl1) }.to_not raise_error
+      end
+      it "should assign @decl = :decl1" do
+        subject.send(:decl=, :decl1)
+        subject.instance_variable_get(:@decl).should be :decl1
+      end
+    end
+  end
+end