schemata-health_manager 0.0.1.beta1

data/lib/schemata/health_manager/status_request/status_request_v1.rb

@@ -0,0 +1,37 @@
+require 'vcap/common'
+
+module Schemata
+  module HealthManager
+    module StatusRequest
+      version 1 do
+        include_preschemata
+
+        define_schema do
+          {
+            "droplet"             => String,
+            "state"               => String,
+            optional("version")   => String,
+          }
+        end
+
+        define_min_version 1
+
+        define_upvert do |old_data|
+          raise NotImplementedError.new
+        end
+
+        define_generate_old_fields do |msg_obj|
+          raise NotImplementedError.new
+        end
+
+        define_mock_values do
+          {
+            "droplet" => proc { VCAP.secure_uuid },
+            "state"   => "FLAPPING",
+            "version" => proc { VCAP.secure_uuid },
+          }
+        end
+      end
+    end
+  end
+end

data/lib/schemata/health_manager/status_request.rb

@@ -0,0 +1,13 @@
+require 'schemata/common/msgtypebase'
+
+module Schemata
+  module HealthManager
+    module StatusRequest
+      extend Schemata::MessageTypeBase
+    end
+  end
+end
+
+Dir[File.dirname(__FILE__) + '/status_request/*.rb'].each do |file|
+  require file
+end

data/lib/schemata/health_manager/version.rb

@@ -0,0 +1,5 @@
+module Schemata
+  module HealthManager
+    VERSION = "0.0.1.beta1"
+  end
+end

data/lib/schemata/health_manager.rb

@@ -0,0 +1,29 @@
+require 'schemata/health_manager/status_request'
+require 'schemata/health_manager/status_flapping_response'
+require 'schemata/health_manager/status_crashed_response'
+require 'schemata/health_manager/health_request'
+require 'schemata/health_manager/health_response'
+
+module Schemata
+  module HealthManager
+    def self.mock_status_request(version=StatusRequest.current_version)
+      StatusRequest::const_get("V#{version}").mock
+    end
+
+    def self.mock_status_flapping_response(version=StatusFlappingResponse.current_version)
+      StatusFlappingResponse::const_get("V#{version}").mock
+    end
+
+    def self.mock_status_crashed_response(version=StatusCrashedResponse.current_version)
+      StatusCrashedResponse::const_get("V#{version}").mock
+    end
+
+    def self.mock_health_request(version=HealthRequest.current_version)
+      HealthRequest::const_get("V#{version}").mock
+    end
+
+    def self.mock_health_response(version=HealthResponse.current_version)
+      HealthResponse::const_get("V#{version}").mock
+    end
+  end
+end

data/lib/schemata/helpers/hash_copy.rb

@@ -0,0 +1,28 @@
+module Schemata
+  module HashCopyHelpers
+    class CopyError < StandardError; end
+
+    def self.deep_copy(node)
+      case node
+      when String
+        return node.dup
+      when Numeric, TrueClass, FalseClass
+        return node
+      when Hash
+        copy = {}
+        # XXX NB: The 'to_s' below was included because some components use
+        # symbols as keys instead of strings. This fix is temporary; in the
+        # long term, we should change all components to use the same type for
+        # their keys
+        node.each { |k, v| copy[k.to_s] = deep_copy(v) }
+        return copy
+      when Array
+        return node.map { |v| deep_copy(v) }
+      when NilClass
+        return nil
+      else
+        raise CopyError.new("Unexpected class: #{node.class}")
+      end
+    end
+  end
+end

data/lib/schemata/helpers/stringify.rb

@@ -0,0 +1,26 @@
+module Schemata
+  module HashCopyHelpers
+
+    def self.stringify(node)
+      case node
+      when String
+        return node
+      when Numeric, TrueClass, FalseClass
+        return node
+      when Hash
+        copy = {}
+        node.each { |k, v| copy[k.to_s] = stringify(v) }
+        return copy
+      when Array
+        return node.map { |v| stringify(v) }
+      when NilClass
+        return nil
+      when Symbol
+        return node.to_s
+      else
+        raise CopyError.new("Unexpected class: #{node.class}")
+      end
+    end
+
+  end
+end

data/spec/cloud_controller/cloud_controller_spec.rb

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

data/spec/cloud_controller/droplet_updated_message_spec.rb

@@ -0,0 +1,10 @@
+require 'schemata/cloud_controller'
+require 'spec_helper'
+
+describe Schemata::CloudController::DropletUpdatedMessage do
+  it_behaves_like "a message type"
+end
+
+describe Schemata::CloudController::DropletUpdatedMessage::V1 do
+  it_behaves_like "a message"
+end

data/spec/cloud_controller/hm_start_request_spec.rb

@@ -0,0 +1,11 @@
+require "schemata/cloud_controller"
+
+describe Schemata::CloudController::HmStartRequest do
+  it_behaves_like "a message type"
+end
+
+Schemata::CloudController::HmStartRequest.versions.each do |v|
+  describe Schemata::CloudController::HmStartRequest::const_get("V#{v}") do
+    it_behaves_like "a message"
+  end
+end

data/spec/cloud_controller/hm_stop_request_spec.rb

@@ -0,0 +1,12 @@
+require 'schemata/cloud_controller'
+require 'spec_helper'
+
+describe Schemata::CloudController::HmStopRequest do
+  it_behaves_like "a message type"
+end
+
+Schemata::CloudController::HmStopRequest.versions.each do |v|
+  describe Schemata::CloudController::HmStopRequest::const_get("V#{v}") do
+    it_behaves_like "a message"
+  end
+end

data/spec/common/helpers_spec.rb

@@ -0,0 +1,115 @@
+require 'schemata/helpers/hash_copy'
+require 'schemata/helpers/stringify'
+
+describe Schemata::HashCopyHelpers do
+  describe "#deep_copy" do
+    it "should deep copy nil" do
+      copy = Schemata::HashCopyHelpers.deep_copy(nil)
+      copy.should == nil
+    end
+
+    it "should deep copy a given string" do
+      original = "foo"
+      copy = Schemata::HashCopyHelpers.deep_copy(original)
+      copy.should be_instance_of String
+      copy.should == original
+      copy.object_id.should_not == original.object_id
+    end
+
+    it "should deep copy a given boolean" do
+      Schemata::HashCopyHelpers.deep_copy(true).
+        should be_an_instance_of TrueClass
+      Schemata::HashCopyHelpers.deep_copy(false).
+        should be_an_instance_of FalseClass
+    end
+
+    it "should deep copy a given numeric type" do
+      original = 0
+      copy = Schemata::HashCopyHelpers.deep_copy(original)
+      copy.should == original
+      copy.should be_an_instance_of Fixnum
+
+      # set original to be max fixnum + 1
+      original = 2**(0.size * 8 - 2)
+      copy = Schemata::HashCopyHelpers.deep_copy(original)
+      copy.should == original
+      copy.should be_an_instance_of Bignum
+
+      original = 0.0
+      copy = Schemata::HashCopyHelpers.deep_copy(original)
+      copy.should == original
+      copy.should be_an_instance_of Float
+    end
+
+    it "should deep copy a given hash" do
+      original = {"foo" => "bar"}
+      copy = Schemata::HashCopyHelpers.deep_copy(original)
+      copy.should be_instance_of Hash
+      copy.should == original
+
+      copy.object_id.should_not == original.object_id
+      copy["foo"].object_id.should_not == original["foo"].object_id
+    end
+
+    it "should deep copy a given array" do
+      original = [1, 2, "hello"]
+      copy = Schemata::HashCopyHelpers.deep_copy(original)
+      copy.should be_instance_of Array
+      copy.should == original
+
+      copy.object_id.should_not == original.object_id
+      # only check object_id of String object
+      copy[2].object_id.should_not == original[2].object_id
+    end
+
+    it "should deep copy nested types" do
+      original = {
+        "foo" => "bar",
+        "inner" => {
+          "hello" => "goodbye",
+        },
+      }
+      copy = Schemata::HashCopyHelpers.deep_copy(original)
+      copy.should be_instance_of Hash
+      copy.should == original
+
+      copy.object_id.should_not == original.object_id
+      copy["foo"].object_id.should_not == original["foo"].object_id
+      copy["inner"].object_id.should_not == original["inner"].object_id
+      copy["inner"]["hello"].object_id.
+        should_not == original["inner"]["hello"].object_id
+    end
+
+    it "should raise error for unknown type" do
+      klass = Class.new
+      expect do
+        Schemata::HashCopyHelpers.deep_copy(klass.new)
+      end.to raise_error(described_class::CopyError, /Unexpected class: /)
+    end
+  end
+
+  describe "#stringify" do
+    it "should stringify nil" do
+      str = Schemata::HashCopyHelpers.stringify(nil)
+      str.should == nil
+    end
+
+    it "should stringify a string" do
+      original = "foo"
+      str = Schemata::HashCopyHelpers.stringify(original)
+      str.should == "foo"
+    end
+
+    it "should stringify a symbol" do
+      original = :foo
+      str = Schemata::HashCopyHelpers.stringify(original)
+      str.should == "foo"
+    end
+
+    it "should stringify a hash" do
+      original = { "foo" => :foo }
+      str = Schemata::HashCopyHelpers.stringify(original)
+      str.should == { "foo" => "foo" }
+    end
+  end
+end

data/spec/common/parsed_msg_spec.rb

@@ -0,0 +1,46 @@
+require 'schemata/common/parsed_msg'
+
+describe Schemata::ParsedMessage do
+  describe "#new" do
+    it "should raise an error if 'min_version' is missing" do
+      json = '{
+        "V10" : { "foo" : "bar" }
+      }'
+      expect {
+        msg = Schemata::ParsedMessage.new(json)
+      }.to raise_error(Schemata::DecodeError)
+    end
+
+    it "should raise an error if there are non-Vxx hashes" do
+      json = '{
+        "min_version" : 10,
+        "foo" : "bar"
+      }'
+      expect {
+        msg = Schemata::ParsedMessage.new(json)
+      }.to raise_error(Schemata::DecodeError)
+    end
+
+    it "should raise an error if there are no Vxx hashes" do
+      json = '{
+        "min_version" : 10
+      }'
+      expect {
+        msg = Schemata::ParsedMessage.new(json)
+      }.to raise_error(Schemata::DecodeError)
+    end
+
+    it "should return a new Schemata::ParsedMessage if the hash is valid" do
+      json = '{
+        "min_version" : 10,
+        "V10" : { "foo" : "bar" },
+        "V11" : { "foo" : "bar"}
+      }'
+      msg = Schemata::ParsedMessage.new(json)
+      msg.min_version.should == 10
+      msg.version.should == 11
+      msg.contents["V10"]["foo"].should == "bar"
+      msg.contents["V11"]["foo"].should == "bar"
+    end
+  end
+end

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