schemata-staging 0.0.1.1

data/spec/component/aux_data_spec.rb

@@ -0,0 +1,37 @@
+require 'schemata/component/foo'
+
+describe Schemata::Component::Foo::V14 do
+  describe "#new" do
+    it "should define accessors for aux schema fields" do
+      v14_obj = Schemata::Component::Foo::V14.new
+      v14_obj.aux_data.respond_to?(:foo4).should be_true
+      v14_obj.aux_data.respond_to?(:foo4=).should be_true
+    end
+  end
+
+  describe "#generate_old_fields" do
+    it "should emit correct fields if the object was constructed with aux_data" do
+      v14_hash = {
+        "foo1" => "hello",
+        "foo3" => [3]
+      }
+      aux_data = { "foo4" => "foo" }
+      v14_obj = Schemata::Component::Foo::V14.new(v14_hash, aux_data)
+      downverted, old_fields = v14_obj.generate_old_fields
+
+      old_fields.keys.should =~ ["foo4"]
+      old_fields["foo4"].should == "foo"
+    end
+
+    it "should raise an error if the object was constructed without aux_data" do
+      v14_hash = {
+        "foo1" => "hello",
+        "foo3" => [3]
+      }
+      v14_obj = Schemata::Component::Foo::V14.new(v14_hash)
+      expect {
+        v14_obj.generate_old_fields
+      }.to raise_error(Schemata::DecodeError)
+    end
+  end
+end

data/spec/component/component_bar_spec.rb

@@ -0,0 +1,140 @@
+require 'schemata/component/component'
+require 'support/helpers'
+
+describe Schemata::Component do
+  before :each do
+    @v10_msg = '{
+      "min_version": 10,
+      "V10": {
+        "bar1": "first",
+        "bar2": "second"
+      }
+    }'
+
+    @v11_msg = '{
+      "min_version": 10,
+      "V11": {
+        "bar1": 1,
+        "bar3": "third"
+      },
+      "V10": {
+        "bar1": "1",
+        "bar2": "second"
+      }
+    }'
+
+    @v10_hash = {
+      "bar1" => "1",
+      "bar2" => "second"
+    }
+
+    @v11_hash = {
+      "bar1" => 1,
+      "bar3" => "third"
+    }
+  end
+
+  describe "#decode" do
+    describe "(current version is 10)" do
+      before :each do
+        set_current_version(Schemata::Component::Bar, 10)
+      end
+
+      after :each do
+        reset_version(Schemata::Component::Bar)
+      end
+
+      it "should take a v10 msg and create a v10 obj" do
+        msg_obj = Schemata::Component::Bar.decode(@v10_msg)
+        msg_obj.bar1.should == "first"
+        msg_obj.bar2.should == "second"
+      end
+
+      it "should take a v11 msg and create a v10 obj" do
+        msg_obj = Schemata::Component::Bar.decode(@v11_msg)
+        msg_obj.bar1.should == "1"
+        msg_obj.bar2.should == "second"
+      end
+    end
+
+    describe "(current version is 11)" do
+      before :each do
+        set_current_version(Schemata::Component::Bar, 11)
+      end
+
+      after :each do
+        reset_version(Schemata::Component::Bar)
+      end
+
+      it "should take a v10 msg and create a v11 obj" do
+        msg_obj = Schemata::Component::Bar.decode(@v10_msg)
+        msg_obj.bar1.should == 5
+        msg_obj.bar3.should == "third"
+      end
+
+      it "should take a v11 msg and create a v11 obj" do
+        msg_obj = Schemata::Component::Bar.decode(@v11_msg)
+        msg_obj.bar1.should == 1
+        msg_obj.bar3.should == "third"
+      end
+    end
+  end
+
+  describe "#encode" do
+    describe "(current version is 10)" do
+      before :each do
+        set_current_version(Schemata::Component::Bar, 10)
+      end
+
+      after :each do
+        reset_version(Schemata::Component::Bar)
+      end
+
+      it "should take a v10 obj and encode a json msg" do
+        v10_obj = Schemata::Component::Bar::V10.new(@v10_hash)
+        json_msg = v10_obj.encode
+        returned_hash = Yajl::Parser.parse(json_msg)
+
+        returned_hash.keys.should =~ ['min_version', 'V10']
+        returned_hash['min_version'].should ==
+          @curr_class::MIN_VERSION_ALLOWED
+
+        v10 = returned_hash['V10']
+        v10.each do |k, v|
+          v10[k].should == @v10_hash[k]
+        end
+      end
+    end
+
+    describe "(current version is 11)" do
+      before :each do
+        set_current_version(Schemata::Component::Bar, 11)
+      end
+
+      it "should take a v11 obj and encode a json msg" do
+        aux_data = {"bar2" => "second" }
+        v11_obj = Schemata::Component::Bar::V11.new(@v11_hash, aux_data)
+        json_msg = v11_obj.encode
+        returned_hash = Yajl::Parser.parse(json_msg)
+
+        returned_hash.keys.should =~ ['min_version', 'V10', 'V11']
+        returned_hash['min_version'].should ==
+          @curr_class::MIN_VERSION_ALLOWED
+
+        v10 = returned_hash['V10']
+        v10.each do |k, v|
+          v10[k].should == @v10_hash[k]
+        end
+
+        v11 = returned_hash['V11']
+        v11.each do |k, v|
+          v11[k].should == @v11_hash[k]
+        end
+      end
+
+      after :each do
+        reset_version(Schemata::Component::Bar)
+      end
+    end
+  end
+end

data/spec/component/component_foo_spec.rb

@@ -0,0 +1,630 @@
+require 'schemata/component/component'
+require 'support/helpers'
+
+describe Schemata::Component do
+  before :each do
+    @v10_msg = '{
+      "min_version": 10,
+      "V10": {
+        "foo1": "hello",
+        "foo2": 1
+      }
+    }'
+
+    @v11_msg = '{
+      "min_version": 10,
+      "V11": {
+        "foo1": "hello",
+        "foo2": 1,
+        "foo3": 1
+      },
+      "V10": {}
+    }'
+
+    @v12_msg = '{
+      "min_version" : 10,
+      "V12": {
+        "foo1": "hello",
+        "foo2": 1,
+        "foo3": [1]
+      },
+      "V11": {
+        "foo3": 1
+      },
+      "V10": {}
+    }'
+
+    @v13_msg = '{
+      "min_version": 13,
+      "V13": {
+        "foo1": "hello",
+        "foo3": [1],
+        "foo4": "foo"
+      }
+    }'
+
+    @v14_msg = '{
+      "min_version": 13,
+      "V14" : {
+        "foo1" : "hello",
+        "foo3" : [1]
+      },
+      "V13" : { "foo4" : "foo" }
+    }'
+
+    @v10_hash = {
+      "foo1" => "hello",
+      "foo2" => 1
+    }
+
+    @v11_hash = {
+      "foo1" => "hello",
+      "foo2" => 1,
+      "foo3" => 1
+    }
+
+    @v12_hash = {
+      "foo1" => "hello",
+      "foo2" => 1,
+      "foo3" => [1]
+    }
+
+    @v13_hash = {
+      "foo1" => "hello",
+      "foo3" => [1],
+      "foo4" => "foo"
+    }
+
+    @v14_hash = {
+      "foo1" => "hello",
+      "foo3" => [1]
+    }
+
+  end
+
+  describe "#decode" do
+    it "should raise an error if the 'min_version' is missing" do
+      msg_hash = {
+        "V10" => {},
+        "V11" => {
+          "foo1" => "foo",
+          "foo2" => 1,
+          "foo3" => 1
+        }
+      }
+      json_msg = Yajl::Encoder.encode msg_hash
+      expect {
+        foo_obj = Schemata::Component::Foo.decode(json_msg)
+      }.to raise_error(Schemata::DecodeError)
+    end
+
+    it "should raise an error if the message has no Vxx key" do
+      msg_hash = {
+        "min_version" => 10
+      }
+      json_msg = Yajl::Encoder.encode msg_hash
+      expect {
+        foo_obj = Schemata::Component::Foo.decode(json_msg)
+      }.to raise_error(Schemata::DecodeError)
+    end
+
+    describe "(current version is 10)" do
+      before :each do
+        set_current_version(Schemata::Component::Foo, 10)
+    end
+
+      after :each do
+        reset_version(Schemata::Component::Foo)
+      end
+
+      it "should take a v10 message and return a correct Foo::V10 object" do
+        foo_obj = Schemata::Component::Foo.decode(@v10_msg)
+        foo_obj.class.should == Schemata::Component::Foo::V10
+        foo_obj.foo1.should == "hello"
+        foo_obj.foo2.should == 1
+      end
+
+      it "should take a v11 message and return a correct Foo::V10 object" do
+        foo_obj = Schemata::Component::Foo.decode(@v11_msg)
+        foo_obj.class.should == Schemata::Component::Foo::V10
+        foo_obj.foo1.should == "hello"
+        foo_obj.foo2.should == 1
+      end
+
+      it "should take a v12 message and return a correct Foo::V10 object" do
+        foo_obj = Schemata::Component::Foo.decode(@v12_msg)
+        foo_obj.class.should == Schemata::Component::Foo::V10
+        foo_obj.foo1.should == "hello"
+        foo_obj.foo2.should == 1
+      end
+
+      it "should raise an error when a v10 message has an invalid V10 hash" do
+        msg_hash = {
+          "min_version" => 10,
+          "V10" => {
+            "foo1" => "foo",
+          }
+        }
+        json_msg = Yajl::Encoder.encode(msg_hash)
+        expect {
+          foo_obj = Schemata::Component::Foo.decode(json_msg)
+        }.to raise_error(Schemata::DecodeError)
+      end
+
+      it "should raise an error when a v11 message has an invalid union \
+of V11 and V10 hashes" do
+        msg_hash = {
+          "min_version" => 10,
+          "V10" => {},
+          "V11" => {
+            "foo1" => "foo",
+            "foo2" => "bar",
+            "foo3" => 1
+          }
+        }
+        json_msg = Yajl::Encoder.encode(msg_hash)
+        expect {
+          foo_obj = Schemata::Component::Foo.decode(
+            json_msg)
+        }.to raise_error(Schemata::DecodeError)
+      end
+
+      it "should raise an error when a v12 message has an invalid union \
+of V10, V11, and V12 hashes" do
+        msg_hash = {
+          "min_version" => 10,
+          "V10" => {},
+          "V11" => {"foo3" => 1},
+          "V12" => {
+            "foo1" => "foo",
+            "foo2" => "bar",
+            "foo3" => [1]
+          }
+        }
+        json_msg = Yajl::Encoder.encode msg_hash
+        expect {
+          foo_obj = Schemata::Component::Foo.decode(json_msg)
+        }.to raise_error(Schemata::DecodeError)
+
+        msg_hash["V11"]["foo2"] = "bar"
+        msg_hash["V12"]["foo2"] = 1
+        json_msg = Yajl::Encoder.encode msg_hash
+        expect {
+          foo_obj = Schemata::Component::Foo.decode(json_msg)
+        }.to raise_error(Schemata::DecodeError)
+      end
+
+      it "should raise an IncompatibleVersionError when it gets a v13 msg" do
+        expect {
+          foo_obj = Schemata::Component::Foo.decode(@v13_msg)
+        }.to raise_error(Schemata::IncompatibleVersionError)
+      end
+    end
+
+    describe "(current version is 11)" do
+      before :each do
+        set_current_version(Schemata::Component::Foo, 11)
+      end
+
+      after :each do
+        reset_version(Schemata::Component::Foo)
+      end
+
+      it "should take a v10 message, upvert, and return a correct V11 object" do
+        foo_obj = Schemata::Component::Foo.decode(@v10_msg)
+        foo_obj.class.should == Schemata::Component::Foo::V11
+        foo_obj.foo1.should == "hello"
+        foo_obj.foo2.should == 1
+        foo_obj.foo3.should == 1
+      end
+
+      it "should take a v11 message and return a correct V11 object" do
+        foo_obj = Schemata::Component::Foo.decode(@v11_msg)
+        foo_obj.class.should == Schemata::Component::Foo::V11
+        foo_obj.foo1.should == "hello"
+        foo_obj.foo2.should == 1
+        foo_obj.foo3.should == 1
+      end
+
+      it "should take a v12 message and return a correct V11 object" do
+        foo_obj = Schemata::Component::Foo.decode(@v12_msg)
+        foo_obj.class.should == Schemata::Component::Foo::V11
+        foo_obj.foo1.should == "hello"
+        foo_obj.foo2.should == 1
+        foo_obj.foo3.should == 1
+      end
+
+      it "should raise an error when a v10 message has an invalid V10 hash" do
+        msg_hash = {
+          "min_version" => 10,
+          "V10" => {
+            "foo1" => "foo",
+          }
+        }
+        json_msg = Yajl::Encoder.encode msg_hash
+        expect {
+          foo_obj = Schemata::Component::Foo.decode(json_msg)
+        }.to raise_error(Schemata::DecodeError)
+      end
+
+      it "should raise an error when a v11 message has an invalid V11 hash" do
+        msg_hash = {
+          "min_version" => 10,
+          "V10" => {},
+          "V11" => {
+            "foo1" => "foo",
+            "foo3" => 1
+          }
+        }
+        json_msg = Yajl::Encoder.encode msg_hash
+        expect {
+          foo_obj = Schemata::Component::Foo.decode(json_msg)
+        }.to raise_error(Schemata::DecodeError)
+      end
+
+        it "should raise an error when a v12 message has an invalid union \
+of V10, V11, and V12 hashes" do
+          msg_hash = {
+            "min_version" => 10,
+            "V10" => {},
+            "V11" => {"foo3" => [1]},
+            "V12" => {
+              "foo1" => "foo",
+              "foo2" => 1,
+              "foo3" => [1]
+            }
+          }
+          json_msg = Yajl::Encoder.encode msg_hash
+          expect {
+            foo_obj = Schemata::Component::Foo.decode(json_msg)
+          }.to raise_error(Schemata::DecodeError)
+      end
+
+      it "should raise an IncompatibleVersionError on a v13 message" do
+        expect {
+          foo_obj = Schemata::Component::Foo.decode(@v13_msg)
+        }.to raise_error(Schemata::IncompatibleVersionError)
+      end
+    end
+
+    describe "(current version is 12)" do
+      before :each do
+        set_current_version(Schemata::Component::Foo, 12)
+      end
+
+      after :each do
+        reset_version(Schemata::Component::Foo)
+      end
+
+      it "should take a v10 message, upvert twice, and return a correct V12 object" do
+        foo_obj = Schemata::Component::Foo.decode(@v10_msg)
+        foo_obj.class.should == Schemata::Component::Foo::V12
+        foo_obj.foo1.should == "hello"
+        foo_obj.foo2.should == 1
+        foo_obj.foo3.should == [1]
+      end
+
+      it "should take a v11 message, upvert, and return a correct V12 object" do
+        foo_obj = Schemata::Component::Foo.decode(@v11_msg)
+        foo_obj.class.should == Schemata::Component::Foo::V12
+        foo_obj.foo1.should == "hello"
+        foo_obj.foo2.should == 1
+        foo_obj.foo3.should == [1]
+      end
+
+      it "should take a v12 message and return a correct V12 object" do
+        foo_obj = Schemata::Component::Foo.decode(@v12_msg)
+        foo_obj.class.should == Schemata::Component::Foo::V12
+        foo_obj.foo1.should == "hello"
+        foo_obj.foo2.should == 1
+        foo_obj.foo3.should == [1]
+      end
+
+      it "should raise an error when a v10 message has an invalid V10 hash" do
+        msg_hash = {
+          "min_version" => 10,
+          "V10" => {
+            "foo1" => "foo"
+          }
+        }
+        json_msg = Yajl::Encoder.encode(msg_hash)
+        expect {
+          foo_obj = Schemata::Component::Foo.decode(json_msg)
+        }.to raise_error(Schemata::DecodeError)
+      end
+
+      it "should raise an error when a v11 messsage an invalid V11 hash" do
+        msg_hash = {
+          "min_version" => 10,
+          "V10" => {},
+          "V11" => {}
+        }
+        json_msg = Yajl::Encoder.encode(msg_hash)
+        expect {
+          foo_obj = Schemata::Component::Foo.decode(json_msg)
+        }.to raise_error(Schemata::DecodeError)
+      end
+
+      it "should raise an error when a v12 message has an invalid V12 hash" do
+        msg_hash = {
+          "min_version" => 10,
+          "V10" => {},
+          "V11" => {"foo3" => 1},
+          "V12" => {}
+        }
+        json_msg = Yajl::Encoder.encode(msg_hash)
+        expect {
+          foo_obj = Schemata::Component::Foo.decode(json_msg)
+        }.to raise_error(Schemata::DecodeError)
+      end
+
+      it "should raise an IncompatibleVersionError on a v13 message" do
+        expect {
+          foo_obj = Schemata::Component::Foo.decode(@v13_msg)
+        }.to raise_error(Schemata::IncompatibleVersionError)
+      end
+    end
+
+    describe "(current version is 13)" do
+      before :each do
+        set_current_version(Schemata::Component::Foo, 13)
+      end
+
+      after :each do
+        reset_version(Schemata::Component::Foo)
+      end
+
+      it "should validate a v10 message and return a correct V13 object" do
+        foo_obj = Schemata::Component::Foo.decode(@v10_msg)
+        foo_obj.class.should == Schemata::Component::Foo::V13
+        foo_obj.foo1.should == "hello"
+        foo_obj.foo3.should == [1]
+        foo_obj.foo4.should == "foo"
+      end
+
+      it "should validate a v11 message and return a correct V13 object" do
+        foo_obj = Schemata::Component::Foo.decode(@v11_msg)
+        foo_obj.class.should == Schemata::Component::Foo::V13
+        foo_obj.foo1.should == "hello"
+        foo_obj.foo3.should == [1]
+        foo_obj.foo4.should == "foo"
+      end
+
+      it "should validate a v12 message and return a correct V13 object" do
+        foo_obj = Schemata::Component::Foo.decode(@v12_msg)
+        foo_obj.class.should == Schemata::Component::Foo::V13
+        foo_obj.foo1.should == "hello"
+        foo_obj.foo3.should == [1]
+        foo_obj.foo4.should == "foo"
+      end
+
+      it "should validate a v13 message and return a correct V13 object" do
+        foo_obj =Schemata::Component::Foo.decode(@v13_msg)
+        foo_obj.class.should == Schemata::Component::Foo::V13
+        foo_obj.foo1.should == "hello"
+        foo_obj.foo3.should == [1]
+        foo_obj.foo4.should == "foo"
+      end
+
+      it "should validate a v14 message and return a correct v13 object" do
+        foo_obj = Schemata::Component::Foo.decode(@v14_msg)
+        foo_obj.class.should == Schemata::Component::Foo::V13
+        foo_obj.foo1.should == "hello"
+        foo_obj.foo3.should == [1]
+        foo_obj.foo4.should == "foo"
+      end
+    end
+
+    describe "(current version is 14)" do
+      before :each do
+        Schemata::Component::Foo.stub(:current_version).and_return(14)
+        @curr_class = Schemata::Component::Foo.current_class
+      end
+
+      it "should validate a v13 message and return a correct v14 object" do
+        foo_obj = Schemata::Component::Foo.decode(@v13_msg)
+        foo_obj.class.should == Schemata::Component::Foo::V14
+        foo_obj.foo1.should == "hello"
+        foo_obj.foo3.should == [1]
+      end
+
+      it "should validate a v14 message and return a correct v14 object" do
+        foo_obj = Schemata::Component::Foo.decode(@v14_msg)
+        foo_obj.class.should == Schemata::Component::Foo::V14
+        foo_obj.foo1.should == "hello"
+        foo_obj.foo3.should == [1]
+      end
+    end
+  end
+
+  describe "#encode" do
+    describe "(current version is 10)" do
+      before :each do
+        set_current_version(Schemata::Component::Foo, 10)
+      end
+
+      after :each do
+        reset_version(Schemata::Component::Foo)
+      end
+
+      it "should take a v10 obj and return the correct json string" do
+        v10_obj = Schemata::Component::Foo::V10.new(@v10_hash)
+        json = v10_obj.encode
+        returned_hash = Yajl::Parser.parse json
+        returned_hash.keys.should =~ ['min_version', 'V10']
+
+        returned_hash['min_version'].should ==
+          @curr_class::MIN_VERSION_ALLOWED
+
+        v10 = returned_hash['V10']
+        v10.each do |k, v|
+          v10[k].should == @v10_hash[k]
+        end
+      end
+
+      it "should raise an error if the msg_obj is incomplete" do
+        msg_obj = Schemata::Component::Foo::V10.new({"foo1" => "foo"})
+        expect {
+          json = msg_obj.encode
+        }.to raise_error(Schemata::EncodeError)
+      end
+    end
+
+    describe "(current version is 11)" do
+      before :each do
+        set_current_version(Schemata::Component::Foo, 11)
+      end
+
+      after:each do
+        reset_version(Schemata::Component::Foo)
+      end
+
+      it "should take a v11 obj and return the correct json string" do
+        v11_obj = Schemata::Component::Foo::V11.new @v11_hash
+        json = v11_obj.encode
+        returned_hash = Yajl::Parser.parse json
+
+        returned_hash.keys.should =~ ['min_version', 'V10', 'V11']
+
+        returned_hash['min_version'].should ==
+          @curr_class::MIN_VERSION_ALLOWED
+
+        v10 = returned_hash["V10"]
+        v10.each do |k, v|
+          v10[k].should == @v10_hash[k]
+        end
+
+        v11 = returned_hash["V11"]
+        v11.each do |k, v|
+          v11[k].should == @v11_hash[k]
+        end
+      end
+
+      it "should raise an error if the msg_obj is incomplete" do
+        msg_obj = Schemata::Component::Foo::V11.new({"foo1" => "foo"})
+        expect {
+          json = msg_obj.encode
+        }.to raise_error(Schemata::EncodeError)
+      end
+    end
+
+    describe "(current version is 12)" do
+      before :each do
+        set_current_version(Schemata::Component::Foo, 12)
+      end
+
+      after :each do
+        reset_version(Schemata::Component::Foo)
+      end
+
+      it "should take a v12 obj and return the correct json string" do
+        v12_obj = Schemata::Component::Foo::V12.new @v12_hash
+        json = v12_obj.encode
+        returned_hash = Yajl::Parser.parse json
+
+        returned_hash.keys.should =~ ['min_version', 'V10', 'V11', 'V12']
+
+        returned_hash['min_version'].should ==
+          @curr_class::MIN_VERSION_ALLOWED
+
+        v10 = returned_hash['V10']
+        v10.each do |k, v|
+          v10[k].should == @v10_hash[k]
+        end
+
+        v11 = returned_hash['V11']
+        v11.each do |k, v|
+          v11[k].should == @v11_hash[k]
+        end
+
+        v12 = returned_hash['V12']
+        v12.each do |k, v|
+          v12[k].should == @v12_hash[k]
+        end
+      end
+
+      it "should raise an error if the msg_obj is incomplete" do
+        msg_obj = Schemata::Component::Foo::V12.new({"foo1" => "foo"})
+        expect {
+          json = msg_obj.encode
+        }.to raise_error(Schemata::EncodeError)
+      end
+    end
+
+    describe "(current version is 13)" do
+      before :each do
+        set_current_version(Schemata::Component::Foo, 13)
+      end
+
+      after :each do
+        reset_version(Schemata::Component::Foo)
+      end
+
+      it "should take a v13 obj and return the correct json string" do
+        v13_obj = Schemata::Component::Foo::V13.new @v13_hash
+        json = v13_obj.encode
+        returned_hash = Yajl::Parser.parse json
+
+        returned_hash.keys.should =~ ['min_version', 'V13']
+
+        returned_hash['min_version'].should ==
+          @curr_class::MIN_VERSION_ALLOWED
+
+        v13 = returned_hash['V13']
+        v13.each do |k, v|
+          v13[k].should == @v13_hash[k]
+        end
+      end
+
+      it "should raise an error if the msg_obj is incomplete" do
+        msg_obj = Schemata::Component::Foo::V13.new({"foo1" => "foo"})
+        expect {
+          json = msg_obj.encode
+        }.to raise_error(Schemata::EncodeError)
+      end
+    end
+
+    describe "(current version 14)" do
+      before :each do
+        Schemata::Component::Foo.stub(:current_version).and_return(14)
+        @curr_class = Schemata::Component::Foo.current_class
+      end
+
+      it "should take a v14 obj and return the correct json string" do
+        aux_data = { "foo4" => "foo" }
+        v14_obj = Schemata::Component::Foo::V14.new(@v14_hash, aux_data)
+        json = v14_obj.encode
+        returned_hash = Yajl::Parser.parse(json)
+
+        returned_hash.keys.should =~ ['min_version', 'V13', 'V14']
+        returned_hash['min_version'].should ==
+          @curr_class::MIN_VERSION_ALLOWED
+
+        v13 = returned_hash['V13']
+        v13.keys.should =~ ['foo4']
+        v13['foo4'].should == "foo"
+
+        v14 = returned_hash['V14']
+        v14.each do |k, v|
+          v14[k].should == @v14_hash[k]
+        end
+      end
+
+      it "should raise an error if the msg_obj is incomplete" do
+        msg_obj = Schemata::Component::Foo::V14.new({"foo1" => "foo"})
+        expect {
+          json = msg_obj.encode
+        }.to raise_error(Schemata::EncodeError)
+
+        msg_obj = Schemata::Component::Foo::V14.new({
+                                                      "foo1" => "foo",
+                                                      "foo3" => [1],
+                                                    })
+        expect {
+          # aux data is missing, and therefore an error is expected.
+          json = msg_obj.encode
+        }.to raise_error(Schemata::EncodeError)
+      end
+    end
+  end
+end