schemata-staging 0.0.1.1 → 0.0.3.beta2

data/spec/{cloud_controller/cc_bar_spec.rb → component2/component2_bar_spec.rb}

@@ -1,7 +1,7 @@
-require 'schemata/cloud_controller/cloud_controller'
+require 'schemata/component2/component2'
 require 'support/helpers'
 
-describe Schemata::CloudController do
+describe Schemata::Component2 do
   before :each do
     @v10_msg = '{
       "min_version": 10,
@@ -37,21 +37,21 @@ describe Schemata::CloudController do
   describe "#decode" do
     describe "(current version is 10)" do
       before :each do
-        set_current_version(Schemata::CloudController::Bar, 10)
+        set_current_version(Schemata::Component2::Bar, 10)
       end
 
       after :each do
-        reset_version(Schemata::CloudController::Bar)
+        reset_version(Schemata::Component2::Bar)
       end
 
       it "should take a v10 msg and create a v10 obj" do
-        msg_obj = Schemata::CloudController::Bar.decode(@v10_msg)
+        msg_obj = Schemata::Component2::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::CloudController::Bar.decode(@v11_msg)
+        msg_obj = Schemata::Component2::Bar.decode(@v11_msg)
         msg_obj.bar1.should == "1"
         msg_obj.bar2.should == "second"
       end
@@ -59,21 +59,21 @@ describe Schemata::CloudController do
 
     describe "(current version is 11)" do
       before :each do
-        set_current_version(Schemata::CloudController::Bar, 11)
+        set_current_version(Schemata::Component2::Bar, 11)
       end
 
       after :each do
-        reset_version(Schemata::CloudController::Bar)
+        reset_version(Schemata::Component2::Bar)
       end
 
       it "should take a v10 msg and create a v11 obj" do
-        msg_obj = Schemata::CloudController::Bar.decode(@v10_msg)
+        msg_obj = Schemata::Component2::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::CloudController::Bar.decode(@v11_msg)
+        msg_obj = Schemata::Component2::Bar.decode(@v11_msg)
         msg_obj.bar1.should == 1
         msg_obj.bar3.should == "third"
       end
@@ -83,15 +83,15 @@ describe Schemata::CloudController do
   describe "#encode" do
     describe "(current version is 10)" do
       before :each do
-        set_current_version(Schemata::CloudController::Bar, 10)
+        set_current_version(Schemata::Component2::Bar, 10)
       end
 
       after :each do
-        reset_version(Schemata::CloudController::Bar)
+        reset_version(Schemata::Component2::Bar)
       end
 
       it "should take a v10 obj and encode a json msg" do
-        v10_obj = Schemata::CloudController::Bar::V10.new(@v10_hash)
+        v10_obj = Schemata::Component2::Bar::V10.new(@v10_hash)
         json_msg = v10_obj.encode
         returned_hash = Yajl::Parser.parse(json_msg)
 
@@ -108,12 +108,12 @@ describe Schemata::CloudController do
 
     describe "(current version is 11)" do
       before :each do
-        set_current_version(Schemata::CloudController::Bar, 11)
+        set_current_version(Schemata::Component2::Bar, 11)
       end
 
       it "should take a v11 obj and encode a json msg" do
         aux_data = {"bar2" => "second" }
-        v11_obj = Schemata::CloudController::Bar::V11.new(@v11_hash, aux_data)
+        v11_obj = Schemata::Component2::Bar::V11.new(@v11_hash, aux_data)
         json_msg = v11_obj.encode
         returned_hash = Yajl::Parser.parse(json_msg)
 
@@ -133,7 +133,7 @@ describe Schemata::CloudController do
       end
 
       after :each do
-        reset_version(Schemata::CloudController::Bar)
+        reset_version(Schemata::Component2::Bar)
       end
     end
   end

data/spec/dea_spec.rb

@@ -0,0 +1,6 @@
+require 'schemata/dea'
+require 'spec_helper'
+
+describe Schemata::Dea do
+  it_behaves_like "a schemata component"
+end

data/spec/health_manager_spec.rb

@@ -0,0 +1,6 @@
+require 'schemata/health_manager'
+require 'spec_helper'
+
+describe Schemata::HealthManager do
+  it_behaves_like 'a schemata component'
+end

data/spec/router_spec.rb

@@ -0,0 +1,6 @@
+require 'schemata/router'
+require 'spec_helper'
+
+describe Schemata::Router do
+  it_behaves_like "a schemata component"
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+Dir["./spec/support/**/*.rb"].sort.each { |f| require f }

data/spec/staging_spec.rb

@@ -0,0 +1,6 @@
+require 'schemata/staging'
+require 'spec_helper'
+
+describe Schemata::Staging do
+  it_behaves_like "a schemata component"
+end

data/spec/support/component_helpers.rb

@@ -0,0 +1,65 @@
+require 'support/helpers'
+require 'schemata/helpers/decamelize'
+
+shared_examples "a schemata component" do
+
+  described_class.constants.select { |x| x != :VERSION }.each do |msg_type|
+    describe ".mock_#{Schemata::Helpers.decamelize(msg_type.to_s)}" do
+      versions = described_class::const_get(msg_type).constants.select { |x| x =~ /V[0-9]+/ }
+      versions.map { |x| x = x.to_s[1..-1].to_i }.each do |version|
+        it_behaves_like "a mocking method", version do
+          let(:message_type)      { described_class::const_get(msg_type) }
+          let(:message_type_name) { msg_type.to_s }
+          let(:component)         { described_class }
+          let(:component_name)    { component.name.split("::")[1] }
+
+          let(:mock_method) { "mock_#{Schemata::Helpers.decamelize(msg_type)}"}
+        end
+      end
+    end
+
+    describe msg_type do
+      message_type = described_class::const_get(msg_type)
+      it_behaves_like "a message type", message_type do
+        let (:message_type)       { described_class::const_get(msg_type) }
+        let (:message_type_name)  { msg_type.to_s }
+        let (:component)          { described_class }
+        let (:component_name)     { component.name.split("::")[1] }
+
+        let (:mock_method)        { "mock_#{Schemata::Helpers.decamelize(msg_type)}" }
+      end
+    end
+  end
+
+end
+
+shared_examples "a mocking method" do |version|
+
+  context "when current_version is #{version}" do
+    before :each do
+      set_current_version(message_type, version)
+    end
+
+    after :each do
+      reset_version(message_type)
+    end
+
+    it "should return a V#{version} object if called with no argument" do
+      msg_obj = component.send(mock_method)
+      msg_obj.class.should == message_type::const_get("V#{version}")
+    end
+
+    1.upto(version) do |i|
+      it "should return a V#{i} object if called with input #{i}" do
+        msg_obj = component.send(mock_method, i)
+        msg_obj.class.should == message_type::const_get("V#{i}")
+      end
+    end
+
+    it "should raise an error if called with input > #{version}" do
+      expect {
+        msg_obj = component.send(mock_method, version + 1)
+      }.to raise_error(NameError)
+    end
+  end
+end

data/spec/support/helpers.rb

@@ -25,3 +25,58 @@ def greater_version?(version, benchmark)
   version = version[1..-1].to_i
   version > benchmark
 end
+
+def num_mandatory_fields(msg_obj)
+  optional = msg_obj.class.schema.optional_keys
+  mandatory = Set.new(msg_obj.class.schema.schemas.keys)
+  diff = mandatory - optional
+  return diff.size
+end
+
+def all_classes
+  all_classes = Set.new([Integer, String, Float, TrueClass, FalseClass, NilClass, Hash, Array])
+end
+
+def get_allowed_classes(schema)
+  case schema
+  when Membrane::Schema::Bool
+    return Set.new([TrueClass, FalseClass])
+  when Membrane::Schema::Enum
+    return Set.new(schema.elem_schemas.map {|x| get_allowed_classes(x)}).flatten
+  when Membrane::Schema::Class
+    return Set.new([schema.klass])
+  when Membrane::Schema::Record
+    return Set.new([Hash])
+  when Membrane::Schema::List
+    return Set.new([Array])
+  when Membrane::Schema::Value
+    return Set.new([schema.value.class])
+  end
+end
+
+def get_unallowed_classes(schema)
+  allowed_classes = get_allowed_classes(schema)
+  all_classes - allowed_classes
+end
+
+def default_value(klass)
+  # Yes this is silly
+  if klass == Integer
+    return 0
+  elsif klass == String
+    return "foo"
+  elsif klass == Float
+    return 3.14
+  elsif klass == TrueClass
+    return true
+  elsif klass == FalseClass
+    return false
+  elsif klass == NilClass
+    return nil
+  elsif klass == Hash
+    return {}
+  elsif klass == Array
+    return []
+  else
+  end
+end

data/spec/support/message_helpers.rb

@@ -0,0 +1,151 @@
+shared_examples "a message" do |msg|
+  version = msg.version
+
+  before :each do
+    set_current_version(message_type, version)
+  end
+
+  after :each do
+    reset_version(message_type)
+  end
+
+  describe "#new" do
+    it "should create a #{msg} object with an incomplete hash" do
+      mock_hash = component.send(mock_method, 1).contents
+      first_key = mock_hash.keys[0]
+      first_value = mock_hash[first_key]
+
+      msg_obj = message.new({first_key => first_value})
+      msg_obj.class.should == message
+      msg_obj.send(first_key).should == first_value
+    end
+
+    it "should raise an error if the hash contains incorrect types" do
+      mock_hash = component.send(mock_method, 1).contents
+      first_key = mock_hash.keys[0]
+      first_value = mock_hash[first_key]
+
+      schema = message.schema.schemas[first_key]
+      unallowed_classes = get_unallowed_classes(schema)
+      bad_value = default_value(unallowed_classes.to_a[0])
+
+      expect {
+        msg_obj = message.new({first_key => bad_value})
+      }.to raise_error(Schemata::UpdateAttributeError)
+    end
+
+    it "should stringify keys when they are symbols" do
+      mock_hash = component.send(mock_method, 1).contents
+      first_key = mock_hash.keys[0]
+      first_value = mock_hash[first_key]
+
+      input_hash = {
+        first_key.to_sym => first_value
+      }
+      msg_obj = message.new(input_hash)
+      msg_obj.send(first_key).should_not be_nil
+    end
+  end
+
+  describe "#encode" do
+    if version == 1
+      it "should return a Schemata-encoded json string, with a V1 hash also in the raw payload" do
+        msg_obj = component.send(mock_method, 1)
+        json = msg_obj.encode
+        json_hash = Yajl::Parser.parse(json)
+
+        json_hash.should have_key "V1"
+        json_hash.should have_key "min_version"
+
+        data = Schemata::Helpers.deep_copy(json_hash["V1"])
+
+        json_hash.delete("V1")
+        json_hash.delete("min_version")
+
+        json_hash.should == data
+      end
+    else
+      it "should return a Schemata-encoded json string, with no raw payload" do
+        msg_obj = component.send(mock_method, version)
+        json = msg_obj.encode
+        json_hash = Yajl::Parser.parse(json)
+
+        1.upto(version) do |i|
+          json_hash.should have_key "V#{i}"
+        end
+        json_hash.should have_key "min_version"
+
+        data = Schemata::Helpers.deep_copy(json_hash["V#{version}"])
+        1.upto(version) do |i|
+          json_hash.delete("V#{i}")
+        end
+        json_hash.delete("min_version")
+
+        json_hash.should be_empty
+      end
+    end
+  end
+
+  msg.schema.schemas.keys.each do |attr|
+    describe "##{attr}" do
+      it "should return the attribute if it was specified at instantiation" do
+        mock_value = component.send(mock_method, version).contents[attr]
+        msg_obj = message.new({ attr => mock_value })
+        msg_obj.send(attr).should == mock_value
+      end
+
+      it "should return the attribute if it was set with an attr writer" do
+        mock_value = component.send(mock_method, version).contents[attr]
+        msg_obj = message.new
+        msg_obj.send("#{attr}=", mock_value)
+        msg_obj.send(attr).should == mock_value
+      end
+
+      it "should return nil if the attribute was never set" do
+        msg_obj = message.new
+        msg_obj.send(attr).should be_nil
+      end
+
+      if msg.schema.optional_keys.include? attr
+        context "the attribute is optional" do
+          it "should allow nil values during instantiation" do
+            mock_value = component.send(mock_method, version).contents[attr]
+            hash = { attr => mock_value }
+            msg_obj = message.new(hash)
+          end
+
+          it "should be able to set the attribute to nil" do
+            msg_obj = message.new
+            msg_obj.send("#{attr}=", nil)
+          end
+        end
+      end
+    end
+
+    describe "##{attr}=" do
+      it "should change the attribute and return the new value" do
+        mock_value = component.send(mock_method, version).contents[attr]
+        msg_obj = message.new({ attr => mock_value })
+        ret = (msg_obj.send("#{attr}=", mock_value))
+        msg_obj.send(attr).should == mock_value
+        ret.should == mock_value
+      end
+
+      unless msg.schema.schemas[attr].kind_of? Membrane::Schema::Any
+        it "should raise an error if the wrong type is written" do
+          mock_value = component.send(mock_method, version).contents[attr]
+
+          schema = message.schema.schemas[attr]
+          unallowed_classes = get_unallowed_classes(schema)
+          bad_value = default_value(unallowed_classes.to_a[0])
+
+          msg_obj = message.new
+
+          expect {
+            msg_obj.send("#{attr}=", bad_value)
+          }.to raise_error(Schemata::UpdateAttributeError)
+        end
+      end
+    end
+  end
+end

data/spec/support/message_type_helpers.rb

@@ -0,0 +1,175 @@
+shared_examples "a message type" do |msg_type|
+
+  versions = msg_type.constants.select {|x| x =~ /V[0-9]+/ }
+    .map {|x| x.to_s[1..-1].to_i}
+
+  describe ".decode" do
+    context "when the current version is 1" do
+      before :each do
+        set_current_version(message_type, 1)
+      end
+
+      after :each do
+        reset_version(message_type)
+      end
+
+      it "should return a V1 object given a flat hash" do
+        data = component.send(mock_method, 1).contents
+        json = Yajl::Encoder.encode(data)
+        msg_obj = message_type.decode(json)
+        msg_obj.class.should == message_type::V1
+
+        message_type::V1.schema.schemas.keys do |key|
+          msg_obj.send(key).should == data[key]
+        end
+      end
+
+      it "should return a V1 object given a V1-encoded json" do
+        data = component.send(mock_method, 1).contents
+
+        msg_hash = {"V1" => data, "min_version" => 1}
+        json = Yajl::Encoder.encode(msg_hash)
+
+        msg_obj = message_type.decode(json)
+        msg_obj.class.should == message_type::V1
+
+        message_type::V1.schema.schemas.keys do |key|
+          msg_obj.send(key).should == data[key]
+        end
+      end
+
+      it "should return a V1 object given a mixed (V1-encoded + flat hash) json" do
+        data = component.send(mock_method, 1).contents
+        msg_hash = {
+          "V1" => data,
+          "min_version" => 1
+        }.merge(Schemata::Helpers.deep_copy(data))
+        json = Yajl::Encoder.encode(msg_hash)
+
+        msg_obj = message_type.decode(json)
+        msg_obj.class.should == message_type::V1
+
+        message_type::V1.schema.schemas.keys do |key|
+          msg_obj.send(key).should == data[key]
+        end
+      end
+
+      it "should return a V1 object when given a V2-encoded json" do
+        v2_hash = component.send(mock_method, 1).contents
+        msg_hash = {
+          "V2" => v2_hash,
+          "V1" => {},
+          "min_version" => 1
+        }
+        json = Yajl::Encoder.encode(msg_hash)
+
+        msg_obj = message_type.decode(json)
+        msg_obj.class.should == message_type::V1
+
+        message_type::V1.schema.schemas.keys do |key|
+          msg_obj.send(key).should == data[key]
+        end
+      end
+
+      it "should raise an error if the input does not have the valid Schemata \
+structure or a complete flash hash" do
+        mock_obj = component.send(mock_method, 1)
+        mock_hash = mock_obj.contents
+
+        if num_mandatory_fields(mock_obj) > 1
+          first_key = mock_hash.keys[0]
+          first_value = mock_hash[first_key]
+
+          json = Yajl::Encoder.encode({ first_key => first_value})
+        else
+          json = Yajl::Encoder.encode({})
+        end
+        expect {
+          msg_obj = message_type.decode(json)
+        }.to raise_error(Schemata::DecodeError)
+      end
+    end
+
+    if versions.include?(2)
+      context "when the current version is 2" do
+        before :each do
+          set_current_version(message_type, 2)
+        end
+
+        after :each do
+          reset_version(message_type)
+        end
+
+        it "should raise an error given a flat hash" do
+          data = component.send(mock_method, 2).contents
+          json = Yajl::Encoder.encode(data)
+          expect {
+            msg_obj = message_type.decode(json)
+          }.to raise_error(Schemata::DecodeError)
+        end
+
+        it "should return a V2 object a given a mixed (flat hash + V1-encoded) json" do
+          msg_hash = component.send(mock_method, 2).contents
+          v1_hash = Schemata::Helpers.deep_copy(msg_hash)
+          msg_hash["V1"] = v1_hash
+          msg_hash["min_version"] = 1
+
+          json = Yajl::Encoder.encode(msg_hash)
+
+          msg_obj = message_type.decode(json)
+          msg_obj.class.should == message_type::V2
+
+          message_type::V2.schema.schemas.keys.each do |key|
+            msg_obj.send(key).should == v1_hash[key]
+          end
+        end
+
+        it "should return a V2 object given a V1-encoded json" do
+          v1_hash = component.send(mock_method, 1).contents
+          msg_hash = {"V1" => v1_hash, 'min_version' => 1}
+
+          json = Yajl::Encoder.encode(msg_hash)
+
+          msg_obj = message_type.decode(json)
+          msg_obj.class.should == message_type::V2
+
+          message_type::V2.schema.schemas.keys.each do |key|
+            msg_obj.send(key).should == v1_hash[key]
+          end
+        end
+
+        it "should return a V2 object given a V2-encoded object" do
+          data = component.send(mock_method, 2).contents
+          v2_hash = Schemata::Helpers.deep_copy(data)
+          msg_hash = {"V2" => v2_hash, "V1" => {}, "min_version" => 1}
+
+          json = Yajl::Encoder.encode(msg_hash)
+
+          msg_obj = message_type.decode(json)
+          msg_obj.class.should == message_type::V2
+
+          message_type::V2.schema.schemas.keys.each do |key|
+            msg_obj.send(key).should == data[key]
+          end
+        end
+      end
+    end
+  end
+
+  # The first two versions have exceptional behavior, starting from
+  # version 3, all versions should have the same unit tests
+  versions.select { |x| x > 2 }.each do |version|
+
+  end
+
+  # Test message version types
+  versions.each do |version|
+    msg = msg_type::const_get("V#{version}")
+    describe "V#{version}" do
+      it_behaves_like "a message", msg do
+        let (:message)            { message_type::const_get("V#{version}") }
+        let (:message_name)       { message.to_s }
+      end
+    end
+  end
+end

metadata

@@ -1,8 +1,8 @@
 --- !ruby/object:Gem::Specification
 name: schemata-staging
 version: !ruby/object:Gem::Version
-  version: 0.0.1.1
-  prerelease: 
+  version: 0.0.3.beta2
+  prerelease: 6
 platform: ruby
 authors:
 - dsabeti
@@ -99,24 +99,36 @@ 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/componentbase.rb
+- lib/schemata/common/error.rb
+- lib/schemata/common/msgbase.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/decamelize.rb
 - lib/schemata/helpers/hash_copy.rb
-- spec/cloud_controller/cc_bar_spec.rb
+- lib/schemata/helpers/stringify.rb
+- lib/schemata/staging/message/message_v1.rb
+- lib/schemata/staging/message/message_v2.rb
+- lib/schemata/staging/message.rb
+- lib/schemata/staging/version.rb
+- lib/schemata/staging.rb
+- spec/cloud_controller_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/component2/component2_bar_spec.rb
+- spec/dea_spec.rb
+- spec/health_manager_spec.rb
+- spec/router_spec.rb
+- spec/spec_helper.rb
+- spec/staging_spec.rb
+- spec/support/component_helpers.rb
 - spec/support/helpers.rb
+- spec/support/message_helpers.rb
+- spec/support/message_type_helpers.rb
 homepage: http://www.cloudfoundry.org
 licenses: []
 post_install_message: 
@@ -132,9 +144,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
@@ -142,12 +154,20 @@ signing_key:
 specification_version: 3
 summary: validation for cloundfoundry stager messages
 test_files:
-- spec/cloud_controller/cc_bar_spec.rb
+- spec/cloud_controller_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/component2/component2_bar_spec.rb
+- spec/dea_spec.rb
+- spec/health_manager_spec.rb
+- spec/router_spec.rb
+- spec/spec_helper.rb
+- spec/staging_spec.rb
+- spec/support/component_helpers.rb
 - spec/support/helpers.rb
+- spec/support/message_helpers.rb
+- spec/support/message_type_helpers.rb