schemata-router 0.0.1.beta9 → 0.0.1.beta10

data/lib/schemata/common/componentbase.rb

@@ -0,0 +1,42 @@
+require 'schemata/helpers/decamelize'
+
+module Schemata
+  module ComponentBase
+
+    def message_types
+      self.constants.select { |x| x != :VERSION }
+    end
+
+    def component_name
+      self.name.split("::")[1]
+    end
+
+    def eigenclass
+      class << self; self; end
+    end
+
+    def register_mock_methods
+      message_types.each do |type|
+        message_type = self::const_get(type)
+        mock_method_name = "mock_#{Schemata::Helpers.decamelize(type.to_s)}"
+        eigenclass.send(:define_method, mock_method_name) do |*args|
+          version = args[0] || message_type.current_version
+          message_type::const_get("V#{version}").mock
+        end
+      end
+    end
+
+    def require_message_classes
+      path = "./lib/schemata/"
+      path << Schemata::Helpers.decamelize(component_name)
+      path << "/*.rb"
+      Dir.glob(path, &method(:require))
+    end
+
+    def self.extended(klass)
+      klass.require_message_classes
+      klass.register_mock_methods
+    end
+
+  end
+end

data/lib/schemata/common/msgbase.rb

@@ -14,7 +14,7 @@ module Schemata
         @contents = {}
 
         data.each do |key, field_value|
-          key = Schemata::HashCopyHelpers.stringify(key)
+          key = Schemata::Helpers.stringify(key)
           field_schema = @schema.schemas[key]
           next unless field_schema
 
@@ -27,7 +27,7 @@ module Schemata
           # symbols, but on the decoding side, it should expect strings. To allow
           # for this in the schema definition, Schemata stringifies all symbols during
           # construction of Schemata objects.
-          field_value = Schemata::HashCopyHelpers.stringify(field_value)
+          field_value = Schemata::Helpers.stringify(field_value)
 
           begin
             field_schema.validate(field_value)
@@ -35,7 +35,7 @@ module Schemata
             raise Schemata::UpdateAttributeError.new(key, e.message)
           end
 
-          @contents[key] = Schemata::HashCopyHelpers.deep_copy(field_value)
+          @contents[key] = Schemata::Helpers.deep_copy(field_value)
         end
       end
 
@@ -45,7 +45,7 @@ module Schemata
         schema.schemas.each do |key, field_schema|
           vc_klass.send(:define_method, key) do
             unless @contents[key].nil?
-              return Schemata::HashCopyHelpers.deep_copy(@contents[key])
+              return Schemata::Helpers.deep_copy(@contents[key])
             end
             nil
           end
@@ -53,13 +53,15 @@ module Schemata
           # TODO This call to stringify should be removed when cc/dea stops using
           # symbols. See comment above for a better description.
           vc_klass.send(:define_method, "#{key}=") do |field_value|
-            field_value = Schemata::HashCopyHelpers.stringify(field_value)
-            begin
-              field_schema.validate(field_value)
-            rescue Membrane::SchemaValidationError => e
-              raise Schemata::UpdateAttributeError.new(key, e.message)
+            field_value = Schemata::Helpers.stringify(field_value)
+            unless schema.optional_keys.include?(key) && field_value == nil
+              begin
+                field_schema.validate(field_value)
+              rescue Membrane::SchemaValidationError => e
+                raise Schemata::UpdateAttributeError.new(key, e.message)
+              end
             end
-            @contents[key] = Schemata::HashCopyHelpers.deep_copy(field_value)
+            @contents[key] = Schemata::Helpers.deep_copy(field_value)
             field_value
           end
         end
@@ -67,7 +69,7 @@ module Schemata
       end
 
       def contents
-        Schemata::HashCopyHelpers.deep_copy(@contents)
+        Schemata::Helpers.deep_copy(@contents)
       end
 
       def empty?

data/lib/schemata/common/msgtypebase.rb

@@ -1,5 +1,6 @@
 require 'schemata/common/msgbase'
 require 'schemata/common/parsed_msg'
+require 'schemata/helpers/decamelize'
 
 module Schemata
   module MessageTypeBase
@@ -70,8 +71,27 @@ module Schemata
       Schemata::const_get(component)
     end
 
+    def component_name
+      self.name.split("::")[1]
+    end
+
+    def message_type_name
+      self.name.split("::")[2]
+    end
+
+    def require_message_versions
+      path = "./lib/schemata/"
+      path << Schemata::Helpers.decamelize(component_name)
+      path << "/"
+      path << Schemata::Helpers.decamelize(message_type_name)
+      path << "/*.rb"
+
+      Dir.glob(path, &method(:require))
+    end
+
     def self.extended(o)
       o.extend Dsl
+      o.require_message_versions
     end
 
     module Dsl

data/lib/schemata/common/parsed_msg.rb

@@ -37,7 +37,7 @@ module Schemata
     end
 
     def contents
-      Schemata::HashCopyHelpers.deep_copy(@contents)
+      Schemata::Helpers.deep_copy(@contents)
     end
   end
 end

data/lib/schemata/helpers/decamelize.rb

@@ -0,0 +1,23 @@
+module Schemata
+  module Helpers
+    def self.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
+  end
+end

data/lib/schemata/helpers/hash_copy.rb

@@ -1,5 +1,5 @@
 module Schemata
-  module HashCopyHelpers
+  module Helpers
     class CopyError < StandardError; end
 
     def self.deep_copy(node)

data/lib/schemata/helpers/stringify.rb

@@ -1,5 +1,5 @@
 module Schemata
-  module HashCopyHelpers
+  module Helpers
 
     def self.stringify(node)
       case node

data/lib/schemata/router.rb

@@ -1,14 +1,7 @@
-require 'schemata/router/register_request'
-require 'schemata/router/start_message'
+require 'schemata/common/componentbase'
 
 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
+    extend Schemata::ComponentBase
   end
 end

data/lib/schemata/router/register_request.rb

@@ -7,7 +7,3 @@ module Schemata
     end
   end
 end
-
-Dir[File.dirname(__FILE__) + '/register_request/*.rb'].each do |file|
-  require file
-end

data/lib/schemata/router/start_message.rb

@@ -7,7 +7,3 @@ module Schemata
     end
   end
 end
-
-Dir[File.dirname(__FILE__) + '/start_message/*.rb'].each do |file|
-  require file
-end

data/lib/schemata/router/version.rb

@@ -1,5 +1,5 @@
 module Schemata
   module Router
-    VERSION = "0.0.1.beta9"
+    VERSION = "0.0.1.beta10"
   end
 end

data/spec/common/helpers_spec.rb

@@ -1,49 +1,49 @@
 require 'schemata/helpers/hash_copy'
 require 'schemata/helpers/stringify'
 
-describe Schemata::HashCopyHelpers do
+describe Schemata::Helpers do
   describe "#deep_copy" do
     it "should deep copy nil" do
-      copy = Schemata::HashCopyHelpers.deep_copy(nil)
+      copy = Schemata::Helpers.deep_copy(nil)
       copy.should == nil
     end
 
     it "should deep copy a given string" do
       original = "foo"
-      copy = Schemata::HashCopyHelpers.deep_copy(original)
+      copy = Schemata::Helpers.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).
+      Schemata::Helpers.deep_copy(true).
         should be_an_instance_of TrueClass
-      Schemata::HashCopyHelpers.deep_copy(false).
+      Schemata::Helpers.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 = Schemata::Helpers.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 = Schemata::Helpers.deep_copy(original)
       copy.should == original
       copy.should be_an_instance_of Bignum
 
       original = 0.0
-      copy = Schemata::HashCopyHelpers.deep_copy(original)
+      copy = Schemata::Helpers.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 = Schemata::Helpers.deep_copy(original)
       copy.should be_instance_of Hash
       copy.should == original
 
@@ -53,7 +53,7 @@ describe Schemata::HashCopyHelpers do
 
     it "should deep copy a given array" do
       original = [1, 2, "hello"]
-      copy = Schemata::HashCopyHelpers.deep_copy(original)
+      copy = Schemata::Helpers.deep_copy(original)
       copy.should be_instance_of Array
       copy.should == original
 
@@ -69,7 +69,7 @@ describe Schemata::HashCopyHelpers do
           "hello" => "goodbye",
         },
       }
-      copy = Schemata::HashCopyHelpers.deep_copy(original)
+      copy = Schemata::Helpers.deep_copy(original)
       copy.should be_instance_of Hash
       copy.should == original
 
@@ -83,32 +83,32 @@ describe Schemata::HashCopyHelpers do
     it "should raise error for unknown type" do
       klass = Class.new
       expect do
-        Schemata::HashCopyHelpers.deep_copy(klass.new)
+        Schemata::Helpers.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 = Schemata::Helpers.stringify(nil)
       str.should == nil
     end
 
     it "should stringify a string" do
       original = "foo"
-      str = Schemata::HashCopyHelpers.stringify(original)
+      str = Schemata::Helpers.stringify(original)
       str.should == "foo"
     end
 
     it "should stringify a symbol" do
       original = :foo
-      str = Schemata::HashCopyHelpers.stringify(original)
+      str = Schemata::Helpers.stringify(original)
       str.should == "foo"
     end
 
     it "should stringify a hash" do
       original = { "foo" => :foo }
-      str = Schemata::HashCopyHelpers.stringify(original)
+      str = Schemata::Helpers.stringify(original)
       str.should == { "foo" => "foo" }
     end
   end

data/spec/support/component_helpers.rb

@@ -1,9 +1,10 @@
 require 'support/helpers'
+require 'schemata/helpers/decamelize'
 
 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
+    describe ".mock_#{Schemata::Helpers.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
@@ -12,11 +13,24 @@ shared_examples "a schemata component" do
           let(:component)         { described_class }
           let(:component_name)    { component.name.split("::")[1] }
 
-          let(:mock_method) { "mock_#{decamelize(msg_type)}"}
+          let(:mock_method) { "mock_#{Schemata::Helpers.decamelize(msg_type)}"}
         end
       end
     end
+
+    describe msg_type do
+      message_type = described_class::const_get(msg_type)
+      it_behaves_like "a message type", message_type 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_#{Schemata::Helpers.decamelize(msg_type)}" }
+      end
+    end
   end
+
 end
 
 shared_examples "a mocking method" do |version|

data/spec/support/helpers.rb

@@ -26,26 +26,6 @@ def greater_version?(version, benchmark)
   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)

data/spec/support/message_helpers.rb

@@ -1,16 +1,5 @@
-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)}" }
+shared_examples "a message" do |msg|
+  version = msg.version
 
   before :each do
     set_current_version(message_type, version)
@@ -21,7 +10,7 @@ shared_examples "a message" do
   end
 
   describe "#new" do
-    it "should create a #{described_class} object with an incomplete hash" do
+    it "should create a #{msg} 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]
@@ -68,7 +57,7 @@ shared_examples "a message" do
         json_hash.should have_key "V1"
         json_hash.should have_key "min_version"
 
-        data = Schemata::HashCopyHelpers.deep_copy(json_hash["V1"])
+        data = Schemata::Helpers.deep_copy(json_hash["V1"])
 
         json_hash.delete("V1")
         json_hash.delete("min_version")
@@ -86,7 +75,7 @@ shared_examples "a message" do
         end
         json_hash.should have_key "min_version"
 
-        data = Schemata::HashCopyHelpers.deep_copy(json_hash["V#{version}"])
+        data = Schemata::Helpers.deep_copy(json_hash["V#{version}"])
         1.upto(version) do |i|
           json_hash.delete("V#{i}")
         end
@@ -97,9 +86,9 @@ shared_examples "a message" do
     end
   end
 
-  described_class.schema.schemas.keys.each do |attr|
+  msg.schema.schemas.keys.each do |attr|
     describe "##{attr}" do
-      it "should the attribute if it was specified at instantiation" do
+      it "should return 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
@@ -116,6 +105,21 @@ shared_examples "a message" do
         msg_obj = message.new
         msg_obj.send(attr).should be_nil
       end
+
+      if msg.schema.optional_keys.include? attr
+        context "the attribute is optional" do
+          it "should allow nil values during instantiation" do
+            mock_value = component.send(mock_method, version).contents[attr]
+            hash = { attr => mock_value }
+            msg_obj = message.new(hash)
+          end
+
+          it "should be able to set the attribute to nil" do
+            msg_obj = message.new
+            msg_obj.send("#{attr}=", nil)
+          end
+        end
+      end
     end
 
     describe "##{attr}=" do
@@ -127,7 +131,7 @@ shared_examples "a message" do
         ret.should == mock_value
       end
 
-      unless described_class.schema.schemas[attr].kind_of? Membrane::Schema::Any
+      unless msg.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]
 

data/spec/support/message_type_helpers.rb

@@ -1,15 +1,8 @@
-shared_examples "a message type" do
+shared_examples "a message type" do |msg_type|
 
-  versions = described_class.constants.select {|x| x =~ /V[0-9]+/ }
+  versions = msg_type.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
@@ -50,7 +43,7 @@ shared_examples "a message type" do
         msg_hash = {
           "V1" => data,
           "min_version" => 1
-        }.merge(Schemata::HashCopyHelpers.deep_copy(data))
+        }.merge(Schemata::Helpers.deep_copy(data))
         json = Yajl::Encoder.encode(msg_hash)
 
         msg_obj = message_type.decode(json)
@@ -96,68 +89,68 @@ structure or a complete flash hash" do
         }.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
+    if versions.include?(2)
+      context "when the current version is 2" do
+        before :each do
+          set_current_version(message_type, 2)
+        end
 
-      after :each do
-        reset_version(message_type)
-      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 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
+        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::Helpers.deep_copy(msg_hash)
+          msg_hash["V1"] = v1_hash
+          msg_hash["min_version"] = 1
 
-        json = Yajl::Encoder.encode(msg_hash)
+          json = Yajl::Encoder.encode(msg_hash)
 
-        msg_obj = message_type.decode(json)
-        msg_obj.class.should == message_type::V2
+          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]
+          message_type::V2.schema.schemas.keys.each do |key|
+            msg_obj.send(key).should == v1_hash[key]
+          end
         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}
+        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)
+          json = Yajl::Encoder.encode(msg_hash)
 
-        msg_obj = message_type.decode(json)
-        msg_obj.class.should == message_type::V2
+          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]
+          message_type::V2.schema.schemas.keys.each do |key|
+            msg_obj.send(key).should == v1_hash[key]
+          end
         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}
+        it "should return a V2 object given a V2-encoded object" do
+          data = component.send(mock_method, 2).contents
+          v2_hash = Schemata::Helpers.deep_copy(data)
+          msg_hash = {"V2" => v2_hash, "V1" => {}, "min_version" => 1}
 
-        json = Yajl::Encoder.encode(msg_hash)
+          json = Yajl::Encoder.encode(msg_hash)
 
-        msg_obj = message_type.decode(json)
-        msg_obj.class.should == message_type::V2
+          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]
+          message_type::V2.schema.schemas.keys.each do |key|
+            msg_obj.send(key).should == data[key]
+          end
         end
       end
     end
@@ -168,4 +161,15 @@ structure or a complete flash hash" do
   versions.select { |x| x > 2 }.each do |version|
 
   end
+
+  # Test message version types
+  versions.each do |version|
+    msg = msg_type::const_get("V#{version}")
+    describe "V#{version}" do
+      it_behaves_like "a message", msg do
+        let (:message)            { message_type::const_get("V#{version}") }
+        let (:message_name)       { message.to_s }
+      end
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: schemata-router
 version: !ruby/object:Gem::Version
-  version: 0.0.1.beta9
+  version: 0.0.1.beta10
   prerelease: 6
 platform: ruby
 authors:
@@ -115,24 +115,23 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/schemata/common/componentbase.rb
+- lib/schemata/common/error.rb
+- lib/schemata/common/msgbase.rb
+- lib/schemata/common/msgtypebase.rb
+- lib/schemata/common/parsed_msg.rb
+- lib/schemata/helpers/decamelize.rb
+- lib/schemata/helpers/hash_copy.rb
+- lib/schemata/helpers/stringify.rb
 - lib/schemata/router/register_directory_server_request/register_directory_server_request_v1.rb
-- lib/schemata/router/register_request.rb
 - lib/schemata/router/register_request/register_request_v1.rb
+- lib/schemata/router/register_request.rb
+- lib/schemata/router/start_message/start_message_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
@@ -165,9 +164,6 @@ 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

data/spec/router/register_request_spec.rb

@@ -1,10 +0,0 @@
-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

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

data/spec/router/start_message_spec.rb

@@ -1,10 +0,0 @@
-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