schemata-router 0.0.1.beta1

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/lib/schemata/router.rb

@@ -0,0 +1,14 @@
+require 'schemata/router/register_request'
+require 'schemata/router/start_message'
+
+module Schemata
+  module Router
+    def self.mock_register_request(version=RegisterRequest.current_version)
+      RegisterRequest::const_get("V#{version}").mock
+    end
+
+    def self.mock_start_message(version=StartMessage.current_version)
+      StartMessage::const_get("V#{version}").mock
+    end
+  end
+end

data/lib/schemata/router/register_request.rb

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

data/lib/schemata/router/register_request/register_request_v1.rb

@@ -0,0 +1,53 @@
+#require 'vcap/common'
+
+module Schemata
+  module Router
+    module RegisterRequest
+      version 1 do
+        include_preschemata
+
+        define_schema do
+          {
+            optional("dea")                   => String,
+            optional("app")                   => String,
+            "uris"                            => [String],
+            "host"                            => String,
+            "port"                            => Integer,
+            "tags"  => {
+              optional("framework")           => String,
+              optional("runtime")             => String,
+              optional("component")           => String,
+            },
+            optional("private_instance_id")  => 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
+          {
+            "dea"   => "deadbeef", #proc { VCAP.secure_uuid },
+            "app"   => proc { Random.rand(100).to_s },
+            "uris"  => ["foo.vcap.me"],
+            "host"  => "127.0.0.1",
+            "port"  => 80,
+            "tags"  => {
+              "framework" => "rails3",
+              "runtime"   => "ruby18",
+              "component" => "dashboard",
+            },
+            "private_instance_id" => "deadbeef1",#proc { VCAP.secure_uuid },
+          }
+        end
+      end
+    end
+  end
+end

data/lib/schemata/router/start_message.rb

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

data/lib/schemata/router/start_message/start_message_v1.rb

@@ -0,0 +1,35 @@
+#require "vcap/common"
+
+module Schemata
+  module Router
+    module StartMessage
+      version 1 do
+        include_preschemata
+
+        define_schema do
+          {
+            "id" => String,
+            "version" => String,
+          }
+        end
+
+        define_min_version 1
+
+        define_upvert do |old_data|
+          raise NotImplmenetedError.new
+        end
+
+        define_generate_old_fields do |msg_obj|
+          raise NotImplementedError.new
+        end
+
+        define_mock_values do
+          {
+            "id" => "deadbeef", #proc { VCAP.secure_uuid },
+            "version" => "0.1.0",
+          }
+        end
+      end
+    end
+  end
+end

data/lib/schemata/router/version.rb

@@ -0,0 +1,5 @@
+module Schemata
+  module Router
+    VERSION = "0.0.1.beta1"
+  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/router/register_request_spec.rb

@@ -0,0 +1,10 @@
+require 'schemata/router'
+require 'spec_helper'
+
+describe Schemata::Router::RegisterRequest do
+  it_behaves_like "a message type"
+end
+
+describe Schemata::Router::RegisterRequest::V1 do
+  it_behaves_like "a message"
+end

data/spec/router/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/router/start_message_spec.rb

@@ -0,0 +1,10 @@
+require 'schemata/router'
+require 'spec_helper'
+
+describe Schemata::Router::StartMessage do
+  it_behaves_like "a message type"
+end
+
+describe Schemata::Router::StartMessage::V1 do
+  it_behaves_like "a message"
+end

data/spec/spec_helper.rb

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

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