hoth 0.2.2 → 0.3.0

data/README.rdoc

@@ -40,13 +40,13 @@ After defining all you services, you need to specify in which modules they live.
           endpoint :default do
             host 'localhost'
             port 3000
-            transport_type :http
+            transport :http
           end
 
           endpoint :bert do
             host 'localhost'
             port 9999
-            transport_type :bert
+            transport :bert
           end
         end
 
@@ -54,13 +54,13 @@ After defining all you services, you need to specify in which modules they live.
           endpoint :default do
             host '192.168.1.12'
             port 3000
-            transport_type :http
+            transport :http
           end
 
           endpoint :bert do
             host '192.168.1.15'
             port 9999
-            transport_type :bert
+            transport :bert
           end
         end
     

data/TODO

@@ -0,0 +1,2 @@
+* Make the rack provider independent from one specific transport.
+* Make the bodies of the rack_provider return an object which responds to each in order not break on Ruby 1.9.

data/lib/hoth.rb

@@ -2,10 +2,8 @@ require 'singleton'
 
 require 'active_support/inflector'
 
-require 'hoth/transport/hoth_transport'
-require 'hoth/transport/http_transport'
-require 'hoth/transport/bert_transport'
-require 'hoth/transport/workling_transport'
+# must be loaded after alls transports and all encodings
+require 'hoth/transport'
 
 require 'hoth/service_definition'
 require 'hoth/service_module'

data/lib/hoth/encoding/json.rb

@@ -0,0 +1,28 @@
+require 'json'
+
+module Hoth
+  module Encoding
+    class Json
+      
+      class <<self
+        def encode(string)
+          string.to_json
+        end
+
+        def decode(string)
+          begin
+            Hoth::Logger.debug "Original params before decode: #{string.inspect}"
+            JSON.parse(string)
+          rescue JSON::ParserError => jpe
+            raise EncodingError.wrap(jpe)
+          end
+        end
+        
+        def content_type
+          "application/json"
+        end
+      end
+      
+    end
+  end
+end

data/lib/hoth/encoding/no_op.rb

@@ -0,0 +1,19 @@
+module Hoth
+  module Encoding
+    class NoOp
+      
+      class <<self
+        def encode(string)
+          string
+        end
+
+        def decode(string)
+          string
+        end
+        
+        def content_type; end
+      end
+      
+    end
+  end
+end

data/lib/hoth/endpoint.rb

@@ -1,6 +1,6 @@
 module Hoth
   class Endpoint
-    attr_accessor :host, :port, :module_name, :transport_type
+    attr_accessor :host, :port, :module_name, :transport
     
     class ConfigEvaluator
       attr_reader :endpoint
@@ -9,7 +9,7 @@ module Hoth
         instance_eval(&block)
       end
       
-      [:host, :port, :module_name, :transport_type].each do |endpoint_attribute|
+      [:host, :port, :module_name, :transport].each do |endpoint_attribute|
         define_method endpoint_attribute do |value|
           endpoint.send("#{endpoint_attribute}=", value)
         end
@@ -23,5 +23,6 @@ module Hoth
     def to_url
       "http://#{@host}:#{@port}/execute"
     end
+    
   end
 end

data/lib/hoth/exceptions.rb

@@ -10,4 +10,5 @@ module Hoth
   end
 
   class TransportError < HothException; end
+  class TransportException < HothException; end
 end

data/lib/hoth/extension/core/exception.rb

@@ -1,10 +1,10 @@
 class Exception
-  def to_json(*a)
+  def to_json(*params)
     {
       'json_class'   => self.class.name,
       'message'      => self.message,
       'backtrace'    => self.backtrace
-    }.to_json(*a)
+    }.to_json(*params)
   end
   
   def self.json_create(hash)

data/lib/hoth/providers/bertrpc_provider.rb

@@ -14,7 +14,7 @@ module Hoth
               mod(service_name) do
                 fun(:execute) do |*args|
                   return_value = begin
-                    Hoth::Transport::BertTransport::TuplePreparer.prepare(Hoth::Services.send(service_name, *args))
+                    Hoth::Transport::Bert::TuplePreparer.prepare(Hoth::Services.send(service_name, *args))
                   rescue Exception => e
                     Ernie.log %Q{An Exception occured: #{e.message} -- #{e.backtrace.join("\n\t")}}
                     false

data/lib/hoth/providers/rack_provider.rb

@@ -1,5 +1,4 @@
 require 'rack/request'
-require 'json'
 
 module Hoth
   module Providers
@@ -10,24 +9,37 @@ module Hoth
       end
 
       def call(env)
+        Hoth::Logger.debug "env: #{env.inspect}"
         if env["PATH_INFO"] =~ /^\/execute/
           begin
             req = Rack::Request.new(env)
 
             service_name   = req.params["name"]
             service_params = req.params["params"]
-            json_payload   = JSON({"result" => Hoth::Services.send(service_name, service_params)})
+            
+            responsible_service = ServiceRegistry.locate_service(service_name)
+            
+            decoded_params = responsible_service.transport.encoder.decode(service_params)
+            result = Hoth::Services.send(service_name, *decoded_params)
+            
+            encoded_result = responsible_service.transport.encoder.encode({"result" => result})
           
-            [200, {'Content-Type' => 'application/json', 'Content-Length' => "#{json_payload.length}"}, json_payload]
+            [200, {'Content-Type' => responsible_service.transport.encoder.content_type, 'Content-Length' => "#{encoded_result.length}"}, [encoded_result]]
           rescue Exception => e
-            json_payload = JSON({'error' => e})
-            [500, {'Content-Type' => 'application/json', 'Content-Length' => "#{json_payload.length}"}, json_payload]
+            Hoth::Logger.debug "e: #{e.message}"
+            if responsible_service
+              encoded_error = responsible_service.transport.encoder.encode({"error" => e})
+              [500, {'Content-Type' => service.transport.encoder.content_type, 'Content-Length' => "#{encoded_error.length}"}, [encoded_error]]
+            else
+              plain_error = "An error occuered! (#{e.message})"
+              [500, {'Content-Type' => "text/plain", 'Content-Length' => "#{plain_error.length}"}, [plain_error]]
+            end
           end
         else
           @app.call(env)
         end
       end
-
+      
     end
   end
 end

data/lib/hoth/service.rb

@@ -1,6 +1,6 @@
 module Hoth
   class Service
-    attr_accessor :name, :params_arity, :return_value, :module
+    attr_accessor :name, :params_arity, :module
     
     def initialize(name, &block)
       @name         = name
@@ -13,7 +13,7 @@ module Hoth
     end
     
     def transport
-      @transport ||= "hoth/transport/#{endpoint.transport_type}_transport".camelize.constantize.new(self)
+      @transport ||= Transport.create(endpoint.transport, self)
     end
     
     def impl_class
@@ -31,17 +31,12 @@ module Hoth
     end
     
     def execute(*args)
-      if self.is_local?
-        decoded_params = transport.decode_params(*args)
-        result = impl_class.send(:execute, *decoded_params)
-        return return_nothing? ? nil : result
-      else
-        transport.call_remote_with(*args)
-      end
+      result = self.is_local? ? impl_class.send(:execute, *args) : transport.call_remote_with(*args)
+      return return_nothing? ? nil : result
     end
     
     def return_nothing?
-      return_value == :nothing || return_value == :nil || return_value == nil
+      [:nothing, :nil, nil].include? @return_value
     end
     
     def via_endpoint(via = nil)
@@ -52,4 +47,4 @@ module Hoth
       @endpoint ||= self.module[Hoth.env][@via_endpoint]
     end
   end
-end
+end

data/lib/hoth/service_definition.rb

@@ -1,5 +1,16 @@
 module Hoth
   class ServiceDefinition
+    
+    # create a new service with service_name and register it at the
+    # ServiceRegistry. The paramters of the block define the parameters of the
+    # defined service. Within the block you can describe the return value.
+    #
+    # Example:
+    #
+    #     service :create_account do |account|
+    #       returns :account_id
+    #     end
+    #
     def service(service_name, &block)
       ServiceRegistry.add_service(Service.new(service_name, &block))
     end

data/lib/hoth/service_module.rb

@@ -31,17 +31,11 @@ module Hoth
     end
     
     def add_service(service_name, options = {})
-      unless self.environments[Hoth.env]
-        puts("no endpoint-definition for environment '#{Hoth.env}' and service '#{service_name}'")
-        exit
-      end
+      raise HothException.new("no endpoint-definition for environment '#{Hoth.env}' and service '#{service_name}'") unless self.environments[Hoth.env]
 
       service = ServiceRegistry.locate_service(service_name.to_sym)
 
-      unless service
-        puts("tried to add service '#{service_name}' but was not defined by service-definition")
-        exit
-      end
+      raise HothException.new("tried to add service '#{service_name}' but was not defined by service-definition") unless service
       
       service.module = self
       service.via_endpoint(options[:via])

data/lib/hoth/service_registry.rb

@@ -1,26 +1,33 @@
 module Hoth
+  
+  # The ServiceRegistry knows all registered services. You can register new
+  # services and locate existing services.
+  
   class ServiceRegistry
     include Singleton
     
+    # add a service to the registry
     def self.add_service(service)
       instance.add_service(service)
     end
+    # alias_method :register_service, :add_service
     
+    # find a service with a given name
     def self.locate_service(service_name)
       instance.locate_service(service_name)
     end
     
-    def add_service(service)
+    def add_service(service) # :nodoc:
       @registry[service.name.to_sym] = service
     end
     
-    def locate_service(service_name)
+    def locate_service(service_name) # :nodoc:
       @registry[service_name.to_sym]
     end
     
     private
-    
-      def initialize
+      
+      def initialize # :nodoc:
         @registry = {}
       end
   end

data/lib/hoth/services.rb

@@ -1,17 +1,45 @@
 module Hoth
   class Services
+    
+    # With Hoth::Services.define followed by a block you define all your
+    # available services.
+    #
+    # Example:
+    #
+    #     Hoth::Services.define do
+    #       
+    #       service :increment_counter do |counter|
+    #         returns :nothing
+    #       end
+    #       
+    #       service :value_of_counter do |counter|
+    #         returns :fixnum
+    #       end
+    #       
+    #       service :create_account do |account|
+    #         returns :account_id
+    #       end
+    #       
+    #     end
+    #   
+    # after defining your services you can call each of them with
+    # <tt>Hoth::Services.service_name(params)</tt>
+    #       
+    #     Hoth::Services.increment_counter(counter)
+    #     current_number = Hoth::Services.value_of_counter(counter)
+    #     created_account = Hoth::Services.create_account(account)
+    #
+    # see Hoth::ServiceDefinition for further informations of the block
+    # content.
+    
     def self.define(&block)
       ServiceDefinition.new.instance_eval(&block)
     end
     
     class <<self
-      attr_writer :env
-      
-      def env
-        @env.to_sym
-      end
-      
-      def method_missing(meth, *args, &blk)
+
+      # this is where the services get called
+      def method_missing(meth, *args, &blk) # :nodoc:
         if _service = ServiceRegistry.locate_service(meth)
           _service.execute(*args)
         else

data/lib/hoth/transport.rb

@@ -0,0 +1,42 @@
+require 'hoth/transport/base'
+require 'hoth/transport/http'
+require 'hoth/transport/bert'
+require 'hoth/transport/workling'
+
+require 'hoth/encoding/json'
+require 'hoth/encoding/no_op'
+
+module Hoth
+  module Transport
+    
+    POSSIBLE_TRANSPORTS = {
+      :json_via_http => {
+        :transport_class => Transport::Http,
+        :encoder => Encoding::Json
+      },
+      :http => :json_via_http,
+      :workling => {
+        :transport_class => Transport::Workling
+      }
+    }
+    
+    class <<self
+      def create(transport_name, service)
+        new_transport_with_encoding(transport_name, service)
+      end
+
+      def new_transport_with_encoding(transport_name, service)
+        if POSSIBLE_TRANSPORTS[transport_name.to_sym]
+          if POSSIBLE_TRANSPORTS[transport_name.to_sym].kind_of?(Hash)
+            POSSIBLE_TRANSPORTS[transport_name.to_sym][:transport_class].new(service, :encoder => POSSIBLE_TRANSPORTS[transport_name.to_sym][:encoder])
+          else
+            new_transport_with_encoding(POSSIBLE_TRANSPORTS[transport_name.to_sym], service)
+          end
+        else
+          raise TransportException.new("specified transport '#{transport_name}' does not exist, use one of these: #{POSSIBLE_TRANSPORTS.keys.join(", ")}")
+        end
+      end
+    end
+    
+  end
+end

data/lib/hoth/transport/{hoth_transport.rb → base.rb}

@@ -1,14 +1,17 @@
 require 'forwardable'
-
+ 
 module Hoth
   module Transport
-    class HothTransport
+    class Base
       extend Forwardable
       
-      def_delegators :@service_delegate, :name, :module, :endpoint, :params, :return_value
+      attr_reader :encoder
       
-      def initialize(service_delegate)
+      def_delegators :@service_delegate, :name, :module, :endpoint, :params, :return_nothing?
+      
+      def initialize(service_delegate, options = {})
         @service_delegate = service_delegate
+        @encoder = options[:encoder] || Encoding::NoOp
       end
       
     end

data/lib/hoth/transport/{bert_transport.rb → bert.rb}

@@ -3,7 +3,7 @@ require 'bertrpc'
 
 module Hoth
   module Transport
-    class BertTransport < HothTransport
+    class Bert < Base
       
       class TuplePreparer
         def self.prepare(obj)

data/lib/hoth/transport/http.rb

@@ -0,0 +1,45 @@
+require 'net/http'
+
+module Hoth
+  module Transport
+    class Http < Base     
+      def call_remote_with(*params)
+        unless return_nothing?
+          begin
+            handle_response post_payload(params)
+          rescue Exception => e
+            raise TransportError.wrap(e)
+          end
+        else
+          return nil
+        end
+      end
+      
+      def handle_response(response)
+        case response
+        when Net::HTTPSuccess
+          Hoth::Logger.debug "response.body: #{response.body}"
+          encoder.decode(response.body)["result"]
+        when Net::HTTPServerError
+          begin
+            Hoth::Logger.debug "response.body: #{response.body}"
+            raise encoder.decode(response.body)["error"]
+          rescue JSON::ParserError => jpe
+            raise TransportError.wrap(jpe)
+          end
+        when Net::HTTPRedirection, Net::HTTPClientError, Net::HTTPInformation, Net::HTTPUnknownResponse
+          raise NotImplementedError, "code: #{response.code}, message: #{response.body}"
+        end
+      end
+      
+      def post_payload(payload)
+        uri = URI.parse(self.endpoint.to_url)
+        return Net::HTTP.post_form(uri,
+          'name'   => self.name.to_s,
+          'params' => encoder.encode(payload)
+        )
+      end
+      
+    end
+  end
+end

data/lib/hoth/transport/{workling_transport.rb → workling.rb}

@@ -4,25 +4,17 @@ rescue LoadError
   STDERR.puts "You need the simple_publisher gem if you want to use Workling/Starling transport."
 end
 
-
-
-
-
 module Hoth
   module Transport
     
-    class WorklingTransport < HothTransport
+    class Workling < Base
       
       def call_remote_with(*args)
         topic      = SimplePublisher::Topic.new(:name => "#{self.module.name.to_s.underscore}_subscribers__#{name.to_s.underscore}")
         connection = SimplePublisher::StarlingConnection.new(:host => endpoint.host, :port => endpoint.port)
 
         publisher = SimplePublisher::Publisher.new(:topic => topic, :connection => connection)
-        publisher.publish(args)
-      end
-      
-      def decode_params(*params)
-        params
+        publisher.publish(encoder.encode(args))
       end
       
     end

data/spec/unit/encoding/json_spec.rb

@@ -0,0 +1,25 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../../',  'spec_helper'))
+
+module Hoth
+  module Encoding
+    
+    describe Json do
+      
+      it "should decode a JSON string" do
+        decoded_json = Json.decode '{"test":23}'
+        decoded_json.should ==({"test" => 23})
+      end
+      
+      it "should encode a JSON string" do
+        encoded_json = Json.encode({"test" => 23})
+        '{"test":23}'.should == encoded_json
+      end
+      
+      it "should know its ContentType" do
+        Json.content_type.should == "application/json"
+      end
+      
+    end
+    
+  end
+end

data/spec/unit/endpoint_spec.rb

@@ -1,30 +1,34 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
 
-describe Hoth::Endpoint do
+module Hoth
   
-  it "should have a port" do
-    endpoint = Hoth::Endpoint.new { port 3000 }
-    endpoint.port.should == 3000
-  end
+  describe Endpoint do
   
-  it "should have a host name" do
-    endpoint = Hoth::Endpoint.new { host "example.com" }
-    endpoint.host.should == "example.com"
-  end
+    it "should have a port" do
+      endpoint = Endpoint.new { port 3000 }
+      endpoint.port.should == 3000
+    end
   
-  it "should have a transport type" do
-    endpoint = Hoth::Endpoint.new { transport_type :json }
-    endpoint.transport_type.should == :json
-  end
+    it "should have a host name" do
+      endpoint = Endpoint.new { host "example.com" }
+      endpoint.host.should == "example.com"
+    end
   
-  it "should should cast itself to URL string" do
-    endpoint = Hoth::Endpoint.new { port 3000; host "example.com" }
-    endpoint.to_url.should == "http://example.com:3000/execute"
-  end
+    it "should have a transport name" do
+      endpoint = Endpoint.new { transport :json_via_http }
+      endpoint.transport.should == :json_via_http
+    end
+  
+    it "should should cast itself to URL string" do
+      endpoint = Endpoint.new { port 3000; host "example.com" }
+      endpoint.to_url.should == "http://example.com:3000/execute"
+    end
     
-  it "should should know the deployment module this endpoint is associated to" do
-    endpoint = Hoth::Endpoint.new { module_name "TestModule" }
-    endpoint.module_name.should == "TestModule"
+    it "should should know the deployment module this endpoint is associated to" do
+      endpoint = Endpoint.new { module_name "TestModule" }
+      endpoint.module_name.should == "TestModule"
+    end
+  
   end
   
 end

data/spec/unit/providers/rack_provider_spec.rb

@@ -2,16 +2,48 @@ require File.expand_path(File.join(File.dirname(__FILE__), '../../',  'spec_help
 
 require File.expand_path(File.join(File.dirname(__FILE__), '../../../',  'lib', 'hoth', 'providers', 'rack_provider'))
 
-describe Hoth::Providers::RackProvider do
-  it "should be able to handle exceptions" do
-    app = stub("ApplicationStub").as_null_object
-    middleware = Hoth::Providers::RackProvider.new app
-    env = {"PATH_INFO" => "/execute/some_method", "other_params" => nil}
-    Rack::Request.should_receive(:new).and_raise(RuntimeError)
+require 'rack/mock'
+
+module Hoth
+  module Providers
+    
+    describe RackProvider do
+      
+      it "should get transport and encoder based on called service" do
+        app = stub("ApplicationStub").as_null_object
+        middleware = Hoth::Providers::RackProvider.new(app)
+        
+        encoder = mock("EncoderMock")
+        encoder.should_receive(:decode).with("some_parameter").and_return(decoded_params = "some_parameter_decoded")
+        encoder.should_receive(:content_type).and_return("application/json")
+        
+        transport = mock("TransportMock")
+        transport.should_receive(:encoder).exactly(3).times.and_return(encoder)
+        
+        service = mock("ServiceMock")
+        service.should_receive(:transport).exactly(3).times.and_return(transport)
+        ServiceRegistry.should_receive(:locate_service).with("service_name").and_return(service)
+        
+        Hoth::Services.should_receive(:send).with("service_name", *decoded_params).and_return(service_result = "result")
+        encoder.should_receive(:encode).with({"result" => service_result}).and_return("result_encoded")
+        
+        mock_request = Rack::MockRequest.new(middleware)
+        mock_request.post("http://localhost/execute?name=service_name&params=some_parameter")
+      end
+      
+      it "should be able to handle exceptions" do
+        app = stub("ApplicationStub").as_null_object
+        middleware = Hoth::Providers::RackProvider.new app
+        env = {"PATH_INFO" => "/execute/some_method", "other_params" => nil}
+        Rack::Request.should_receive(:new).and_raise(RuntimeError)
+      
+        rack_response = middleware.call env
+        rack_response.first.should == 500 #status code
+        rack_response.last.should be_a_kind_of(Array)
+        rack_response.last.first.should == "An error occuered! (RuntimeError)"
+      end
+      
+    end
     
-    rack_response = middleware.call env
-    rack_response.first.should == 500 #status code
-    rack_response.last.should match('json_class')
-    rack_response.last.should match('RuntimeError')
   end
 end

data/spec/unit/service_definition_spec.rb

@@ -14,7 +14,7 @@ module Hoth
       service = ServiceRegistry.locate_service(service_name)
       service.should_not be(nil)
       service.params_arity.should be(1)
-      service.return_value.should be(:nothing)
+      service.return_nothing?.should be(true)
     end
   
   end

data/spec/unit/service_spec.rb

@@ -2,7 +2,6 @@ require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
 
 class TestServiceImpl
   def self.execute(param1, param2)
-    
   end
 end
 
@@ -16,7 +15,7 @@ module Hoth
       service = Service.new("TestService", &service_block)
 
       service.params_arity.should be(3)
-      service.return_value.should be(:some_data)
+      service.return_nothing?.should be(false)
     end
     
     it "should know its service-impl class" do
@@ -26,15 +25,22 @@ module Hoth
     
     it "should know that its service-impl class is not available" do
       service = Service.new("TestServiceWithoutImplClass") {}
-      service.impl_class
+      service.impl_class.should be(false)
+    end
+    
+    it "should know if it is local or not based on Impl-Class availability" do
+      service = Service.new("TestServiceWithoutImplClass") {}
+      service.is_local?.should be(false)
+
+      service = Service.new("test_service") {}
+      service.is_local?.should be(true)
     end
     
     it "should execute the service stub locally if its impl-class was found" do
       service = Service.new("test_service") { |p1, p2| returns :nothing }
       
-      service.should_receive(:transport).and_return(transport = mock("TransportMock"))
-      transport.should_receive(:decode_params).with(:arg1, :arg2).and_return(decoded_params = mock("DecodedParamsMock"))
-      service.impl_class.should_receive(:execute).with(decoded_params)
+      service.should_receive(:is_local?).and_return(true)
+      service.impl_class.should_receive(:execute).with(:arg1, :arg2)
       
       service.execute(:arg1, :arg2)
     end
@@ -42,6 +48,7 @@ module Hoth
     it "should call the remote service if impl-class does not exist" do
       service = Service.new("test_service_without_impl") { |p1, p2| returns :nothing }
       
+      service.should_receive(:is_local?).and_return(false)
       service.should_receive(:transport).and_return(transport = mock("TransportMock"))
       transport.should_receive(:call_remote_with).with(:arg1, :arg2)
       
@@ -51,8 +58,8 @@ module Hoth
     it "should create transport instance based on endpoint" do
       service = Service.new("test_service") { |p1, p2| returns :nothing }
       service.should_receive(:endpoint).and_return(endpoint = mock("EndpointMock"))
-      endpoint.should_receive(:transport_type).and_return(:http)
-      Hoth::Transport::HttpTransport.should_receive(:new).with(service)
+      endpoint.should_receive(:transport).and_return(:http)
+      Hoth::Transport.should_receive(:create).with(:http, service)
       service.transport
     end
   

data/spec/unit/transport/base_spec.rb

@@ -0,0 +1,43 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../../',  'spec_helper'))
+
+module Hoth
+  module Transport
+    
+    describe "Base" do
+      
+      it "should initialize with service-delegate" do
+        service = mock("ServiceMock")
+        transport = Base.new(service)
+      end
+      
+      it "should use an NoOp encoder if no encoder class was given at all" do
+        service = mock("ServiceMock")
+        transport = Base.new(service)
+        transport.encoder.should == Encoding::NoOp
+      end
+      
+      it "should delegate calls to service-delegate" do
+        service = mock("ServiceMock")
+        service.should_receive(:name)
+        service.should_receive(:module)
+        service.should_receive(:endpoint)
+        service.should_receive(:params)
+        service.should_receive(:return_nothing?)
+        transport = Base.new(service)
+        
+        [:name, :module, :endpoint, :params, :return_nothing?].each do |method|
+          transport.send(method)
+        end
+      end
+      
+      it "should have an encoder" do
+        service = mock("ServiceMock")
+        encoder = mock("EncoderMock")
+        transport = Base.new(service, :encoder => encoder)
+        transport.encoder.should be(encoder)
+      end
+            
+    end
+    
+  end
+end

data/spec/unit/transport/http_spec.rb

@@ -0,0 +1,77 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../../',  'spec_helper'))
+
+module Hoth
+  module Transport
+    describe Http do
+      
+      before(:each) do
+        @service_mock = mock("ServiceMock")
+      end
+      
+      it "should call a remote via http" do
+        @service_mock.should_receive(:return_nothing?).and_return(false)
+        
+        params = {:first_name => "Seras", :last_name => "Victoria"}
+
+        transport = Http.new(@service_mock)
+        transport.should_receive(:post_payload).with([params])
+        transport.call_remote_with(params)
+      end
+      
+      it "should post payload encoded with JSON" do
+        @service_mock.should_receive(:endpoint).and_return(endpoint = mock("EndpointMock"))
+        @service_mock.should_receive(:name).and_return("service_name")
+        endpoint.should_receive(:to_url).and_return("http://localhost:3000/execute")
+
+        encoder = mock("JsonEncoderMock")
+        encoder.should_receive(:encode).with("params").and_return("encoded_params")
+        
+        URI.should_receive(:parse).with("http://localhost:3000/execute").and_return(uri = mock("URIMock"))
+        Net::HTTP.should_receive(:post_form).with(uri, {"name" => "service_name", "params" => "encoded_params"})
+        
+        transport = Http.new(@service_mock, {:encoder => encoder})
+        transport.post_payload("params")
+      end
+      
+      describe "Error Handling" do
+        
+        before(:each) do
+          service_mock = mock("ServiceMock")
+          service_mock.should_receive(:return_nothing?).any_number_of_times.and_return(false)
+
+          @params    = {:first_name => "Seras", :last_name => "Victoria"}
+          encoder    = mock("JsonEncoderMock")
+          @transport = Http.new(service_mock, {:encoder => encoder})
+        end
+        
+        it "should handle http connection error" do
+          @transport.should_receive(:post_payload).and_raise(Exception)
+          lambda { @transport.call_remote_with(@params) }.should raise_error(TransportError)
+        end
+
+        it "should handle successful response" do
+          @transport.should_receive(:post_payload).and_return(response = Net::HTTPSuccess.allocate)
+          response.should_receive(:body).twice.and_return(response_body = '{"result" : "return_value"}')
+          @transport.encoder.should_receive(:decode).with(response_body).and_return({"result" => "return_value"})
+          @transport.call_remote_with(@params)
+        end
+
+        it "should handle remote server error" do
+          @transport.should_receive(:post_payload).and_return(response = Net::HTTPServerError.allocate)
+          response.should_receive(:body).any_number_of_times.and_return(response_body = '{"error" : "ServerError"}')
+          @transport.encoder.should_receive(:decode).with(response_body).and_return({"result" => "return_value"})
+          lambda { @transport.call_remote_with(@params) }.should raise_error(TransportError)
+        end
+
+        it "should handle any other HTTP errors" do
+          [Net::HTTPRedirection, Net::HTTPClientError, Net::HTTPInformation, Net::HTTPUnknownResponse].each do |http_response|
+            @transport.should_receive(:post_payload).and_return(response = http_response.allocate)
+            response.should_receive(:body).any_number_of_times.and_return('{"error" : "ServerError"}')
+            lambda { @transport.call_remote_with(@params) }.should raise_error(TransportError)
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/transport/{workling_transport_spec.rb → workling_spec.rb}

@@ -3,7 +3,7 @@ require File.expand_path(File.join(File.dirname(__FILE__), '../../',  'spec_help
 module Hoth
   module Transport
     
-    describe "WorklingTransport" do
+    describe "Workling" do
       
       it "should send publish a message via SimplePublisher" do
         endpoint = mock("EndpointMock")
@@ -32,17 +32,10 @@ module Hoth
 
         publisher.should_receive(:publish).with([uid, email_address])
         
-        transport = WorklingTransport.new(service)
+        transport = Workling.new(service)
         transport.call_remote_with(uid, email_address)
       end
       
-      it "should decode params from a message wrapper" do
-        params_as_message = ["uid"]
-        
-        transport = WorklingTransport.new(mock("ServiceMock"))
-        transport.decode_params(*params_as_message).should == ["uid"]
-      end
-      
     end
     
   end

data/spec/unit/transport_spec.rb

@@ -0,0 +1,29 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+module Hoth
+  describe Transport do
+
+    it "should create a new transport by transport name for a given service" do
+      service = mock("ServiceMock")
+      Transport.should_receive(:new_transport_with_encoding).with(:transport_name, service)
+      Transport.create(:transport_name, service)
+    end
+
+    it "should create a new transport instance with encoding from a transport name" do
+      transport = Transport.new_transport_with_encoding :json_via_http, mock("ServiceMock")
+      transport.should be_kind_of(Transport::Http)
+      transport.encoder.should == Encoding::Json
+    end
+
+    it "should create a new transport instance with encoding from a transport alias" do
+      transport = Transport.new_transport_with_encoding :http, mock("ServiceMock")
+      transport.should be_kind_of(Transport::Http)
+      transport.encoder.should == Encoding::Json
+    end
+
+    it "should raise an exception if transport name does not exist" do
+      lambda { Transport.new_transport_with_encoding :not_existing_transport, mock("ServiceMock") }.should raise_error(TransportException)
+    end
+
+  end
+end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 2
-  - 2
-  version: 0.2.2
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Dirk Breuer
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-30 00:00:00 +02:00
+date: 2010-03-31 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -89,10 +89,13 @@ extensions: []
 extra_rdoc_files: 
 - LICENSE
 - README.rdoc
+- TODO
 files: 
 - README.rdoc
 - THANKS.md
 - lib/hoth.rb
+- lib/hoth/encoding/json.rb
+- lib/hoth/encoding/no_op.rb
 - lib/hoth/endpoint.rb
 - lib/hoth/exceptions.rb
 - lib/hoth/extension/core/exception.rb
@@ -104,13 +107,14 @@ files:
 - lib/hoth/service_module.rb
 - lib/hoth/service_registry.rb
 - lib/hoth/services.rb
-- lib/hoth/transport/amqp_transport.rb
-- lib/hoth/transport/bert_transport.rb
-- lib/hoth/transport/hoth_transport.rb
-- lib/hoth/transport/http_transport.rb
-- lib/hoth/transport/workling_transport.rb
+- lib/hoth/transport.rb
+- lib/hoth/transport/base.rb
+- lib/hoth/transport/bert.rb
+- lib/hoth/transport/http.rb
+- lib/hoth/transport/workling.rb
 - lib/hoth/util/logger.rb
 - spec/spec_helper.rb
+- spec/unit/encoding/json_spec.rb
 - spec/unit/endpoint_spec.rb
 - spec/unit/extension/core/exception_spec.rb
 - spec/unit/hoth_spec.rb
@@ -118,8 +122,12 @@ files:
 - spec/unit/service_definition_spec.rb
 - spec/unit/service_module_spec.rb
 - spec/unit/service_spec.rb
-- spec/unit/transport/workling_transport_spec.rb
+- spec/unit/transport/base_spec.rb
+- spec/unit/transport/http_spec.rb
+- spec/unit/transport/workling_spec.rb
+- spec/unit/transport_spec.rb
 - LICENSE
+- TODO
 has_rdoc: true
 homepage: http://github.com/railsbros/hoth
 licenses: []
@@ -152,6 +160,7 @@ specification_version: 3
 summary: Registry and deployment description abstraction for SOA-Services
 test_files: 
 - spec/spec_helper.rb
+- spec/unit/encoding/json_spec.rb
 - spec/unit/endpoint_spec.rb
 - spec/unit/extension/core/exception_spec.rb
 - spec/unit/hoth_spec.rb
@@ -159,4 +168,7 @@ test_files:
 - spec/unit/service_definition_spec.rb
 - spec/unit/service_module_spec.rb
 - spec/unit/service_spec.rb
-- spec/unit/transport/workling_transport_spec.rb
+- spec/unit/transport/base_spec.rb
+- spec/unit/transport/http_spec.rb
+- spec/unit/transport/workling_spec.rb
+- spec/unit/transport_spec.rb

data/lib/hoth/transport/amqp_transport.rb

@@ -1,7 +0,0 @@
-module Hoth
-  module Transport
-    class AmqpTransport
-      
-    end
-  end
-end

data/lib/hoth/transport/http_transport.rb

@@ -1,43 +0,0 @@
-require 'json'
-require 'net/http'
-
-
-module Hoth
-  module Transport
-    class HttpTransport < HothTransport     
-      def call_remote_with(*args)
-        response = Net::HTTP.post_form(
-          URI.parse(self.endpoint.to_url),
-          { 'name' => self.name.to_s, 'params' => "#{args.to_json}" }
-        )
-        
-        if return_value
-          case response
-          when Net::HTTPSuccess
-            Hoth::Logger.debug "response.body: #{response.body}"
-            JSON(response.body)["result"]
-          when Net::HTTPServerError
-            begin
-              raise JSON(response.body)["error"]
-            rescue JSON::ParserError => jpe
-              raise TransportError.wrap(jpe)
-            end
-          when Net::HTTPRedirection, Net::HTTPClientError, Net::HTTPInformation, Net::HTTPUnknownResponse
-            #TODO Handle redirects(3xx) and http errors(4xx), http information(1xx), unknown responses(xxx)
-            raise NotImplementedError, "HTTP code: #{response.code}, message: #{response.message}"
-          end
-        else
-          response.is_a?(Net::HTTPSuccess)
-        end
-      end
-      
-      def decode_params(params)
-        Hoth::Logger.debug "Original params before decode: #{params.inspect}"
-        JSON.parse(params)
-      rescue JSON::ParserError => jpe
-        raise TransportError.wrap(jpe)
-      end
-      
-    end
-  end
-end