schemata-health_manager 0.0.1.beta1

data/spec/support/component_helpers.rb

@@ -0,0 +1,51 @@
+require 'support/helpers'
+
+shared_examples "a schemata component" do
+
+  described_class.constants.select { |x| x != :VERSION }.each do |msg_type|
+    describe ".mock_#{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_#{decamelize(msg_type)}"}
+        end
+      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

@@ -0,0 +1,102 @@
+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
+
+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,135 @@
+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]
+
+      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
+  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]
+
+          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,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,240 @@
+--- !ruby/object:Gem::Specification
+name: schemata-health_manager
+version: !ruby/object:Gem::Version
+  version: 0.0.1.beta1
+  prerelease: 6
+platform: ruby
+authors:
+- dsabeti
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-10 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: vcap_common
+  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 Health Manager messages and validate messages\n
+  \     against defined schema\n"
+email:
+- support@cloudfoundry.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/schemata/health_manager/status_request.rb
+- lib/schemata/health_manager/status_crashed_response.rb
+- lib/schemata/health_manager/status_flapping_response.rb
+- lib/schemata/health_manager/status_flapping_response/status_flapping_response_v1.rb
+- lib/schemata/health_manager/health_request/health_request_v1.rb
+- lib/schemata/health_manager/health_response/health_response.rb
+- lib/schemata/health_manager/version.rb
+- lib/schemata/health_manager/health_request.rb
+- lib/schemata/health_manager/health_response.rb
+- lib/schemata/health_manager/status_request/status_request_v1.rb
+- lib/schemata/health_manager/status_crashed_response/status_crashed_response_v1.rb
+- lib/schemata/health_manager.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/cloud_controller/cloud_controller_spec.rb
+- spec/cloud_controller/droplet_updated_message_spec.rb
+- spec/cloud_controller/hm_start_request_spec.rb
+- spec/cloud_controller/hm_stop_request_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/component2/component2_bar_spec.rb
+- spec/dea/advertise_message_spec.rb
+- spec/dea/dea_spec.rb
+- spec/dea/dea_status_response_spec.rb
+- spec/dea/discover_request_spec.rb
+- spec/dea/droplet_status_response_spec.rb
+- spec/dea/exit_message_spec.rb
+- spec/dea/find_droplet_request_spec.rb
+- spec/dea/find_droplet_response_spec.rb
+- spec/dea/heartbeat_response_spec.rb
+- spec/dea/hello_message_spec.rb
+- spec/dea/start_request_spec.rb
+- spec/dea/stop_request_spec.rb
+- spec/dea/update_request_spec.rb
+- spec/health_manager/health_manager_spec.rb
+- spec/health_manager/health_request_spec.rb
+- spec/health_manager/health_response_spec.rb
+- spec/health_manager/status_crashed_response_spec.rb
+- spec/health_manager/status_flapping_response_spec.rb
+- spec/health_manager/status_request_spec.rb
+- spec/router/register_request_spec.rb
+- spec/router/router_spec.rb
+- spec/router/start_message_spec.rb
+- spec/spec_helper.rb
+- spec/staging/staging_message_spec.rb
+- spec/staging/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: 
+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 health manager messages
+test_files:
+- spec/cloud_controller/cloud_controller_spec.rb
+- spec/cloud_controller/droplet_updated_message_spec.rb
+- spec/cloud_controller/hm_start_request_spec.rb
+- spec/cloud_controller/hm_stop_request_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/component2/component2_bar_spec.rb
+- spec/dea/advertise_message_spec.rb
+- spec/dea/dea_spec.rb
+- spec/dea/dea_status_response_spec.rb
+- spec/dea/discover_request_spec.rb
+- spec/dea/droplet_status_response_spec.rb
+- spec/dea/exit_message_spec.rb
+- spec/dea/find_droplet_request_spec.rb
+- spec/dea/find_droplet_response_spec.rb
+- spec/dea/heartbeat_response_spec.rb
+- spec/dea/hello_message_spec.rb
+- spec/dea/start_request_spec.rb
+- spec/dea/stop_request_spec.rb
+- spec/dea/update_request_spec.rb
+- spec/health_manager/health_manager_spec.rb
+- spec/health_manager/health_request_spec.rb
+- spec/health_manager/health_response_spec.rb
+- spec/health_manager/status_crashed_response_spec.rb
+- spec/health_manager/status_flapping_response_spec.rb
+- spec/health_manager/status_request_spec.rb
+- spec/router/register_request_spec.rb
+- spec/router/router_spec.rb
+- spec/router/start_message_spec.rb
+- spec/spec_helper.rb
+- spec/staging/staging_message_spec.rb
+- spec/staging/staging_spec.rb
+- spec/support/component_helpers.rb
+- spec/support/helpers.rb
+- spec/support/message_helpers.rb
+- spec/support/message_type_helpers.rb