json_proxy 0.5.1

data/test/functional/server_spec.rb~

@@ -0,0 +1,137 @@
+require 'rubygems'
+require 'net/http'
+require 'active_support'
+
+require File.dirname(__FILE__) + '/spec_helper'
+require File.dirname(__FILE__) + '/test_service.rb'
+
+
+
+# Test basic server operation using echo server
+
+describe "Server" do
+
+  def start_server
+    app = Server::Server.new 
+    Thread.new {
+       @acc = Rack::Handler::Mongrel.run(app, :Port => 4567) do |server|
+        puts "Server running"     
+       end
+     }
+    sleep 2
+    
+  end
+  
+  def start_worker
+    Thread.new {
+      puts "Worker Started"
+      worker = UrlQueue::QueueDaemon.new
+      sleeping = false
+      loop do
+        processed = worker.process
+        if processed == 0 && !sleeping
+          sleeping = true
+          puts "Queue empty \n"
+        elsif processed > 0
+          puts "Processed #{processed}\n"
+          sleeping = false
+        end
+       sleep(1)
+      end
+    }
+    sleep 1
+  end
+
+  before(:all) do
+    start_server
+    start_worker
+  end
+  
+  
+  before(:each) do
+  end
+  
+  def get(msg)
+    Net::HTTP.get_response(URI.parse('http://localhost:4567/echo/echo.js?message='+msg))
+  end
+  
+  def force_get(msg)
+    Net::HTTP.get_response(URI.parse('http://localhost:4567/echo/echo.js?message='+msg+'&force=true'))
+  end
+  
+  def random_msg
+    "random-#{rand(9999999)}"
+  end
+  
+  describe "with missing service" do
+    it "response should be 404" do
+      response = Net::HTTP.get_response(URI.parse('http://localhost:4567/missing'))
+      response.code.should =="200"
+      response.body.should =="Handler not found"
+    end
+  end
+
+  describe "with echo service" do
+
+    describe "with cached message" do
+      before(:each) do
+          force_get "cached"
+      end
+    
+      it "response should == message " do
+        response = get("cached")
+        response.code.should == "200"
+        body = ActiveSupport::JSON.decode(response.body)
+        body.should be :kind_of, Hash
+        body['status'].should == 200
+        body['data'].should be :kind_of, Hash
+        body['data']['message'].should == "cached" 
+      end
+   
+    end
+    
+    describe "with uncached message" do
+    
+      it "response should be 202 - Processing until complete then success" do
+        msg = random_msg
+        response = get(msg)
+        response.code.should == "202"
+        response.body.should_not be(:empty)
+        body = ActiveSupport::JSON.decode(response.body)
+        body.should be :kind_of, Hash
+        body['status'].should == 202
+        count = 1;
+        maxCount = 10;
+        while response = get(msg)
+          puts "Retry #{count} \n"
+          if (response.code != "202" || count > maxCount)
+            break
+          end
+          count += 1
+          sleep(1)
+        end
+        response.code.should == "200"
+        body = ActiveSupport::JSON.decode(response.body)
+        body['status'].should == 200
+        body['data'].should be :kind_of, Hash
+        body['data']['message'].should == msg 
+      end
+   
+    end
+    
+    describe "with forced query" do
+
+      it "response should == message " do
+        msg = random_msg
+        response = force_get(msg)
+        response.code.should == "200"
+        body = ActiveSupport::JSON.decode(response.body)
+        body['status'].should == 200
+        body['data'].should be :kind_of, Hash
+        body['data']['message'].should == msg 
+      end
+    
+    end
+
+  end
+end

data/test/functional/spec_helper.rb

@@ -0,0 +1,14 @@
+
+require 'rubygems'
+require 'spec'
+require 'configatron'
+
+
+$:.unshift(File.dirname(__FILE__) + "/../../lib") 
+require File.dirname(__FILE__) + '/../../lib/json_proxy.rb'
+
+require File.dirname(__FILE__) + '/../../lib/queue/queue.rb'
+require File.dirname(__FILE__) + '/../../lib/queue/queue_daemon.rb'
+
+
+

data/test/functional/spec_helper.rb~

@@ -0,0 +1,16 @@
+
+require 'rubygems'
+require 'spec'
+require 'configatron'
+
+
+$:.unshift(File.dirname(__FILE__) + "/../../lib") 
+require File.dirname(__FILE__) + '/../../lib/json_proxy.rb'
+
+require File.dirname(__FILE__) + '/../../lib/queue/queue.rb'
+require File.dirname(__FILE__) + '/../../lib/queue/queue_daemon.rb'
+
+
+include Server::DSL
+require File.dirname(__FILE__) + '/../../lib/webservices/echo.rb'
+

data/test/functional/test_service.rb

@@ -0,0 +1,17 @@
+
+
+# Not needed but the test should be a little more robust this way
+class EchoResponse
+  attr_accessor :message
+  
+  def initialize(msg)
+    @message = msg
+  end 
+end
+
+np_namespace "echo" do |ns|
+  
+  ns.route 'echo', [:message] do |message|
+    EchoResponse.new message
+  end
+end

data/test/spec/handlers/cache_handler_spec.rb

@@ -0,0 +1,206 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+
+describe "Cache Handler#action" do
+
+
+ before(:each) do
+    @name = 'name'
+    @namespace = 'namespace'
+    @options = mock("options")
+    @options.stub!('[]').with(:cache_key).and_return(Proc.new { "key" })
+    @handler = Server::Handlers::CacheHandler.new @namespace, @name, @options
+    
+    @cache = mock("cache")
+    @cache.stub!(:fetch)
+    Utils::CouchCache.stub!(:new).and_return(@cache)
+    
+    @request = mock("request")
+    @request.stub!(:args)
+    @request.stub!(:force?)
+    @response = mock("response")
+
+    @block_body = mock("block_body")
+    @block_body.stub!(:yielded)
+ end
+
+ def action
+   @handler.action @request, @response do |request, response|
+      @block_body.yielded request, response
+   end
+ end
+ 
+ it "should initialise cache" do
+   Utils::CouchCache.should_receive(:new).with("#{@namespace.downcase}_#{@name.downcase}")
+   action
+ end
+ 
+ it "should raise exception if cache_key is not a proc" do
+  cache_key = mock("cache_key")
+  @options.stub!('[]').with(:cache_key).and_return(cache_key)
+  cache_key.should_receive(:is_a?).with(Proc).and_return(false)
+
+  lambda { action }.should raise_error
+  
+ end
+ 
+ it "should apply the cache_key function to the request args" do
+  args = mock("args")
+  cache_key_body = mock("cache_key_body")
+  cache_key = Proc.new { |args| cache_key_body.yielded args }
+  
+  @options.stub!('[]').with(:cache_key).and_return(cache_key)
+  cache_key_body.should_receive(:yielded).with(args)
+  @request.stub!(:args).and_return(args)
+  
+  action
+ end
+ 
+ it "should fetch the result from the cache" do
+  @cache.should_receive(:fetch).with("key")
+  
+  action
+ end
+ 
+ describe ", cache miss" do
+    before(:each) do
+      @cache.stub!(:fetch).and_return(nil)
+    end
+
+    it "should yield" do
+      @block_body.should_receive(:yielded).with(@request, @response)
+      
+      action
+    end
+
+    it "should check if the request is forced" do
+      @request.should_receive(:force?)
+      
+      action
+    end
+
+    describe "with unforced request" do
+      before(:each) do
+        @request.stub!(:force?).and_return(false)
+      end
+      
+      it "should not store result" do
+         @cache.should_not_receive(:store)
+         action
+      end
+      
+    end
+
+    describe "with forced request" do
+       before(:each) do
+        @request.stub!(:force?).and_return(true)
+       end
+      
+      it "should store result" do
+        body = {}
+        @response.should_receive(:body).and_return(body)
+
+        @cache.should_receive(:store).with("key", anything())  do |key , json|
+          cacheObj = JSON.parse json
+          cacheObj['mtime'].should be_kind_of(Numeric)
+          cacheObj['ctime'].should be_kind_of(Numeric)
+          cacheObj['app_version'].should be(JsonProxy::APP_VERSION)
+        end
+         action
+      end
+    end
+  end
+  
+  describe ", cache hit" do
+    before(:each) do
+      @cacheObj = mock("cacheObj")
+      @cacheObj.stub!('[]').with('data')
+      @cacheObj.stub!('[]').with('mtime')
+      
+      @handler.stub!(:expired?).and_return(false)
+      @cache.stub!(:fetch).and_return("cacheJSON")
+      
+      JSON.stub!(:parse).with("cacheJSON").and_return(@cacheObj)
+      
+      @response.stub!(:body=)
+    end
+  
+    it "should parse JSON result" do
+      JSON.should_receive(:parse).with("cacheJSON")
+      action
+    end
+  
+    it "should check expiry" do
+
+      @handler.should_receive(:expired?).with(@cacheObj)
+      action
+    end  
+    
+    describe "with unexpired cached result" do
+      before(:each) do
+         @handler.stub!(:expired?).and_return(false)
+      end
+      
+      it "should set the response" do
+        @cacheObj.should_receive('[]').with('data').and_return(:data)
+        @response.should_receive(:body=).with(:data)
+        action
+      end
+      
+      it "should not yield" do
+        @block_body.should_not_receive(:yielded)
+        action
+      end
+    
+    end
+    
+    describe "with expired cache result" do
+      before(:each) do
+         @handler.stub!(:expired?).and_return(true)
+      end
+      
+       it "should yield" do
+         @block_body.should_receive(:yielded).with(@request, @response)
+         action
+       end
+
+       describe "with unforced request" do
+
+         before(:each) do
+           @request.stub!(:force?).and_return(false)
+        end
+               
+        it "should not store result" do
+          @cache.should_not_receive(:store)
+          action
+        end
+      end
+       
+       describe "with forced request" do
+
+         before(:each) do
+           @request.stub!(:force?).and_return(true)
+        end
+               
+        it "should store result" do
+          body = {}
+          @response.should_receive(:body).and_return(body)
+          @cacheObj.should_receive('[]').with('ctime').and_return("ctime")
+          @cacheObj.should_receive('[]').with('_id').and_return("id")
+          @cacheObj.should_receive('[]').with('_rev').and_return("rev")
+          
+          @cache.should_receive(:store).with("key", anything())  do |key , json|
+            cacheObj = JSON::Parser.new(json).parse #JSON.parse is stubbed
+            cacheObj['ctime'].should =="ctime"
+            cacheObj['mtime'].should be_kind_of(Numeric)
+            cacheObj['app_version'].should be(JsonProxy::APP_VERSION)
+            cacheObj['_rev'].should =="rev"
+            cacheObj['_id'].should =="id"
+          end
+           action
+        end
+      end
+    end
+        
+  end
+end

data/test/spec/handlers/cache_handler_spec.rb~

@@ -0,0 +1,206 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+
+describe "Cache Handler#action" do
+
+
+ before(:each) do
+    @name = 'name'
+    @namespace = 'namespace'
+    @options = mock("options")
+    @options.stub!('[]').with(:cache_key).and_return(Proc.new { "key" })
+    @handler = Server::Handlers::CacheHandler.new @namespace, @name, @options
+    
+    @cache = mock("cache")
+    @cache.stub!(:fetch)
+    Utils::CouchCache.stub!(:new).and_return(@cache)
+    
+    @request = mock("request")
+    @request.stub!(:args)
+    @request.stub!(:force?)
+    @response = mock("response")
+
+    @block_body = mock("block_body")
+    @block_body.stub!(:yielded)
+ end
+
+ def action
+   @handler.action @request, @response do |request, response|
+      @block_body.yielded request, response
+   end
+ end
+ 
+ it "should initialise cache" do
+   Utils::CouchCache.should_receive(:new).with("#{@namespace.downcase}_#{@name.downcase}")
+   action
+ end
+ 
+ it "should raise exception if cache_key is not a proc" do
+  cache_key = mock("cache_key")
+  @options.stub!('[]').with(:cache_key).and_return(cache_key)
+  cache_key.should_receive(:is_a?).with(Proc).and_return(false)
+
+  lambda { action }.should raise_error
+  
+ end
+ 
+ it "should apply the cache_key function to the request args" do
+  args = mock("args")
+  cache_key_body = mock("cache_key_body")
+  cache_key = Proc.new { |args| cache_key_body.yielded args }
+  
+  @options.stub!('[]').with(:cache_key).and_return(cache_key)
+  cache_key_body.should_receive(:yielded).with(args)
+  @request.stub!(:args).and_return(args)
+  
+  action
+ end
+ 
+ it "should fetch the result from the cache" do
+  @cache.should_receive(:fetch).with("key")
+  
+  action
+ end
+ 
+ describe "with no cache result" do
+    before(:each) do
+      @cache.stub!(:fetch).and_return(nil)
+    end
+
+    it "should yield" do
+      @block_body.should_receive(:yielded).with(@request, @response)
+      
+      action
+    end
+
+    it "should check if the request is forced" do
+      @request.should_receive(:force?)
+      
+      action
+    end
+
+    describe "with unforced request" do
+      before(:each) do
+        @request.stub!(:force?).and_return(false)
+      end
+      
+      it "should not store result" do
+         @cache.should_not_receive(:store)
+         action
+      end
+      
+    end
+
+    describe "with forced request" do
+       before(:each) do
+        @request.stub!(:force?).and_return(true)
+       end
+      
+      it "should store result" do
+        body = {}
+        @response.should_receive(:body).and_return(body)
+
+        @cache.should_receive(:store).with("key", anything())  do |key , json|
+          cacheObj = JSON.parse json
+          cacheObj['mtime'].should be_kind_of(Numeric)
+          cacheObj['ctime'].should be_kind_of(Numeric)
+          cacheObj['app_version'].should be(JsonProxy::APP_VERSION)
+        end
+         action
+      end
+    end
+  end
+  
+  describe ", cache hit" do
+    before(:each) do
+      @cacheObj = mock("cacheObj")
+      @cacheObj.stub!('[]').with('data')
+      @cacheObj.stub!('[]').with('mtime')
+      
+      @handler.stub!(:expired?).and_return(false)
+      @cache.stub!(:fetch).and_return("cacheJSON")
+      
+      JSON.stub!(:parse).with("cacheJSON").and_return(@cacheObj)
+      
+      @response.stub!(:body=)
+    end
+  
+    it "should parse JSON result" do
+      JSON.should_receive(:parse).with("cacheJSON")
+      action
+    end
+  
+    it "should check expiry" do
+
+      @handler.should_receive(:expired?).with(@cacheObj)
+      action
+    end  
+    
+    describe "with unexpired cached result" do
+      before(:each) do
+         @handler.stub!(:expired?).and_return(false)
+      end
+      
+      it "should set the response" do
+        @cacheObj.should_receive('[]').with('data').and_return(:data)
+        @response.should_receive(:body=).with(:data)
+        action
+      end
+      
+      it "should not yield" do
+        @block_body.should_not_receive(:yielded)
+        action
+      end
+    
+    end
+    
+    describe "with expired cache result" do
+      before(:each) do
+         @handler.stub!(:expired?).and_return(true)
+      end
+      
+       it "should yield" do
+         @block_body.should_receive(:yielded).with(@request, @response)
+         action
+       end
+
+       describe "with unforced request" do
+
+         before(:each) do
+           @request.stub!(:force?).and_return(false)
+        end
+               
+        it "should not store result" do
+          @cache.should_not_receive(:store)
+          action
+        end
+      end
+       
+       describe "with forced request" do
+
+         before(:each) do
+           @request.stub!(:force?).and_return(true)
+        end
+               
+        it "should store result" do
+          body = {}
+          @response.should_receive(:body).and_return(body)
+          @cacheObj.should_receive('[]').with('ctime').and_return("ctime")
+          @cacheObj.should_receive('[]').with('_id').and_return("id")
+          @cacheObj.should_receive('[]').with('_rev').and_return("rev")
+          
+          @cache.should_receive(:store).with("key", anything())  do |key , json|
+            cacheObj = JSON::Parser.new(json).parse #JSON.parse is stubbed
+            cacheObj['ctime'].should =="ctime"
+            cacheObj['mtime'].should be_kind_of(Numeric)
+            cacheObj['app_version'].should be(JsonProxy::APP_VERSION)
+            cacheObj['_rev'].should =="rev"
+            cacheObj['_id'].should =="id"
+          end
+           action
+        end
+      end
+    end
+        
+  end
+end