schemata-staging 0.0.1.1

data/spec/component/foo_spec.rb

@@ -0,0 +1,214 @@
+require 'schemata/component/foo'
+require 'schemata/common/error'
+require 'support/helpers'
+
+describe Schemata::Component::Foo do
+  describe "V10" do
+    it "should define accessors for the schema" do
+      v10_obj = Schemata::Component::Foo::V10.new
+      v10_obj.respond_to?(:foo1).should be_true
+      v10_obj.respond_to?(:foo1=).should be_true
+      v10_obj.respond_to?(:foo2).should be_true
+      v10_obj.respond_to?(:foo2=).should be_true
+    end
+
+    it "should not raise an error if an incomplete but valid hash is given" do
+      v10_hash = {"foo1" => "foo"}
+      expect { Schemata::Component::Foo::V10.new(v10_hash) }.to_not raise_error
+    end
+
+    it "should raise an error if an incomplete and invalid hash is given" do
+      v10_hash = {"foo1" => 1}
+      expect {
+        Schemata::Component::Foo::V10.new(v10_hash)
+      }.to raise_error(Schemata::UpdateAttributeError)
+    end
+
+    it "should not raise an error if an attribute is correctly assigned" do
+      foo_obj = Schemata::Component.mock_foo 10
+      expect { foo_obj.foo1 = "new name" }.to_not raise_error
+    end
+
+    it "should raise an error if an attribute is incorrectly assigned" do
+      foo_obj = Schemata::Component.mock_foo 10
+      expect { foo_obj.foo1 = 1 }.to raise_error(Schemata::UpdateAttributeError)
+    end
+
+    it "should not raise an error if an incomplete msg_obj is updated \
+correctly" do
+      v10_hash = {"foo1" => "foo"}
+      v10_obj = Schemata::Component::Foo::V10.new(v10_hash)
+      expect { v10_obj.foo1 = "new name" }.to_not raise_error
+    end
+
+    it "should raise an error if an incomplete msg_obj is updated \
+incorrectly" do
+      v10_hash = {"foo1" => "foo"}
+      v10_obj = Schemata::Component::Foo::V10.new(v10_hash)
+      expect { v10_obj.foo1 = 1 }.to raise_error(Schemata::UpdateAttributeError)
+    end
+  end
+
+  describe "V11" do
+    it "should define accessors for the schema" do
+      v11_obj = Schemata::Component::Foo::V11.new
+      v11_obj.respond_to?(:foo1).should be_true
+      v11_obj.respond_to?(:foo1=).should be_true
+      v11_obj.respond_to?(:foo2).should be_true
+      v11_obj.respond_to?(:foo2=).should be_true
+      v11_obj.respond_to?(:foo3).should be_true
+      v11_obj.respond_to?(:foo3=).should be_true
+    end
+
+    it "should not raise an error if an incomplete but valid hash is given" do
+      v11_hash = {"foo1" => "foo"}
+      expect { Schemata::Component::Foo::V11.new(v11_hash) }.to_not raise_error
+    end
+
+    it "should raise an error if an incomplete and invalid hash is given" do
+      v11_hash = {"foo1" => 1}
+      expect {
+        v11_obj = Schemata::Component::Foo::V11.new(v11_hash)
+      }.to raise_error(Schemata::UpdateAttributeError)
+    end
+
+    it "should not raise an error if an attribute is correctly assigned" do
+      foo_obj = Schemata::Component.mock_foo 11
+      expect { foo_obj.foo2 = 10 }.to_not raise_error
+    end
+
+    it "should raise an error if an attribute is incorrectly assigned" do
+      foo_obj = Schemata::Component.mock_foo 11
+      expect {
+        foo_obj.foo2 = "foo"
+      }.to raise_error(Schemata::UpdateAttributeError)
+    end
+
+    it "should not raise an error if an incomplete msg_obj is updated \
+correctly" do
+      v11_hash = {"foo1" => "foo"}
+      v11_obj = Schemata::Component::Foo::V11.new(v11_hash)
+      expect { v11_obj.foo1 = "new name" }.to_not raise_error
+    end
+
+    it "should raise an error if an incomplete msg_obj is updated \
+incorrectly" do
+      v11_hash = {"foo1" => "foo"}
+      v11_obj = Schemata::Component::Foo::V11.new(v11_hash)
+      expect {
+        v11_obj.foo1 = 1
+      }.to raise_error(Schemata::UpdateAttributeError)
+    end
+  end
+
+  describe "V12" do
+    it "should define accessors for the schema" do
+      v12_obj = Schemata::Component::Foo::V12.new
+      v12_obj.respond_to?(:foo1).should be_true
+      v12_obj.respond_to?(:foo1=).should be_true
+      v12_obj.respond_to?(:foo2).should be_true
+      v12_obj.respond_to?(:foo2=).should be_true
+      v12_obj.respond_to?(:foo3).should be_true
+      v12_obj.respond_to?(:foo3=).should be_true
+    end
+
+    it "should not raise an error if an incomplete but valid hash is given" do
+      v12_hash = {"foo1" => "foo"}
+      expect { Schemata::Component::Foo::V12.new(v12_hash) }.to_not raise_error
+    end
+
+    it "should raise an error if an incomplete and invalid hash is given" do
+      v12_hash = {"foo1" => 1}
+      expect {
+        Schemata::Component::Foo::V12.new(v12_hash)
+      }.to raise_error(Schemata::UpdateAttributeError)
+    end
+
+    it "should not raise an error if an attribute is correctly assigned" do
+      foo_obj = Schemata::Component.mock_foo 12
+      expect { foo_obj.foo3 = [1, 2] }.to_not raise_error
+    end
+
+    it "should raise an error if an attribute is incorrectly assigned" do
+      foo_obj = Schemata::Component.mock_foo 12
+      expect {
+        foo_obj.foo3 = 1
+      }.to raise_error(Schemata::UpdateAttributeError)
+    end
+
+    it "should not raise an error if an incomplete msg_obj is updated \
+correctly" do
+      v12_hash = {"foo1" => "foo"}
+      v12_obj = Schemata::Component::Foo::V12.new(v12_hash)
+      expect { v12_obj.foo1 = "new name" }.to_not raise_error
+    end
+
+    it "should raise an error if an incomplete msg_obj is updated \
+incorrectly" do
+      v12_hash = {"foo1" => "foo"}
+      v12_obj = Schemata::Component::Foo::V12.new(v12_hash)
+      expect {
+        v12_obj.foo1 = 1
+      }.to raise_error(Schemata::UpdateAttributeError)
+    end
+  end
+
+  describe "V13" do
+    it "should define accessors for the schema" do
+      v13_obj = Schemata::Component::Foo::V13.new
+      v13_obj.respond_to?(:foo1).should be_true
+      v13_obj.respond_to?(:foo1=).should be_true
+      v13_obj.respond_to?(:foo3).should be_true
+      v13_obj.respond_to?(:foo3=).should be_true
+      v13_obj.respond_to?(:foo4).should be_true
+      v13_obj.respond_to?(:foo4=).should be_true
+    end
+
+    it "should not raise an error if an incomplete but valid hash is given" do
+      v13_hash = {"foo1" => "foo"}
+      expect { Schemata::Component::Foo::V13.new(v13_hash) }.to_not raise_error
+    end
+
+    it "should raise an error if an incomplete and invalid hash is given" do
+      v13_hash = {"foo1" => 1}
+      expect {
+        Schemata::Component::Foo::V13.new(v13_hash)
+      }.to raise_error(Schemata::UpdateAttributeError)
+    end
+
+    it "should not raise an error if an attribute is correctly assigned" do
+      foo_obj = Schemata::Component.mock_foo 13
+      expect { foo_obj.foo4 = "foobar" }.to_not raise_error
+    end
+
+    it "should raise an error if an attribute is incorrectly assigned" do
+      foo_obj = Schemata::Component.mock_foo 13
+      expect {
+        foo_obj.foo4 =1
+      }.to raise_error(Schemata::UpdateAttributeError)
+    end
+
+    it "should raise an error if an accessed field was removed" do
+      foo_obj = Schemata::Component.mock_foo 13
+      expect {
+        foo_obj.foo2
+      }.to raise_error
+    end
+
+    it "should not raise an error if an incomplete msg_obj is updated \
+correctly" do
+      v13_hash = {"foo1" => "foo"}
+      v13_obj = Schemata::Component::Foo::V13.new(v13_hash)
+      expect { v13_obj.foo1 = "new name" }.to_not raise_error
+    end
+
+    it "should raise an error if an incomplete msg_obj is updated \
+incorrectly" do
+      v13_hash = {"foo1" => "foo"}
+      v13_obj = Schemata::Component::Foo::V13.new(v13_hash)
+      expect {
+        v13_obj.foo1 = 1
+      }.to raise_error(Schemata::UpdateAttributeError)
+    end
+  end
+end

data/spec/staging/staging_message_spec.rb

@@ -0,0 +1,186 @@
+require 'yajl'
+require 'support/helpers'
+require 'schemata/staging'
+
+describe Schemata::Staging do
+  describe ".mock_message" do
+    it "should return a V1 object" do
+      msg_obj = Schemata::Staging.mock_message(1)
+      msg_obj.class.should == Schemata::Staging::Message::V1
+    end
+  end
+end
+
+describe Schemata::Staging::Message do
+  describe ".decode" do
+    context "current version is 1" do
+
+      before :each do
+        set_current_version(Schemata::Staging::Message, 1)
+      end
+
+      after :each do
+        reset_version(Schemata::Staging::Message)
+      end
+
+      it "should return a V1 object when given a flat hash" do
+        json = Yajl::Encoder.encode(
+          Schemata::Staging::Message::V1::MOCK_VALUES)
+        msg_obj = Schemata::Staging::Message.decode(json)
+        msg_obj.class.should == Schemata::Staging::Message::V1
+
+        msg_obj.app_id.should == 1
+        msg_obj.download_uri.should == "http://foobar@172.0.0.0:100/download"
+        msg_obj.upload_uri.should == "http://foobar@172.0.0.0:100/upload"
+        msg_obj.properties.should ==
+          Schemata::Staging::Message::V1::MOCK_VALUES["properties"]
+      end
+
+      it "should return a V1 object when given a V1-encoded json" do
+        v1_hash = Schemata::HashCopyHelpers.deep_copy(
+          Schemata::Staging::Message::V1::MOCK_VALUES)
+        msg_hash = {"V1" => v1_hash, "min_version" => 1}
+
+        json = Yajl::Encoder.encode(msg_hash)
+
+        msg_obj = Schemata::Staging::Message.decode(json)
+        msg_obj.class.should == Schemata::Staging::Message::V1
+
+        msg_obj.app_id.should == 1
+        msg_obj.download_uri.should == "http://foobar@172.0.0.0:100/download"
+        msg_obj.upload_uri.should == "http://foobar@172.0.0.0:100/upload"
+        msg_obj.properties.should ==
+          Schemata::Staging::Message::V1::MOCK_VALUES["properties"]
+      end
+
+      it "should return a V1 object when given a mixed (flat hash + V1-encoded) json" do
+        msg_hash = Schemata::HashCopyHelpers.deep_copy(
+          Schemata::Staging::Message::V1::MOCK_VALUES)
+
+        v1_hash = Schemata::HashCopyHelpers.deep_copy(msg_hash)
+        msg_hash["V1"] = v1_hash
+
+        msg_hash["min_version"] = 1
+
+        json = Yajl::Encoder.encode(msg_hash)
+
+        msg_obj = Schemata::Staging::Message.decode(json)
+        msg_obj.class.should == Schemata::Staging::Message::V1
+
+        msg_obj.app_id.should == 1
+        msg_obj.download_uri.should == "http://foobar@172.0.0.0:100/download"
+        msg_obj.upload_uri.should == "http://foobar@172.0.0.0:100/upload"
+        msg_obj.properties.should ==
+          Schemata::Staging::Message::V1::MOCK_VALUES["properties"]
+      end
+
+      it "should return a V1 object when given a V2-encoded json message" do
+        v2_hash = Schemata::HashCopyHelpers.deep_copy(
+          Schemata::Staging::Message::V1::MOCK_VALUES
+        )
+        msg_hash = {
+          "V2" => v2_hash, "V1" => {}, "min_version" => 1
+        }
+
+        json = Yajl::Encoder.encode(msg_hash)
+
+        msg_obj = Schemata::Staging::Message.decode(json)
+        msg_obj.class.should == Schemata::Staging::Message::V1
+
+        msg_obj.app_id.should == 1
+        msg_obj.download_uri.should == "http://foobar@172.0.0.0:100/download"
+        msg_obj.upload_uri.should == "http://foobar@172.0.0.0:100/upload"
+        msg_obj.properties.should ==
+          Schemata::Staging::Message::V1::MOCK_VALUES["properties"]
+      end
+
+      it "should raise an error if the input does not have the valid Schemata structure or a complete flat hash of the data" do
+        json = Yajl::Encoder.encode({"app_id" => 1})
+        expect {
+          msg_obj = Schemata::Staging::Message.decode(json)
+        }.to raise_error(Schemata::DecodeError)
+      end
+    end
+  end
+end
+
+describe Schemata::Staging::Message::V1 do
+  before :each do
+    set_current_version(Schemata::Staging::Message, 1)
+  end
+
+  after :each do
+    reset_version(Schemata::Staging::Message)
+  end
+
+  describe "#new" do
+    it "should create a V1 obj with an incomplete hash" do
+      msg_obj = Schemata::Staging::Message::V1.new({"app_id" => 1})
+    end
+
+    it "should raise an error if the hash contains incorrect types" do
+      expect {
+        msg_obj = Schemata::Staging::Message::V1.new({"app_id" => "foo"})
+      }.to raise_error(Schemata::UpdateAttributeError)
+    end
+  end
+
+  describe "#encode" do
+    it "should return a json string, with V1 hash also in the raw payload" do
+      msg_obj = Schemata::Staging.mock_message(1)
+      json = msg_obj.encode
+      json_hash = Yajl::Parser.parse(json)
+
+      json_hash.should have_key "V1"
+      json_hash.should have_key "min_version"
+
+      v1_hash = json_hash['V1']
+      min_version = json_hash['min_version']
+      json_hash.delete('V1')
+      json_hash.delete('min_version')
+
+      v1_hash.should == json_hash
+    end
+
+    it "should raise an error if the object is not complete" do
+      msg_obj = Schemata::Staging::Message::V1.new({"app_id" => 1})
+      expect {
+        json = msg_obj.encode
+      }.to raise_error(Schemata::EncodeError)
+    end
+  end
+
+  describe "#app_id" do
+    it "should return the app_id if it was specified at instantiation" do
+      msg_obj = Schemata::Staging::Message::V1.new({"app_id" => 1})
+      msg_obj.app_id.should == 1
+    end
+
+    it "should return the app_id if it was set with an attr wrtier" do 
+      msg_obj = Schemata::Staging::Message::V1.new({})
+      msg_obj.app_id = 1
+      msg_obj.app_id.should == 1
+    end
+
+    it "should return nil if the app_id was never set" do
+      msg_obj = Schemata::Staging::Message::V1.new({})
+      msg_obj.app_id.should be_nil
+    end
+  end
+
+  describe "#app_id=" do
+    it "should change the app_id and return the new value" do
+      msg_obj = Schemata::Staging::Message::V1.new({"app_id" => 1})
+      ret = (msg_obj.app_id = 2)
+      msg_obj.app_id.should == 2
+      ret.should == 2
+    end
+
+    it "should raise an error if the wrong type is written" do
+      msg_obj = Schemata::Staging::Message::V1.new({})
+      expect {
+        msg_obj.app_id = "foo"
+      }.to raise_error(Schemata::UpdateAttributeError)
+    end
+  end
+end

data/spec/support/helpers.rb

@@ -0,0 +1,27 @@
+def set_current_version(msg_type, version)
+  msg_type.stub(:current_version).and_return(version)
+  @curr_class = msg_type.current_class
+
+  @future_versions = {}
+  msg_type::constants.each do |v|
+    next if !is_message_version?(v) || !greater_version?(v, version)
+    @future_versions[v] = msg_type::const_get(v)
+    msg_type.send(:remove_const, v)
+  end
+end
+
+def reset_version(msg_type)
+  @future_versions.each do |v, klass|
+    msg_type::const_set(v, klass)
+  end
+  @future_versions
+end
+
+def is_message_version?(constant)
+  !!(constant =~ /^V[0-9]+$/)
+end
+
+def greater_version?(version, benchmark)
+  version = version[1..-1].to_i
+  version > benchmark
+end

metadata

@@ -0,0 +1,153 @@
+--- !ruby/object:Gem::Specification
+name: schemata-staging
+version: !ruby/object:Gem::Version
+  version: 0.0.1.1
+  prerelease: 
+platform: ruby
+authors:
+- dsabeti
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: membrane
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yajl-ruby
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ci_reporter
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! "    Specify schema for staging messages and validate messages\n      against
+  defined schema\n"
+email:
+- support@cloudfoundry.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/schemata/staging/message/message_v1.rb
+- lib/schemata/staging/version.rb
+- lib/schemata/staging/message.rb
+- lib/schemata/common/msgtypebase.rb
+- lib/schemata/common/parsed_msg.rb
+- lib/schemata/common/msgbase.rb
+- lib/schemata/common/error.rb
+- lib/schemata/staging.rb
+- lib/schemata/helpers/hash_copy.rb
+- spec/cloud_controller/cc_bar_spec.rb
+- spec/common/helpers_spec.rb
+- spec/common/parsed_msg_spec.rb
+- spec/component/aux_data_spec.rb
+- spec/component/component_bar_spec.rb
+- spec/component/component_foo_spec.rb
+- spec/component/foo_spec.rb
+- spec/staging/staging_message_spec.rb
+- spec/support/helpers.rb
+homepage: http://www.cloudfoundry.org
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: validation for cloundfoundry stager messages
+test_files:
+- spec/cloud_controller/cc_bar_spec.rb
+- spec/common/helpers_spec.rb
+- spec/common/parsed_msg_spec.rb
+- spec/component/aux_data_spec.rb
+- spec/component/component_bar_spec.rb
+- spec/component/component_foo_spec.rb
+- spec/component/foo_spec.rb
+- spec/staging/staging_message_spec.rb
+- spec/support/helpers.rb