sk-hoth 0.0.1 → 0.3.0

data/spec/unit/transport/http_hmac_spec.rb

@@ -0,0 +1,44 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../../',  'spec_helper'))
+
+module Hoth
+  module Transport
+    describe HttpHmac do
+
+      before(:each) do
+        @service_mock = mock("ServiceMock")
+        
+      end
+
+      it "should post payload encoded with JSON" do
+        stub_request(:any, "localhost:3000/execute")
+        @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")        
+
+        transport = HttpHmac.new(@service_mock, {:encoder => encoder})
+        transport.hmac_access_id = 'an-hmac_access_id'
+        transport.hmac_secret  = 'an-hmac_secret'
+        transport.post_payload("params")
+        transport.req['Authorization'].should include('KingHmac::Auth an-hmac_access_id:')
+      end
+
+      describe "Error Handling" do
+
+        before(:each) do
+          service_mock = mock("ServiceMock")
+          @params    = {:first_name => "Seras", :last_name => "Victoria"}
+          encoder    = mock("JsonEncoderMock")
+          @transport = HttpHmac.new(service_mock, {:encoder => encoder})
+        end
+
+        it "should handle hmac missing error" do
+          lambda { @transport.call_remote_with(@params) }.should raise_error(TransportError)
+        end
+       
+      end
+
+    end
+  end
+end

data/spec/unit/transport/http_spec.rb

@@ -0,0 +1,73 @@
+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
+        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")
+          @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_spec.rb

@@ -0,0 +1,42 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../../',  'spec_helper'))
+
+module Hoth
+  module Transport
+    
+    describe "Workling" do
+      
+      it "should send publish a message via SimplePublisher" do
+        endpoint = mock("EndpointMock")
+        endpoint.should_receive(:host).and_return("localhost")
+        endpoint.should_receive(:port).and_return("22122")
+        
+        service_module = mock("ServiceModule")
+        service_module.should_receive(:name).and_return("TestServiceModule")
+        
+        service = mock("ServiceMock")
+        service.should_receive(:name).and_return("TestService")
+        service.should_receive(:endpoint).any_number_of_times.and_return(endpoint)
+        service.should_receive(:module).any_number_of_times.and_return(service_module)
+        
+        SimplePublisher::Topic.should_receive(:new).with(:name => "test_service_module_subscribers__test_service").and_return(topic = mock("Topic"))
+        
+        SimplePublisher::StarlingConnection.should_receive(:new).with(:host => "localhost", :port => "22122").and_return(connection = mock("Connection"))
+        
+        SimplePublisher::Publisher.should_receive(:new).with(
+          :topic => topic,
+          :connection => connection
+        ).and_return(publisher = mock("PublisherMock"))
+
+        uid = "GC-123546"
+        email_address = "test@example.com"
+
+        publisher.should_receive(:publish).with([uid, email_address])
+        
+        transport = Workling.new(service)
+        transport.call_remote_with(uid, email_address)
+      end
+      
+    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,21 +4,22 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
+  - 3
   - 0
-  - 1
-  version: 0.0.1
+  version: 0.3.0
 platform: ruby
 authors: 
+- Dirk Breuer
 - Georg Leciejewski
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2010-05-08 00:00:00 +02:00
+date: 2010-04-11 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: curb
+  name: activesupport
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
@@ -30,7 +31,7 @@ dependencies:
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: json
+  name: bertrpc
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     requirements: 
@@ -42,7 +43,7 @@ dependencies:
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: king_hmac
+  name: json
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
     requirements: 
@@ -54,7 +55,7 @@ dependencies:
   type: :runtime
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  name: rspec
+  name: king_hmac
   prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement 
     requirements: 
@@ -63,10 +64,10 @@ dependencies:
         segments: 
         - 0
         version: "0"
-  type: :development
+  type: :runtime
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
-  name: webmock
+  name: rspec
   prerelease: false
   requirement: &id005 !ruby/object:Gem::Requirement 
     requirements: 
@@ -77,11 +78,35 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: simple_publisher
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: webmock
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id007
 description: |
   Creating a SOA requires a centralized location to define all services within the
   SOA. Furthermore you want to know where to deploy those services.
 
-email: gl@salesking.eu
+email: dirk.breuer@gmail.com
 executables: []
 
 extensions: []
@@ -89,20 +114,49 @@ extensions: []
 extra_rdoc_files: 
 - LICENSE
 - README.rdoc
+- TODO
 files: 
 - README.rdoc
-- lib/king_soa.rb
-- lib/king_soa/rack/middleware.rb
-- lib/king_soa/registry.rb
-- lib/king_soa/service.rb
-- spec/king_soa/rack/middleware_spec.rb
-- spec/king_soa/registry_spec.rb
-- spec/king_soa/service_spec.rb
-- spec/server/app.rb
+- 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
+- lib/hoth/modules.rb
+- lib/hoth/providers/bertrpc_provider.rb
+- lib/hoth/providers/rack_provider.rb
+- lib/hoth/service.rb
+- lib/hoth/service_definition.rb
+- lib/hoth/service_module.rb
+- lib/hoth/service_registry.rb
+- lib/hoth/services.rb
+- lib/hoth/transport.rb
+- lib/hoth/transport/base.rb
+- lib/hoth/transport/bert.rb
+- lib/hoth/transport/http.rb
+- lib/hoth/transport/http_hmac.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
+- spec/unit/providers/rack_provider_spec.rb
+- spec/unit/service_definition_spec.rb
+- spec/unit/service_module_spec.rb
+- spec/unit/service_spec.rb
+- spec/unit/transport/base_spec.rb
+- spec/unit/transport/http_hmac_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/salesking/king_soa
+homepage: http://github.com/salesking/hoth
 licenses: []
 
 post_install_message: 
@@ -133,7 +187,16 @@ specification_version: 3
 summary: Registry and deployment description abstraction for SOA-Services. Tweaked by SalesKing
 test_files: 
 - spec/spec_helper.rb
-- spec/king_soa/registry_spec.rb
-- spec/king_soa/service_spec.rb
-- spec/king_soa/rack/middleware_spec.rb
-- spec/server/app.rb
+- spec/unit/service_module_spec.rb
+- spec/unit/service_spec.rb
+- spec/unit/transport_spec.rb
+- spec/unit/encoding/json_spec.rb
+- spec/unit/providers/rack_provider_spec.rb
+- spec/unit/service_definition_spec.rb
+- spec/unit/extension/core/exception_spec.rb
+- spec/unit/transport/http_hmac_spec.rb
+- spec/unit/transport/workling_spec.rb
+- spec/unit/transport/http_spec.rb
+- spec/unit/transport/base_spec.rb
+- spec/unit/hoth_spec.rb
+- spec/unit/endpoint_spec.rb

data/lib/king_soa/rack/middleware.rb

@@ -1,47 +0,0 @@
-module KingSoa::Rack
-  class Middleware
-
-    def initialize(app)
-      @app = app
-    end
-
-    # Takes incoming soa requests and calls the passed in method with given params
-    def call(env)
-#      Hoth::Logger.debug "env: #{env.inspect}"
-      if env["PATH_INFO"] =~ /^\/soa/
-        begin
-          req = Rack::Request.new(env)
-          # find service
-          service = KingSoa.find(req.params["name"])
-          # authenticate
-          authenticated?(service, req.params["auth_key"])
-          # perform method with decoded  params
-          result = service.perform(*service.decode( req.params["params"] ))
-          # encode result
-          encoded_result = service.encode({"result" => result})
-          # and return
-          [ 200,
-            {'Content-Type' => 'application/json',
-             'Content-Length' => "#{encoded_result.length}"},
-            [encoded_result] ]
-        rescue Exception => e
-          #Hoth::Logger.debug "e: #{e.message}"
-          if service
-            encoded_error = service.encode({"error" => e})
-            [500, {'Content-Type' => 'application/json', 'Content-Length' => "#{encoded_error.length}"}, [encoded_error]]
-          else
-            encoded_error = {"error" => "An error occurred! (#{e.message})"}.to_json
-            [500, {'Content-Type' => "application/json", 'Content-Length' => "#{encoded_error.length}"}, [encoded_error]]
-          end
-        end
-      else
-        @app.call(env)
-      end
-    end
-
-    def authenticated?(service, key)
-      raise "Please provide a valid authentication key" unless service.auth_key == key
-    end
-
-  end
-end

data/lib/king_soa/registry.rb

@@ -1,55 +0,0 @@
-module KingSoa
-  class Registry
-    include Singleton
-
-    ############################################################################
-    # Class methods .. only use those since we are in a Singleton
-    ############################################################################
-
-    # Get a method by a given name
-    def self.[](service_name)
-      instance[service_name]
-    end
-    # add a service
-    def self.<<(service)
-      instance << service
-    end
-    # Return an array of defined services
-    def self.services
-      instance.services
-    end
-
-    # find a group of services identified by starting with the same string
-    #
-    def group(name)
-      instance.group(name)
-    end
-    ############################################################################
-    # Instance methods - not directly accessible => Singleton
-    ############################################################################
-
-    # returns all available methods
-    def services
-      @services ||= []
-    end
-
-    # Add a new method onto the stack
-    def <<(service)
-      (services || []) << service
-    end
-
-    # Get a method by a given name
-    def [](service_name)
-      name = service_name.to_sym
-      services.detect {|s| s.name == name }
-    end
-
-    def group(service_name)
-      name = service_name.to_sym
-#      srvs = []
-      services.collect {|s| s.name[/^#{name}/] }
-    end
-
-
-  end
-end

data/lib/king_soa/service.rb

@@ -1,88 +0,0 @@
-module KingSoa
-  class Service
-    # endpoint url
-    attr_accessor :debug, :name, :auth_key, :queue
-    attr_reader :request
-    
-    def initialize(opts)
-      self.name = opts[:name].to_sym
-      self.url = opts[:url] if opts[:url]      
-      self.queue = opts[:queue] if opts[:queue]
-      self.auth_key = opts[:auth_key] if opts[:auth_key]
-    end
-
-    def call_remote(*args)
-      set_request_opts(args)
-      resp_code = @request.perform
-      case resp_code
-      when 200
-        return self.decode(@request.response_body)["result"]
-      else
-        return self.decode(@request.response_body)["error"]
-      end
-    end
-
-    def perform(*args)
-      result = local_class ? local_class.send(:perform, *args) : call_remote(*args)
-      return result
-    end
-    
-
-    def local_class
-      @local_class ||= begin
-                        "#{self.name.to_s.camelize}".constantize
-                      rescue NameError => e        # no local implementation
-                        false
-                      end
-    end
-
-    def request
-      @request ||= Typhoeus::Easy.new
-    end
-
-    def set_request_opts(args)
-      request.url         = url
-      request.method      = :post
-      request.timeout     = 100 # milliseconds
-      request.params      = params(args)
-      request.user_agent  = 'KingSoa'
-      request.follow_location = true      
-      request.verbose     = 1 if debug      
-    end
-
-    # Url receiving the request
-    # TODO. if not present try to grab from endpoint
-    def url
-      @url
-    end
-    def url=(url)
-      @url = "#{url}/soa"
-    end
-
-     # The params for each soa request consisnt of two values:
-    # name => the name of the method to call
-    # params => the parameters for the method
-    # ==== Parameter
-    # params<Hash|Array|String>:: will be json encoded
-    # === Returns
-    # <Hash{String=>String}>:: params added to the POST body
-    def params(payload)
-      { 'name'   => name.to_s,
-        'params' => encode(payload),
-        'auth_key'=> auth_key }
-    end
-
-    def encode(string)
-      string.to_json
-    end
-
-    def decode(string)
-      begin
-        JSON.parse(string)
-      rescue JSON::ParserError => e
-        raise e
-      end
-    end
-
-  end
-end

data/lib/king_soa.rb

@@ -1,56 +0,0 @@
-require 'singleton'
-require 'json'
-require 'typhoeus'
-require 'active_support/inflector'
-
-require 'king_soa/registry'
-require 'king_soa/service'
-require 'king_soa/rack/middleware'
-
-# Define available services.
-#
-# service:
-#   name: sign_document
-#   url: "https://msg.salesking.eu"
-#   auth: 'a-long-random-string'
-#   queue: a-queue-name
-#
-#
-# method: save_signed_document
-# url: "https://www.salesking.eu/soa"
-#
-#
-# after defining your services you can call each of them with
-# <tt>Hoth::Services.service_name(params)</tt>
-#
-#     KingSoa.sign_document(counter)
-#     current_number = Hoth::Services.value_of_counter(counter)
-#     created_account = Hoth::Services.create_account(account)
-#
-module KingSoa
-  
-  class << self
-
-    def init_from_hash(services)
-      # create service
-      
-    end
-    
-    # Locate service by a given name
-    # ==== Params
-    # service<String|Symbol>:: the name to lookup
-    def find(service)
-      Registry[service]
-    end
-
-    # this is where the services get called
-    def method_missing(meth, *args, &blk) # :nodoc:
-      if service = Registry[meth]
-        service.execute(*args)
-      else
-        super
-      end
-    end
-  end
-
-end

data/spec/king_soa/rack/middleware_spec.rb

@@ -1,36 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-describe KingSoa::Rack::Middleware do
-  include Rack::Test::Methods
-
-  before(:each) do
-    @service = KingSoa::Service.new(:url=>'localhost', :name=>'a_method')
-    KingSoa::Registry << @service
-  end
-
-  it "should be able to handle exceptions" do
-    app = stub("ApplicationStub").as_null_object
-    middleware = KingSoa::Rack::Middleware.new(app)
-    env = {"PATH_INFO" => "/soa", "name" => 'a_method'}
-
-    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 == "{\"error\":\"An error occurred! (Missing rack.input)\"}"
-  end
-
-  xit "says hello" do
-    app = stub("ApplicationStub").as_null_object
-        middleware = Hoth::Providers::RackProvider.new(app)
-
-    get '/soa', :name=>'a_method', :params=> "#{{:number=>1}.to_json}"
-    last_response.should == 'ads'#be_ok
-    last_response.body.should == 'Hello World'
-  end
-
-#  def app
-#    dummy_app = lambda { |env| puts "in dummy"; [200, {}, ""] }
-#    KingSoa::Rack::Middleware.new(dummy_app)
-#  end
-
-end

data/spec/king_soa/registry_spec.rb

@@ -1,28 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper.rb'
-
-describe KingSoa::Registry do
-  before(:each) do
-
-  end
-
-  it "should return empty services" do
-    reg = KingSoa::Registry.new
-    reg.services.should == []
-  end
-
-  it "should add service" do
-    reg = KingSoa::Registry.new
-    s = KingSoa::Service.new(:url=>'http://localhost')
-    reg << s
-    reg.services.should == [s]
-  end
-
-  it "should return a service by name" do
-    reg = KingSoa::Registry.new
-    s = KingSoa::Service.new(:name=>:save_document, :url=>'http://localhost')
-    reg << s
-    reg[:save_document].should == s
-  end
-
-
-end