schemata-router 0.0.1.beta1

data/spec/support/helpers.rb

@@ -0,0 +1,54 @@
+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
+
+def decamelize(str)
+  words = []
+  curr_word = ""
+  0.upto(str.length - 1) do |i|
+    ch = str[i]
+    if ch =~ /[A-Z]/
+      words.push(curr_word)
+      curr_word = ""
+    end
+    curr_word += ch
+  end
+  words.push(curr_word)
+  words.map! { |x| x.downcase }
+
+  # If the first letter is capitalized, then the first word here is empty
+  words.shift if words[0] == ""
+
+  words.join('_')
+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

data/spec/support/message_helpers.rb

@@ -0,0 +1,138 @@
+shared_examples "a message" do
+
+  version = described_class.version
+
+  let(:component_name)    { described_class.name.split("::")[1] }
+  let(:message_type_name) { described_class.name.split("::")[2] }
+  let(:message_name)      { described_class.name.split("::")[3] }
+
+  let(:component)         { Schemata::const_get(component_name) }
+  let(:message_type)      { component::const_get(message_type_name) }
+  let(:message)           { described_class }
+
+  let(:mock_method)       { "mock_#{decamelize(message_type_name)}" }
+
+  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 #{described_class} 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]
+      if first_value.kind_of? Integer
+        bad_value = "foo"
+      else
+        bad_value = 1
+      end
+
+      expect {
+        msg_obj = message.new({first_key => bad_value})
+      }.to raise_error(Schemata::UpdateAttributeError)
+    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::HashCopyHelpers.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::HashCopyHelpers.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
+
+  described_class.schema.schemas.keys.each do |attr|
+    describe "##{attr}" do
+      it "should 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
+    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 described_class.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]
+
+          if mock_value.kind_of? Integer
+            bad_value = "foo"
+          else
+            bad_value = 1
+          end
+
+          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,171 @@
+shared_examples "a message type" do
+
+  versions = described_class.constants.select {|x| x =~ /V[0-9]+/ }
+    .map {|x| x.to_s[1..-1].to_i}
+
+  let(:message_type_name) { described_class.name.split("::")[2] }
+  let(:message_type)      { described_class }
+  let(:component_name)    { described_class.name.split("::")[1] }
+  let(:component)         { Schemata::const_get(component_name) }
+
+  let(:mock_method)       { "mock_#{decamelize(message_type_name)}" }
+
+  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::HashCopyHelpers.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
+  end
+
+  if versions.include?(2)
+    context "when 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::HashCopyHelpers.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::HashCopyHelpers.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
+
+  # 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
+end

metadata

@@ -0,0 +1,158 @@
+--- !ruby/object:Gem::Specification
+name: schemata-router
+version: !ruby/object:Gem::Version
+  version: 0.0.1.beta1
+  prerelease: 6
+platform: ruby
+authors:
+- dsabeti
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-19 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 Router messages and validate messages\n      against
+  defined schema\n"
+email:
+- support@cloudfoundry.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/schemata/router/register_request.rb
+- lib/schemata/router/register_request/register_request_v1.rb
+- lib/schemata/router/start_message.rb
+- lib/schemata/router/version.rb
+- lib/schemata/router/start_message/start_message_v1.rb
+- lib/schemata/router.rb
+- lib/schemata/common/msgtypebase.rb
+- lib/schemata/common/parsed_msg.rb
+- lib/schemata/common/msgbase.rb
+- lib/schemata/common/error.rb
+- lib/schemata/helpers/stringify.rb
+- lib/schemata/helpers/hash_copy.rb
+- spec/common/helpers_spec.rb
+- spec/common/parsed_msg_spec.rb
+- spec/router/register_request_spec.rb
+- spec/router/router_spec.rb
+- spec/router/start_message_spec.rb
+- spec/spec_helper.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: 
+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: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: validation for cloundfoundry Router messages
+test_files:
+- spec/common/helpers_spec.rb
+- spec/common/parsed_msg_spec.rb
+- spec/router/register_request_spec.rb
+- spec/router/router_spec.rb
+- spec/router/start_message_spec.rb
+- spec/spec_helper.rb
+- spec/support/component_helpers.rb
+- spec/support/helpers.rb
+- spec/support/message_helpers.rb
+- spec/support/message_type_helpers.rb