schemata-cloud_controller 0.0.1.beta1

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