king_soa 0.0.5 → 0.0.6

data/lib/king_soa/registry.rb

@@ -21,7 +21,7 @@ module KingSoa
 
     # find a group of services identified by starting with the same string
     #
-    def group(name)
+    def self.group(name)
       instance.group(name)
     end
     ############################################################################
@@ -52,9 +52,7 @@ module KingSoa
 
     # untested
     def group(service_name)
-      name = service_name.to_sym
-#      srvs = []
-      services.collect {|s| s.name[/^#{name}/] }
+      services.select {|s| !s.name.to_s.match(/^#{service_name}/).nil? }
     end
 
 

data/lib/king_soa/service.rb

@@ -2,16 +2,21 @@ module KingSoa
   class Service
 
     # name<String/Symbol>:: name of the service class to call
+    #
     # auth<String/Int>:: password for the remote service. Used by rack middleware
     # to authentify the callee
-    # url<String>:: Url where the service is located. If the rack middleware is
-    # used on the receiving side, make sure to append /soa to the url so the
-    # middleware can grab the incoming call. A custom endpoint path can be set in
-    # the middleware.
+    #
+    #
     # queue<Boolean>:: turn on queueing for this service call. The incoming
     # request(className+parameter) will be put onto a resque queue
-    # debug<Boolean>:: turn on verbose outpur for typhoeus request
-    attr_accessor :debug, :name, :auth, :queue, :url
+    #
+    # debug<Boolean>:: turn on verbose output for typhoeus request
+    #
+    # request_method<Symbol>:: :get :post, :put : delete, used for curl request
+    
+    attr_accessor :debug, :name, :auth, :queue, :request_method
+    # raw_url<String>:: raw incoming url string with request method prefixed "GET http://whatever"
+    attr_reader :raw_url
     
     def initialize(opts)
       self.name = opts[:name].to_sym
@@ -26,6 +31,10 @@ module KingSoa
       request = Typhoeus::Easy.new
       set_request_opts(request, args)
       resp_code = request.perform
+      parse_response(resp_code, request)
+    end
+
+    def parse_response(resp_code, request)
       case resp_code
       when 200
         if request.response_header.include?('Content-Type: application/json')
@@ -36,7 +45,7 @@ module KingSoa
         end
       else
         if request.response_header.include?('Content-Type: application/json')
-          #decode incoming json .. most likely from KingSoa's rack middleware
+          #decode incoming json carriing an error.. most likely from KingSoa's rack middleware
           return self.decode(request.response_body)["error"]
         else # return plain body
           return request.response_body
@@ -94,7 +103,7 @@ module KingSoa
     # args<Array[]>:: arguments for the soa method, added to post body json encoded
     def set_request_opts(req, args)
       req.url         = url
-      req.method      = :post
+      req.method      = request_method || :post
       req.timeout     = 10000 # milliseconds
       req.params      = params(args)
       req.user_agent  = 'KingSoa'
@@ -102,6 +111,38 @@ module KingSoa
       req.verbose     = 1 if debug
     end
 
+    #=== Params
+    #url_string<String>::service location to call.
+    #
+    # 
+    # POST(default)
+    # http://myUrl.com
+    # http://myUrl.com:3000/my_path
+    # http://myUrl.com:3000/soa
+    #
+    # Request types can be defined within url string:
+    #   GET http://myUrl.com
+    #   DELETE http://myUrl.com:3000/my_path
+    #   PUT http://myUrl.com:3000/soa
+    #   POST http://myUrl.com:3000/custom_post_receiving_path
+    # 
+    # === Returns
+    # url<String>:: service Url
+    #
+    def url=(url_string)
+      # grab leading req type, case-insensitive
+      if req_type = url_string[/^(GET|POST|PUT|DELETE)/i, 0]
+        @request_method = req_type.downcase.to_sym
+      end
+      @raw_url = url_string
+      # grab only url string starting with ht until its end
+      @url = url_string[/ht.*/i, 0]
+    end
+
+    def url
+      @url
+    end
+
     # Params for a soa request consist of following values:
     # name => name of the soa class to call
     # args => arguments for the soa class method -> Class.perform(args)

data/spec/king_soa/registry_spec.rb

@@ -21,5 +21,17 @@ describe KingSoa::Registry do
     @reg[:save_document].should == s
   end
 
+  it "should find a service group" do
+    s = KingSoa::Service.new(:name=>:soa_document, :url=>'http://localhost')
+    s2 = KingSoa::Service.new(:name=>:soa_test, :url=>'http://localhost')
+    s3 = KingSoa::Service.new(:name=>:tester1, :url=>'http://localhost')
+    @reg << s
+    @reg << s2
+    @reg << s3
+    @reg.group('soa').should == [s,s2]
+    @reg.group('soa').should_not include(s3)
+
+  end
+
 
 end

data/spec/king_soa/service_spec.rb

@@ -10,6 +10,27 @@ describe KingSoa::Service, 'in general' do
       s = KingSoa::Service.new()
     }.should raise_error
   end
+
+  it "should parse request type from url" do
+    s = KingSoa::Service.new(:name=>'get_settings_form', :url=>"GET #{test_url}")
+    s.url.should == test_url
+    s.request_method.should == :get
+
+    s.url = "DELETE https://whatever"
+    s.raw_url.should == "DELETE https://whatever"
+    s.url.should == "https://whatever"
+    s.request_method.should == :delete
+
+    s.url = "PUT https://localhost:3000"
+    s.url.should == "https://localhost:3000"
+    s.request_method.should == :put
+  end
+
+  it "should parse url with invalid request type" do
+    s = KingSoa::Service.new(:name=>'get_settings_form', :url=>"NOWAY #{test_url}")
+    s.url.should == test_url
+    s.request_method.should be_nil
+  end
 end
 
 describe KingSoa::Service, 'local request' do
@@ -24,6 +45,8 @@ describe KingSoa::Service, 'queued' do
   it "should call queue" do
     s = KingSoa::Service.new(:name=>:local_soa_class, :queue=>:test_queue)
     s.perform(1,2,3).should be_nil
+    #...also test for queue content
+
   end
 end
 
@@ -41,18 +64,56 @@ describe KingSoa::Service, 'remote request' do
     s.perform(1,2,3).should == [1,2,3]
   end
 
-  it "should call a remote service and return auth error" do
+  it "should call remote service and return auth error" do
     s = KingSoa::Service.new(:name=>:soa_test_service, :url=>test_soa_url, :auth=>'wrong')
     s.perform(1,2,3).should == "Please provide a valid authentication key"
   end
 
-  it "should call a service remote and return not found error" do
+  it "should call remote service and return not found error" do
     s = KingSoa::Service.new(:name=>:wrong_service, :url=>test_soa_url, :auth=>'12345')
     s.perform(1,2,3).should include("The service: wrong_service could not be found")
   end
 
-  it "should call a remote service without using middleware and returning plain text" do
+  it "should call remote service without middleware and return plain text" do
     s = KingSoa::Service.new(:name=>:non_soa_test_service, :url=> "#{test_url}/non_json_response")
     s.perform().should == "<h1>hello World</h1>"
   end
+
+  it "should GET remote service with params added to url and return params" do
+    s = KingSoa::Service.new(:name=>:non_soa_test_service,
+                              :url=> "GET #{test_url}/get_with_params_test",
+                              :auth=>'12345' )
+    s.request_method.should == :get
+    s.perform(:opt_one=>'hi').should == "name=>non_soa_test_service, args=>[{\"opt_one\":\"hi\"}], auth=>12345"
+  end
+  
+  it "should GET remote service with multiple params" do
+    s = KingSoa::Service.new(:name=>:non_soa_test_service,
+                              :url=> "GET #{test_url}/get_with_params_test",
+                              :auth=>'12345' )
+    s.request_method.should == :get
+    res = s.perform(:opt_one=>'hi', :opt_two=>'there' )
+    res.should include("\"opt_one\":\"hi\"")
+    res.should include("\"opt_two\":\"there\"")
+  end
+
+  it "should GET remote service and return plain text" do
+    s = KingSoa::Service.new(:name=>:non_soa_test_service, :url=> "GET #{test_url}/get_test")
+    s.request_method.should == :get
+    s.perform().should == "go get it"
+  end
+
+  it "should PUT a remote service and return plain text" do
+    s = KingSoa::Service.new(:name=>:non_soa_test_service, :url=> "PUT #{test_url}/put_test")
+    s.request_method.should == :put
+    s.perform().should == "put it down"
+  end
+  
+  it "should DELETE a remote service and return plain text" do
+    s = KingSoa::Service.new(:name=>:non_soa_test_service, :url=> "DELETE #{test_url}/delete_test")
+    s.request_method.should == :delete
+    s.perform().should == "ereased the sucker"
+  end
+
+
 end

data/spec/server/app.rb

@@ -9,6 +9,10 @@ require "king_soa"
 # this grabs all /soa requests
 use KingSoa::Rack::Middleware
 
+################################################################################
+# Sinatra endpoints
+################################################################################
+
 #  method to kill this server instance
 get '/die' do
   exit!
@@ -20,6 +24,26 @@ post '/non_json_response' do
   "<h1>hello World</h1>"
 end
 
+delete "/delete_test" do
+  "ereased the sucker"
+end
+
+put "/put_test" do
+  "put it down"
+end
+
+get "/get_test" do
+  "go get it"
+end
+
+get "/get_with_params_test" do
+  str = []
+  params.each do |k,v|
+    str << "#{k}=>#{v}"
+  end
+  str.join(', ')
+end
+
 ################################################################################
 # Somewhere in you app you define a local service, receiving the incoming call
 #

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: king_soa
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 19
   prerelease: false
   segments: 
   - 0
   - 0
-  - 5
-  version: 0.0.5
+  - 6
+  version: 0.0.6
 platform: ruby
 authors: 
 - Georg Leciejewski
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-29 00:00:00 +02:00
+date: 2010-07-16 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency