sanford-protocol 0.10.0 → 0.11.0

data/lib/sanford-protocol/request.rb

@@ -1,12 +1,8 @@
-# The Request class models a specific type of Sanford message body and provides
-# a defined structure for it. A request requires a message body to contain a
-# name and params.
+require 'sanford-protocol'
 
 module Sanford; end
 module Sanford::Protocol
 
-  BadRequestError = Class.new(RuntimeError)
-
   class Request
 
     def self.parse(body)
@@ -17,12 +13,13 @@ module Sanford::Protocol
 
     def initialize(name, params)
       self.validate!(name, params)
-      @name, @params = name.to_s, params
+      @name   = name.to_s
+      @params = params
     end
 
     def to_hash
       { 'name'   => name,
-        'params' => self.stringify(params)
+        'params' => Sanford::Protocol::StringifyParams.new(params)
       }
     end
 
@@ -49,21 +46,12 @@ module Sanford::Protocol
       problem = if !name
         "The request doesn't contain a name."
       elsif !params.kind_of?(::Hash)
-        "The request's params are not a valid BSON document."
+        "The request's params are not valid."
       end
-      raise(BadRequestError, problem) if problem
+      raise(InvalidError, problem) if problem
     end
 
-    def stringify(object)
-      case(object)
-      when Hash
-        object.inject({}){|h, (k, v)| h.merge({ k.to_s => self.stringify(v) }) }
-      when Array
-        object.map{|item| self.stringify(item) }
-      else
-        object
-      end
-    end
+    InvalidError = Class.new(ArgumentError)
 
   end
 

data/lib/sanford-protocol/version.rb

@@ -1,5 +1,5 @@
 module Sanford
   module Protocol
-    GEM_VERSION = "0.10.0"
+    GEM_VERSION = "0.11.0"
   end
 end

data/lib/sanford-protocol.rb

@@ -49,5 +49,18 @@ module Sanford
       def decode(binary); ::BSON.deserialize(binary); end
     end
 
+    module StringifyParams
+      def self.new(object)
+        case(object)
+        when Hash
+          object.inject({}){ |h, (k, v)| h.merge(k.to_s => self.new(v)) }
+        when Array
+          object.map{ |item| self.new(item) }
+        else
+          object
+        end
+      end
+    end
+
   end
 end

data/test/unit/request_tests.rb

@@ -6,85 +6,76 @@ class Sanford::Protocol::Request
   class UnitTests < Assert::Context
     desc "Sanford::Protocol::Request"
     setup do
-      @request = Sanford::Protocol::Request.new('some_service', { 'key' => 'value' })
+      @name   = Factory.string
+      @params = { Factory.string => Factory.string }
+      @request_class = Sanford::Protocol::Request
+    end
+    subject{ @request_class }
+
+    should have_imeths :parse
+
+    should "parse a request from a body hash" do
+      request = @request_class.parse({
+        'name'   => @name,
+        'params' => @params
+      })
+
+      assert_instance_of @request_class, request
+      assert_equal @name,   request.name
+      assert_equal @params, request.params
+    end
+
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    setup do
+      @request = @request_class.new(@name, @params)
     end
     subject{ @request }
 
     should have_imeths :name, :params, :to_hash
-    should have_cmeths :parse
 
     should "know its name and params" do
-      assert_equal 'some_service', subject.name
-      assert_equal({ 'key' => 'value' }, subject.params)
+      assert_equal @name,   subject.name
+      assert_equal @params, subject.params
     end
 
     should "force string request names" do
-      request = Sanford::Protocol::Request.new(:symbol_service_name, {})
-      assert_equal 'symbol_service_name', request.name
+      request = @request_class.new(@name.to_sym, {})
+      assert_equal @name, request.name
     end
 
-    should "return it's name with #to_s" do
+    should "return its name using `to_s`" do
       assert_equal subject.name, subject.to_s
     end
 
-    should "parse requests given a body hash" do
-      # using BSON messages are hashes
-      hash = {
-        'name'   => 'service_name',
-        'params' => { 'service_params' => 'yes' }
+    should "return the request as a hash using `to_hash`" do
+      @params[Factory.integer]       = Factory.integer
+      @params[Factory.string.to_sym] = Factory.string.to_sym
+      request = @request_class.new(@name, @params)
+      exp = {
+        'name'   => @name,
+        'params' => Sanford::Protocol::StringifyParams.new(@params)
       }
-      request = Sanford::Protocol::Request.parse(hash)
-
-      assert_instance_of Sanford::Protocol::Request, request
-      assert_equal hash['name'],   request.name
-      assert_equal hash['params'], request.params
-    end
-
-    should "return the request as a hash with stringified params with #to_hash" do
-      # using BSON, messages are hashes
-      request = Sanford::Protocol::Request.new('service', {
-        1 => 1,
-        :symbol => :symbol
-      })
-      expected = {
-        'name'   => 'service',
-        'params' => { '1' => 1, 'symbol' => :symbol }
-      }
-      assert_equal expected, request.to_hash
+      assert_equal exp, request.to_hash
     end
 
     should "be comparable" do
-      match_request = Sanford::Protocol::Request.new(
-        subject.name.dup,
-        subject.params.dup
-      )
-      assert_equal match_request, subject
-
-      not_match_request = Sanford::Protocol::Request.new('other', {})
-      assert_not_equal not_match_request, subject
-    end
-
-  end
+      matching = @request_class.new(@name, @params)
+      assert_equal matching, subject
 
-  class ValidTests < UnitTests
-
-    should "not raise an exception with valid request args" do
-      assert_nothing_raised do
-        Sanford::Protocol::Request.new('name', {})
-      end
+      non_matching = @request_class.new(Factory.string, @params)
+      assert_not_equal non_matching, subject
+      non_matching = @request_class.new(@name, Factory.string => Factory.string)
+      assert_not_equal non_matching, subject
     end
 
-    should "raise an exception when there isn't a name arg" do
-      assert_raises(Sanford::Protocol::BadRequestError) do
-        Sanford::Protocol::Request.new(nil, {})
-      end
+    should "raise an error when given invalid attributes" do
+      assert_raises(InvalidError){ @request_class.new(nil, @params) }
+      assert_raises(InvalidError){ @request_class.new(@name, Factory.string) }
     end
 
-    should "return false and a message when the params are not a Hash" do
-      assert_raises(Sanford::Protocol::BadRequestError) do
-        Sanford::Protocol::Request.new('name', true)
-      end
-    end
   end
 
 end

data/test/unit/sanford-protocol_tests.rb

@@ -20,27 +20,27 @@ module Sanford::Protocol
     should "encode the protocol version to a 1B binary string" do
       assert_equal 1, subject.msg_version.bytesize
 
-      expected = [ subject::VERSION ].pack('C')
-      assert_equal expected, subject.msg_version
+      exp = [subject::VERSION].pack('C')
+      assert_equal exp, subject.msg_version
     end
 
     should "encode/decode the size to/from a 4B binary string" do
       assert_equal 4, subject.msg_size.bytes
 
       size   = (2 ** 32) - 1 # the max number it supports
-      binary = [ size ].pack('N')
+      binary = [size].pack('N')
       assert_equal binary, subject.msg_size.encode(size)
       assert_equal size,   subject.msg_size.decode(binary)
     end
 
     should "encode the body to BSON" do
       data = {
-        'string'  => 'test',
-        'int'     => 1,
-        'float'   => 2.1,
-        'boolean' => true,
-        'array'   => [ 1, 2, 3 ],
-        'hash'    => { 'something' => 'else' }
+        'string'  => Factory.string,
+        'int'     => Factory.integer,
+        'float'   => Factory.float,
+        'boolean' => Factory.boolean,
+        'array'   => Factory.integer(3).times.map{ Factory.integer },
+        'hash'    => { Factory.string => Factory.string }
       }
       binary = ::BSON.serialize(data).to_s
 
@@ -49,4 +49,28 @@ module Sanford::Protocol
     end
 
   end
+
+  class StringifyParamsTests < UnitTests
+    desc "StringifyParams"
+    subject{ StringifyParams }
+
+    should have_imeths :new
+
+    should "convert all hash keys to strings" do
+      key, value = Factory.string.to_sym, Factory.string
+      result = subject.new({
+        key    => value,
+        :hash  => { key => [value] },
+        :array => [{ key => value }]
+      })
+      exp = {
+        key.to_s => value,
+        'hash'   => { key.to_s => [value] },
+        'array'  => [{ key.to_s => value }]
+      }
+      assert_equal exp, result
+    end
+
+  end
+
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: sanford-protocol
 version: !ruby/object:Gem::Version 
-  hash: 55
+  hash: 51
   prerelease: 
   segments: 
   - 0
-  - 10
+  - 11
   - 0
-  version: 0.10.0
+  version: 0.11.0
 platform: ruby
 authors: 
 - Collin Redding
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2014-09-26 00:00:00 Z
+date: 2015-06-19 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   requirement: &id001 !ruby/object:Gem::Requirement 
@@ -37,9 +37,9 @@ dependencies:
         - 10
         - 0
         version: 1.10.0
-  version_requirements: *id001
   type: :runtime
   name: bson
+  version_requirements: *id001
   prerelease: false
 - !ruby/object:Gem::Dependency 
   requirement: &id002 !ruby/object:Gem::Requirement 
@@ -52,9 +52,9 @@ dependencies:
         - 2
         - 11
         version: "2.11"
-  version_requirements: *id002
   type: :development
   name: assert
+  version_requirements: *id002
   prerelease: false
 description: Ruby implementation of the Sanford TCP communication protocol.
 email: 
@@ -123,7 +123,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.29
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Ruby implementation of the Sanford TCP communication protocol.