schemata-dea 0.0.1.beta18 → 0.0.1.beta20

data/lib/schemata/common/error.rb

@@ -1,18 +1,43 @@
 module Schemata
-  class DecodeError < StandardError; end
-  class EncodeError < StandardError; end
-  class SchemaDefinitionError < StandardError; end
+  class Error < StandardError
 
-  class UpdateAttributeError < StandardError
-    def initialize(key, message)
-      super("#{key}: #{message}")
+    attr_reader :source_exception, :source_backtrace
+
+    def initialize(source_exception = $!, message = nil)
+      message = source_exception.message if message.nil? && source_exception
+      super(message)
+      if source_exception
+        @source_exception = source_exception
+        @source_backtrace = source_exception.backtrace || []
+      end
+    end
+
+    def backtrace
+      self_backtrace = super
+      self_backtrace && source_backtrace  ? self_backtrace + source_backtrace : self_backtrace
     end
   end
 
-  class IncompatibleVersionError < DecodeError
+  class DecodeError < Error; end
+  class EncodeError < Error; end
+  class SchemaDefinitionError < Error; end
+
+  class UpdateAttributeError < Error
+    attr_reader :key
+
+    def initialize(key, exception = $!)
+      super(exception, "#{key}: #{exception.message}")
+      @key = key
+    end
+  end
+
+  class IncompatibleVersionError < Error
+    attr_reader :msg_version, :component_version
+
     def initialize(msg_version, component_version)
-      super("min message version #{msg_version} too high for component ver\
-sion #{component_version}")
+      super(self, "min message version #{msg_version} too high for component version #{component_version}")
+      @msg_version = msg_version
+      @component_version = component_version
     end
   end
 end

data/lib/schemata/common/msgbase.rb

@@ -10,31 +10,18 @@ module Schemata
     class ValidatingContainer
       def initialize(data = {})
         data ||= {}
-        @schema = self.class.const_get(:SCHEMA)
         @contents = {}
 
         data.each do |key, field_value|
-          key = Schemata::Helpers.stringify(key)
-          field_schema = @schema.schemas[key]
+          key = Schemata::Helpers.stringify_symbols(key) # TODO see test
+          field_schema = schema.schemas[key]
           next unless field_schema
 
-          # TODO This call to stringify should be removed when cc/dea stop using
-          # Symbols.
-          #
-          # Currently, some fields (for example, 'states' in requests sent
-          # on dea.find.droplet), are are symbols, During Yajl decoding, however,
-          # they become strings. Thus, on the encoding side, Schemata should expect
-          # 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::Helpers.stringify(field_value)
-
           begin
-            field_schema.validate(field_value)
+            field_value = validate_field(field_schema, key, field_value)
           rescue Membrane::SchemaValidationError => e
-            raise Schemata::UpdateAttributeError.new(key, e.message)
+            raise Schemata::UpdateAttributeError.new(key, e)
           end
-
           @contents[key] = Schemata::Helpers.deep_copy(field_value)
         end
       end
@@ -50,17 +37,9 @@ module Schemata
             nil
           end
 
-          # 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::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
+            field_value = validate_field(field_schema, key, field_value)
             @contents[key] = Schemata::Helpers.deep_copy(field_value)
             field_value
           end
@@ -77,7 +56,23 @@ module Schemata
       end
 
       def validate
-        @schema.validate(@contents)
+        schema.schemas.each do |key, field_schema|
+          validate_field(field_schema, key, @contents[key])
+        end
+      end
+
+      private
+
+      def validate_field(field_schema, key, field_value)
+        field_value = Schemata::Helpers.stringify_symbols(field_value) # TODO see test
+        unless schema.optional_keys.include?(key) && field_value == nil
+          field_schema.validate(field_value)
+        end
+        field_value
+      end
+
+      def schema
+        self.class.const_get(:SCHEMA)
       end
     end
 
@@ -86,7 +81,7 @@ module Schemata
     end
 
     def aux_vc_klass
-      return self.class.const_get(:AUX_VC_KLASS) if self.class.aux_schema
+      self.class.const_get(:AUX_VC_KLASS) if self.class.aux_schema
     end
 
     def initialize(msg_data_hash = nil, aux_data_hash = nil)
@@ -101,10 +96,10 @@ module Schemata
         validate_contents
         validate_aux_data
       rescue Membrane::SchemaValidationError => e
-        raise Schemata::EncodeError.new(e.message)
+        raise Schemata::EncodeError.new(e)
       end
 
-      msg_type = message_type
+      message_type
       curr_version = self.class.version
       min_version = self.class::MIN_VERSION_ALLOWED
 
@@ -146,140 +141,138 @@ module Schemata
     end
 
     def message_type
-      _, component, msg_type, version = self.class.name.split("::")
+      _, component, msg_type, _ = self.class.name.split("::")
       Schemata::const_get(component)::const_get(msg_type)
     end
 
     def component
-      _, component, msg_type, version = self.class.name.split("::")
+      component = self.class.name.split("::")[1]
       Schemata::const_get(component)
     end
 
     def self.included(klass)
-      klass.extend(Schemata::ClassMethods)
-      klass.extend(Dsl)
+      klass.extend(Schemata::MessageBase::ClassMethods)
+      klass.extend(Schemata::MessageBase::Dsl)
     end
-  end
 
-  module ClassMethods
-    def mock
-      mock = {}
-      mock_values.keys.each do |k|
-        value = mock_values[k]
-        mock[k] = value.respond_to?("call") ? value.call : value
+    module ClassMethods
+      def mock
+        mock = {}
+        mock_values.keys.each do |k|
+          value = mock_values[k]
+          mock[k] = value.respond_to?("call") ? value.call : value
+        end
+        self.new(mock)
       end
-      self.new(mock)
-    end
-
-    def schema
-      self::SCHEMA
-    end
-
-    def aux_schema
-      return self::AUX_SCHEMA if defined?(self::AUX_SCHEMA)
-    end
-
-    def mock_values
-      self::MOCK_VALUES
-    end
 
-    def version
-      _, component, msg_type, version = self.name.split("::")
-      version[1..-1].to_i
-    end
+      def schema
+        self::SCHEMA
+      end
 
-    def previous_version
-      _, component, msg_type, version = self.name.split("::")
-      version = version[1..-1].to_i - 1
-      Schemata::const_get(component)::const_get(msg_type)::
-        const_get("V#{version}")
-    end
-  end
+      def aux_schema
+        return self::AUX_SCHEMA if defined?(self::AUX_SCHEMA)
+      end
 
-  module Dsl
-    def define_schema(&blk)
-      schema = Membrane::SchemaParser.parse(&blk)
-      unless schema.kind_of? Membrane::Schema::Record
-        Schemata::SchemaDefinitionError.new("Schema must be a hash")
+      def mock_values
+        self::MOCK_VALUES
       end
-      self::const_set(:SCHEMA, schema)
-    end
 
-    def define_aux_schema(&blk)
-      aux_schema = Membrane::SchemaParser.parse(&blk)
-      unless aux_schema.kind_of? Membrane::Schema::Record
-        Schemata::SchemaDefinitionError.new("Schema must be a hash")
+      def version
+        self.name.split("::")[-1][1..-1].to_i
       end
 
-      self::const_set(:AUX_SCHEMA, aux_schema)
+      def previous_version
+        _, component, msg_type, version = self.name.split("::")
+        version = version[1..-1].to_i - 1
+        Schemata::const_get(component)::const_get(msg_type)::const_get("V#{version}")
+      end
     end
 
-    def define_min_version(min_version)
-      unless min_version.is_a? Integer
-        raise SchemaDefinitionError.new("Min version must be an integer")
+    module Dsl
+      def define_schema(&blk)
+        schema = Membrane::SchemaParser.parse(&blk)
+        unless schema.kind_of? Membrane::Schema::Record
+          raise Schemata::SchemaDefinitionError.new(nil, "Schema must be a hash")
+        end
+        self::const_set(:SCHEMA, schema)
       end
-      const_set(:MIN_VERSION_ALLOWED, min_version)
-    end
 
-    def define_upvert(&blk)
-      eigenclass.send(:define_method, :upvert) do |old_data|
-        # No need to validate aux_data because upvert is only called during
-        # decode, when aux_data is irrelevant
-        begin
-          previous_version::SCHEMA.validate(old_data)
-        rescue Membrane::SchemaValidationError => e
-          raise Schemata::DecodeError.new(e.message)
+      def define_aux_schema(&blk)
+        aux_schema = Membrane::SchemaParser.parse(&blk)
+        unless aux_schema.kind_of? Membrane::Schema::Record
+          raise Schemata::SchemaDefinitionError.new(nil, "Schema must be a hash")
         end
 
-        blk.call(old_data)
+        self::const_set(:AUX_SCHEMA, aux_schema)
       end
-    end
 
-    def define_generate_old_fields(&blk)
-      self.send(:define_method, :generate_old_fields) do
-        if self.class.aux_schema && aux_data.empty?
-          raise Schemata::DecodeError.new("Necessary aux_data missing")
+      def define_min_version(min_version)
+        unless min_version.is_a? Integer
+          raise SchemaDefinitionError.new(nil, "Min version must be an integer")
         end
-        old_fields = blk.call(self)
+        const_set(:MIN_VERSION_ALLOWED, min_version)
+      end
 
-        msg_contents = contents
-        msg_contents.update(old_fields)
-        msg_obj = self.class.previous_version.new(msg_contents)
+      def define_upvert(&blk)
+        eigenclass.send(:define_method, :upvert) do |old_data|
+          # No need to validate aux_data because upvert is only called during
+          # decode, when aux_data is irrelevant
+          begin
+            previous_version::SCHEMA.validate(old_data)
+          rescue Membrane::SchemaValidationError => e
+            raise Schemata::DecodeError.new(e)
+          end
 
-        msg_obj.validate_contents
-        return msg_obj, old_fields
+          blk.call(old_data)
+        end
       end
-    end
 
-    def define_mock_values(hash=nil, &blk)
-      if (hash && blk) ||  (!hash && !blk)
-        # value defined twice or not at all
-        raise SchemaDefinitionError.new("Mock values incorrectly defined")
+      def define_generate_old_fields(&blk)
+        self.send(:define_method, :generate_old_fields) do
+          if self.class.aux_schema && aux_data.empty?
+            raise Schemata::DecodeError.new(nil, "Necessary aux_data missing")
+          end
+          old_fields = blk.call(self)
+
+          msg_contents = contents
+          msg_contents.update(old_fields)
+          msg_obj = self.class.previous_version.new(msg_contents)
+
+          msg_obj.validate_contents
+          return msg_obj, old_fields
+        end
       end
 
-      hash = blk.call if blk
+      def define_mock_values(hash=nil, &blk)
+        if (hash && blk) || (!hash && !blk)
+          # value defined twice or not at all
+          raise SchemaDefinitionError.new(nil, "Mock values incorrectly defined")
+        end
+
+        hash = blk.call if blk
 
-      # Validate a sample of the mock values.
-      mock = {}
-      hash.each do |key, value|
-        mock[key] = value.respond_to?("call") ? value.call : value
+        # Validate a sample of the mock values.
+        mock = {}
+        hash.each do |key, value|
+          mock[key] = value.respond_to?("call") ? value.call : value
+        end
+
+        begin
+          self.schema.validate(mock)
+          define_constant(:MOCK_VALUES, hash)
+        rescue Membrane::SchemaValidationError => e
+          raise SchemaDefinitionError.new(nil, "Sample mock values do not match schema: #{e}")
+        end
       end
 
-      begin
-        self.schema.validate(mock)
-        define_constant(:MOCK_VALUES, hash)
-      rescue Membrane::SchemaValidationError => e
-        raise SchemaDefinitionError.new("Sample mock values do not match schema: #{e}")
+      def define_constant(constant_name, constant_value)
+        self.const_set(constant_name, constant_value)
       end
-    end
 
-    def define_constant(constant_name, constant_value)
-      self.const_set(constant_name, constant_value)
-    end
+      def include_preschemata
+        define_constant(:INCLUDE_PRESCHEMATA, true)
+      end
 
-    def include_preschemata
-      define_constant(:INCLUDE_PRESCHEMATA, true)
     end
-
   end
 end

data/lib/schemata/common/msgtypebase.rb

@@ -60,9 +60,9 @@ module Schemata
         # We don't validate aux data in decode.
         return msg_obj
       rescue Schemata::UpdateAttributeError => e
-        raise Schemata::DecodeError.new(e.message)
+        raise Schemata::DecodeError.new(e)
       rescue Membrane::SchemaValidationError => e
-        raise Schemata::DecodeError.new(e.message)
+        raise Schemata::DecodeError.new(e)
       end
     end
 
@@ -124,12 +124,14 @@ module Schemata
         end
 
         # Define attribute accessors for the message class
-        klass.schema.schemas.each do |key, field_schema|
-          klass.send(:define_method, key) do
-            @contents.send(key)
-          end
+        klass.schema.schemas.each do |key, _|
+          klass.send(:define_method, key) { @contents.send(key) }
           klass.send(:define_method, "#{key}=") do |field_value|
-            @contents.send("#{key}=", field_value)
+            begin
+              @contents.send("#{key}=", field_value)
+            rescue Membrane::SchemaValidationError => e
+              raise Schemata::UpdateAttributeError.new(key, e)
+            end
           end
         end
         self::const_set("V#{v}", klass)
@@ -144,9 +146,8 @@ module Schemata
         msg_obj = current_class.new(msg_contents)
         msg_obj.validate_contents
         return msg_obj
-      rescue Schemata::UpdateAttributeError,
-        Membrane::SchemaValidationError => e
-        raise Schemata::DecodeError.new(e.message)
+      rescue Schemata::UpdateAttributeError, Membrane::SchemaValidationError => e
+        raise Schemata::DecodeError.new(e)
       end
     end
 

data/lib/schemata/common/parsed_msg.rb

@@ -12,24 +12,24 @@ module Schemata
 
       @min_version = @contents['min_version']
       if !@min_version
-        raise DecodeError.new("Field 'min_version' abset from message")
+        raise DecodeError.new(nil, "Field 'min_version' abset from message")
       end
 
       versions = []
       @contents.keys.each do |k|
         next if k == 'min_version'
         unless k =~ /^V[0-9]+$/
-          raise DecodeError.new("Invalid key: #{k}")
+          raise DecodeError.new(nil, "Invalid key: #{k}")
         end
         versions << k[1..-1].to_i
       end
 
       if versions.empty?
-        raise DecodeError.new("Message contains no versioned hashes")
+        raise DecodeError.new(nil, "Message contains no versioned hashes")
       end
 
       if Set.new(versions.min..versions.max) != Set.new(versions)
-        raise DecodeError.new("There are versions missing between\
+        raise DecodeError.new(nil, "There are versions missing between\
  #{versions.min} and #{versions.max}")
       end
 

data/lib/schemata/dea/version.rb

@@ -1,5 +1,5 @@
 module Schemata
   module Dea
-    VERSION = "0.0.1.beta18"
+    VERSION = "0.0.1.beta20"
   end
 end

data/lib/schemata/helpers.rb

@@ -0,0 +1 @@
+Dir[File.expand_path("../helpers/*.rb", __FILE__)].each { |file| require file }

data/lib/schemata/helpers/stringify.rb

@@ -1,24 +1,21 @@
 module Schemata
   module Helpers
+    class StringifyError < StandardError; end
 
-    def self.stringify(node)
+    def self.stringify_symbols(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) }
+        node.each { |k, v| copy[k.to_s] = stringify_symbols(v) }
         return copy
       when Array
-        return node.map { |v| stringify(v) }
-      when NilClass
-        return nil
+        return node.map { |v| stringify_symbols(v) }
       when Symbol
         return node.to_s
+      when String, Numeric, TrueClass, FalseClass, NilClass
+        return node
       else
-        raise CopyError.new("Unexpected class: #{node.class}")
+        raise StringifyError.new("Unexpected class: #{node.class}")
       end
     end
 

data/spec/common/error_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+require 'schemata/common/error'
+
+describe Schemata do
+  let(:backtrace) { %w(foo bar) }
+  let(:message) { "message" }
+  let(:exception) do
+    error = StandardError.new(message)
+    error.set_backtrace backtrace
+    error
+  end
+
+  describe Schemata::Error do
+    context 'when an exception is explicitly passed in' do
+      context 'and a message is not passed in' do
+        subject { Schemata::Error.new(exception) }
+
+        its(:message) { should eq message }
+        its(:backtrace) { should be_nil }
+      end
+
+      context 'and a message is passed in' do
+        subject { Schemata::Error.new(exception, "other message") }
+
+        its(:message) { should eq "other message" }
+        its(:backtrace) { should be_nil }
+      end
+    end
+
+    context 'when no exception is passed in' do
+      context 'and it is a reraise' do
+        subject do
+          error = nil
+          begin
+            begin
+              raise exception
+            rescue
+              raise Schemata::Error.new
+            end
+          rescue => e
+            error = e
+          end
+          error
+        end
+
+        its(:message) { should eq message }
+        its(:source_backtrace) { should eq backtrace }
+
+        it 'includes the re raised exception' do
+          expect(subject.backtrace.first).to match /error_spec\.rb/
+        end
+
+        it 'includes the chained exception' do
+          expect(subject.backtrace.last).to eq "bar"
+        end
+      end
+
+      context 'and it is a standlone exception' do
+        subject { Schemata::Error.new(nil, message) }
+
+        its(:message) { should eq message }
+        its(:backtrace) { should be_nil }
+      end
+    end
+  end
+
+  describe Schemata::UpdateAttributeError do
+    let(:key) { "key" }
+    subject { Schemata::UpdateAttributeError.new(key, exception) }
+
+    its(:message) { should eq "#{key}: #{message}" }
+    its(:to_s) { should eq "#{key}: #{message}" }
+    its(:key) { should eq key }
+    its(:backtrace) { should be_nil }
+  end
+
+  describe Schemata::IncompatibleVersionError do
+    let(:msg_version) { 1 }
+    let(:component_version) { 2 }
+
+    subject { Schemata::IncompatibleVersionError.new(msg_version, component_version) }
+
+    its(:message) { should eq "min message version #{msg_version} too high for component version #{component_version}" }
+    its(:to_s) { should eq "min message version #{msg_version} too high for component version #{component_version}" }
+    its(:msg_version) { should eq msg_version }
+    its(:component_version) { should eq component_version }
+    its(:backtrace) { should be_nil }
+  end
+end
+

data/spec/common/helpers_spec.rb

@@ -87,29 +87,4 @@ describe Schemata::Helpers do
       end.to raise_error(described_class::CopyError, /Unexpected class: /)
     end
   end
-
-  describe "#stringify" do
-    it "should stringify nil" do
-      str = Schemata::Helpers.stringify(nil)
-      str.should == nil
-    end
-
-    it "should stringify a string" do
-      original = "foo"
-      str = Schemata::Helpers.stringify(original)
-      str.should == "foo"
-    end
-
-    it "should stringify a symbol" do
-      original = :foo
-      str = Schemata::Helpers.stringify(original)
-      str.should == "foo"
-    end
-
-    it "should stringify a hash" do
-      original = { "foo" => :foo }
-      str = Schemata::Helpers.stringify(original)
-      str.should == { "foo" => "foo" }
-    end
-  end
 end

data/spec/common/msgbase_spec.rb

@@ -0,0 +1,162 @@
+require 'spec_helper'
+require 'membrane'
+require 'schemata/helpers'
+require 'schemata/common/msgbase'
+
+describe Schemata::MessageBase do
+  describe Schemata::MessageBase::ValidatingContainer do
+    let(:data) { {"required" => "value"} }
+    let(:validating_container) { Schemata::MessageBase::ValidatingContainer.define(schema) }
+    let(:instance_validating_container) { validating_container.new(data) }
+    let(:schema) do
+      Membrane::SchemaParser.parse do
+        {
+            "required"             => String,
+            optional("optional")   => String
+        }
+      end
+    end
+
+    describe ".new" do
+      context 'when the field is an optional attribute' do
+        let(:data) { {:optional => nil} }
+        it 'allows it to be set to nil' do
+          expect(instance_validating_container.optional).to be_nil
+        end
+      end
+
+      context "when the keys are string in the data" do
+        it { expect(instance_validating_container.required).to eq "value" }
+      end
+
+      context "when keys are symbols in the data due to DEA inconsistencies" do
+        let(:data) { {:required => "value"} }
+
+        it 'stringifies them temporarily' do
+          # TODO Yajl decodes keys become strings. Thus, on the encoding side, Schemata should allow symbols,
+          # but on the decoding side, it should expect strings. E.g. states in dea.find.droplet
+          expect(instance_validating_container.required).to eq "value"
+        end
+      end
+    end
+
+    describe ".define" do
+      context 'when the field is required' do
+        it "doesn't it to be set to nil" do
+          expect { instance_validating_container.required = nil }.to raise_error Membrane::SchemaValidationError
+        end
+      end
+
+      context 'when the field is an optional attribute' do
+        it 'allows it to be set to nil' do
+          expect { instance_validating_container.optional = nil }.not_to raise_error
+        end
+      end
+    end
+
+    describe '#validate' do
+      let(:required) { "foo" }
+      let(:optional) { "bar" }
+
+      subject do
+        instance_validating_container.required = required
+        instance_validating_container.optional = optional
+        instance_validating_container.validate
+      end
+
+      it { expect { subject }.not_to raise_error }
+
+      context 'when the schema an optional nil value' do
+        let(:optional) { nil }
+        it { expect { subject }.not_to raise_error }
+      end
+
+      context 'when the schema an optional wrong type value' do
+        let(:optional) { 123 }
+        it { expect { subject }.to raise_error Membrane::SchemaValidationError }
+      end
+
+      context 'when the schema a required nil value' do
+        let(:required) { nil }
+        it { expect { subject }.to raise_error Membrane::SchemaValidationError }
+      end
+
+      context 'when the schema a required wrong type value' do
+        let(:required) { 123 }
+        it { expect { subject }.to raise_error Membrane::SchemaValidationError }
+      end
+    end
+  end
+
+  describe Schemata::MessageBase::Dsl do
+    describe '#define_aux_schema' do
+      let(:dsl) do
+        class TestDsl
+          extend Schemata::MessageBase::Dsl
+        end
+      end
+
+      after do
+        dsl::AUX_SCHEMA
+      end
+
+      subject do
+        dsl.define_aux_schema &schema
+      end
+
+      context 'when the aux schema is a Record' do
+        let(:schema) { ->(_) { {"key" => String} } }
+
+        it 'sets the AUX_SCHEMA constant to the parse schema' do
+          subject
+          expect(dsl::AUX_SCHEMA).to be_a Membrane::Schema::Record
+        end
+
+        it "correctly parses the schema" do
+          subject
+          expect(dsl::AUX_SCHEMA.schemas["key"].klass).to eq String
+        end
+      end
+
+      context 'when the aux schema is not a Record' do
+        let(:schema) { ->(_) { [String] } }
+        it { expect { subject }.to raise_error Schemata::SchemaDefinitionError, "Schema must be a hash" }
+      end
+    end
+
+    describe '#define_schema' do
+      let(:dsl) do
+        class TestDsl
+          extend Schemata::MessageBase::Dsl
+        end
+      end
+
+      after do
+        dsl::SCHEMA
+      end
+
+      subject do
+        dsl.define_schema &schema
+      end
+
+      context 'when the aux schema is a Record' do
+        let(:schema) { ->(_) { {"key" => String} } }
+
+        it 'sets the SCHEMA constant to the parse schema' do
+          subject
+          expect(dsl::SCHEMA).to be_a Membrane::Schema::Record
+        end
+
+        it "correctly parses the schema" do
+          subject
+          expect(dsl::SCHEMA.schemas["key"].klass).to eq String
+        end
+      end
+
+      context 'when the aux schema is not a Record' do
+        let(:schema) { ->(_) { [String] } }
+        it { expect { subject }.to raise_error Schemata::SchemaDefinitionError, "Schema must be a hash" }
+      end
+    end
+  end
+end

data/spec/common/parsed_msg_spec.rb

@@ -7,7 +7,7 @@ describe Schemata::ParsedMessage do
         "V10" : { "foo" : "bar" }
       }'
       expect {
-        msg = Schemata::ParsedMessage.new(json)
+        Schemata::ParsedMessage.new(json)
       }.to raise_error(Schemata::DecodeError)
     end
 
@@ -17,7 +17,7 @@ describe Schemata::ParsedMessage do
         "foo" : "bar"
       }'
       expect {
-        msg = Schemata::ParsedMessage.new(json)
+        Schemata::ParsedMessage.new(json)
       }.to raise_error(Schemata::DecodeError)
     end
 
@@ -26,7 +26,7 @@ describe Schemata::ParsedMessage do
         "min_version" : 10
       }'
       expect {
-        msg = Schemata::ParsedMessage.new(json)
+        Schemata::ParsedMessage.new(json)
       }.to raise_error(Schemata::DecodeError)
     end
 

data/spec/component/component_foo_spec.rb

@@ -94,7 +94,7 @@ describe Schemata::Component do
       }
       json_msg = Yajl::Encoder.encode msg_hash
       expect {
-        foo_obj = Schemata::Component::Foo.decode(json_msg)
+        Schemata::Component::Foo.decode(json_msg)
       }.to raise_error(Schemata::DecodeError)
     end
 
@@ -104,7 +104,7 @@ describe Schemata::Component do
       }
       json_msg = Yajl::Encoder.encode msg_hash
       expect {
-        foo_obj = Schemata::Component::Foo.decode(json_msg)
+        Schemata::Component::Foo.decode(json_msg)
       }.to raise_error(Schemata::DecodeError)
     end
 
@@ -147,7 +147,7 @@ describe Schemata::Component do
         }
         json_msg = Yajl::Encoder.encode(msg_hash)
         expect {
-          foo_obj = Schemata::Component::Foo.decode(json_msg)
+          Schemata::Component::Foo.decode(json_msg)
         }.to raise_error(Schemata::DecodeError)
       end
 
@@ -164,7 +164,7 @@ of V11 and V10 hashes" do
         }
         json_msg = Yajl::Encoder.encode(msg_hash)
         expect {
-          foo_obj = Schemata::Component::Foo.decode(
+          Schemata::Component::Foo.decode(
             json_msg)
         }.to raise_error(Schemata::DecodeError)
       end
@@ -183,20 +183,20 @@ of V10, V11, and V12 hashes" do
         }
         json_msg = Yajl::Encoder.encode msg_hash
         expect {
-          foo_obj = Schemata::Component::Foo.decode(json_msg)
+          Schemata::Component::Foo.decode(json_msg)
         }.to raise_error(Schemata::DecodeError)
 
         msg_hash["V11"]["foo2"] = "bar"
         msg_hash["V12"]["foo2"] = 1
         json_msg = Yajl::Encoder.encode msg_hash
         expect {
-          foo_obj = Schemata::Component::Foo.decode(json_msg)
+          Schemata::Component::Foo.decode(json_msg)
         }.to raise_error(Schemata::DecodeError)
       end
 
       it "should raise an IncompatibleVersionError when it gets a v13 msg" do
         expect {
-          foo_obj = Schemata::Component::Foo.decode(@v13_msg)
+          Schemata::Component::Foo.decode(@v13_msg)
         }.to raise_error(Schemata::IncompatibleVersionError)
       end
     end
@@ -465,7 +465,7 @@ of V10, V11, and V12 hashes" do
       it "should raise an error if the msg_obj is incomplete" do
         msg_obj = Schemata::Component::Foo::V10.new({"foo1" => "foo"})
         expect {
-          json = msg_obj.encode
+          msg_obj.encode
         }.to raise_error(Schemata::EncodeError)
       end
     end
@@ -475,7 +475,7 @@ of V10, V11, and V12 hashes" do
         set_current_version(Schemata::Component::Foo, 11)
       end
 
-      after:each do
+      after :each do
         reset_version(Schemata::Component::Foo)
       end
 

data/spec/helpers/stringify_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+require 'schemata/helpers'
+
+describe Schemata::Helpers do
+  describe ".stringify" do
+    subject { Schemata::Helpers.stringify_symbols(obj)  }
+
+    context 'when the object is a String' do
+      let(:obj) { "foo" }
+      it { should eq obj }
+    end
+
+    context 'when the object is a symbol' do
+      let(:obj) { :foo }
+      it { should eq "foo" }
+    end
+
+    context 'when the object is a numeric' do
+      let(:obj) { 123.03 }
+      it { should eq obj }
+    end
+
+    context 'when the object is a nil' do
+      let(:obj) { nil }
+      it { should be_nil }
+    end
+
+    context 'when the object is a nil' do
+      let(:obj) { true }
+      it { should be_true }
+    end
+
+    context 'when the object is a nil' do
+      let(:obj) { false }
+      it { should be_false }
+    end
+
+    context 'when the object is an array' do
+      context 'and one of the values is a symobl' do
+        let(:obj) { [:foo, "bar", :baz] }
+        it { should eq %w(foo bar baz) }
+      end
+
+      context 'and their is a nested array' do
+        let(:obj) { [:foo, ["bar", :bar], :baz] }
+        it { should eq ["foo", ["bar", "bar"], "baz"] }
+      end
+    end
+
+    context "when the object is a hash" do
+      context 'and the value is a symbol' do
+        let(:obj) { { "foo" => :foo } }
+        it { should eq("foo" => "foo") }
+      end
+
+      context 'and the key is a symbol' do
+        let(:obj) { { :foo => 'foo'} }
+        it { should eq("foo" => "foo") }
+      end
+
+      context 'and their is a nested hash' do
+        let(:obj) { { :foo => {:foo => 'bar'}} }
+        it { should eq("foo" => {"foo" => "bar"}) }
+      end
+    end
+
+    context 'when the object is a nil' do
+      let(:obj) { Object.new }
+      it { expect { subject }.to raise_error Schemata::Helpers::StringifyError }
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: schemata-dea
 version: !ruby/object:Gem::Version
-  version: 0.0.1.beta18
+  version: 0.0.1.beta20
   prerelease: 6
 platform: ruby
 authors:
@@ -149,9 +149,12 @@ files:
 - lib/schemata/helpers/decamelize.rb
 - lib/schemata/helpers/hash_copy.rb
 - lib/schemata/helpers/stringify.rb
+- lib/schemata/helpers.rb
 - spec/cloud_controller_spec.rb
 - spec/common/componentbase_spec.rb
+- spec/common/error_spec.rb
 - spec/common/helpers_spec.rb
+- spec/common/msgbase_spec.rb
 - spec/common/msgtypebase_spec.rb
 - spec/common/parsed_msg_spec.rb
 - spec/component/aux_data_spec.rb
@@ -161,6 +164,7 @@ files:
 - spec/component2/component2_bar_spec.rb
 - spec/dea_spec.rb
 - spec/health_manager_spec.rb
+- spec/helpers/stringify_spec.rb
 - spec/router_spec.rb
 - spec/spec_helper.rb
 - spec/staging_spec.rb
@@ -195,7 +199,9 @@ summary: validation for cloundfoundry DEA messages
 test_files:
 - spec/cloud_controller_spec.rb
 - spec/common/componentbase_spec.rb
+- spec/common/error_spec.rb
 - spec/common/helpers_spec.rb
+- spec/common/msgbase_spec.rb
 - spec/common/msgtypebase_spec.rb
 - spec/common/parsed_msg_spec.rb
 - spec/component/aux_data_spec.rb
@@ -205,6 +211,7 @@ test_files:
 - spec/component2/component2_bar_spec.rb
 - spec/dea_spec.rb
 - spec/health_manager_spec.rb
+- spec/helpers/stringify_spec.rb
 - spec/router_spec.rb
 - spec/spec_helper.rb
 - spec/staging_spec.rb