LVS-JSONService 0.3.0 → 0.3.2

data/.specification

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: LVS-JSONService 
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
+  version: 0.3.2
 require_paths:
 - lib
 platform: ruby

data/JSONService.gemspec

@@ -2,10 +2,10 @@
 
 Gem::Specification.new do |s|
   s.name = %q{JSONService}
-  s.version = "0.3.0"
+  s.version = "0.3.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["LVS"]
+  s.authors = ["LVS", "andyjeffries"]
   s.date = %q{2009-08-06}
   s.email = %q{info@lvs.co.uk}
   s.extra_rdoc_files = [
@@ -24,12 +24,17 @@ Gem::Specification.new do |s|
      "lib/lvs/json_service/base.rb",
      "lib/lvs/json_service/logger.rb",
      "lib/lvs/json_service/request.rb",
+     "lib/lvs/json_service/connection_manager.rb",
      "spec/fixtures/error_response.yml",
      "spec/fixtures/response.yml",
      "spec/json_service_spec.rb",
      "spec/lvs/json_service/base_spec.rb",
+     "spec/lvs/json_service/connection_manager_spec.rb",
+     "spec/lvs/json_service/json_methods_spec.rb",
      "spec/lvs/json_service/logger_spec.rb",
      "spec/lvs/json_service/request_spec.rb",
+     "spec/lvs/json_service/mock_net_http.rb",
+     "spec/lvs/json_service/setting_fields_spec.rb",
      "spec/spec.opts",
      "spec/spec_helper.rb"
   ]

data/Rakefile

@@ -8,7 +8,7 @@ begin
     gem.summary = %Q{TODO}
     gem.email = "info@lvs.co.uk"
     gem.homepage = "http://github.com/lvs/JSONService"
-    gem.authors = ["LVS"]
+    gem.authors = ["LVS", "andyjeffries"]
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
 

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.3.2

data/lib/lvs/json_service/connection_manager.rb

@@ -0,0 +1,53 @@
+module LVS
+  module JsonService
+    class ConnectionManager
+      def self.get_connection(host, port, options)
+        @@connections ||= {}
+        key = create_key(host, port, options)
+        connection = @@connections[key]
+        if connection.nil? || !connection.started?
+          connection = create_connection(host, port, options)
+          @@connections[key] = connection
+        end
+        connection
+      end
+      
+      def self.reset_connection(host, port, options)
+        @@connections ||= {}
+        key = create_key(host, port, options)
+        @@connections.delete(key)
+      end
+
+      def self.reset_all_connections
+        @@connections = {}
+      end
+      
+      def self.create_connection(host, port, options)
+        http = Net::HTTP.new(host, port)
+        if options[:encrypted]
+          http.use_ssl = true
+          # Self-signed certs give streams of "warning: peer certificate won't be verified in this SSL session"
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE 
+          LVS::JsonService::Logger.debug "Using SSL"
+          if options[:auth_cert]
+            LVS::JsonService::Logger.debug "Using Auth"
+            http.cert = OpenSSL::X509::Certificate.new(File.read(options[:auth_cert]))
+            http.key = OpenSSL::PKey::RSA.new(File.read(options[:auth_key]), options[:auth_key_password])
+          end
+        end
+      
+        http.open_timeout = options[:timeout] || 1
+        http.read_timeout = options[:timeout] || 1
+        LVS::JsonService::Logger.debug "Connecting"
+        http.start
+        http
+      end
+      
+      private
+      
+      def self.create_key(host, port, options)
+        "#{host}:#{port}:#{options.to_s}"
+      end
+    end
+  end
+end

data/lib/lvs/json_service/request.rb

@@ -1,5 +1,6 @@
 require 'json'
 require 'lvs/json_service/logger'
+require 'lvs/json_service/connection_manager'
 
 module LVS
   module JsonService
@@ -9,36 +10,30 @@ module LVS
         base.extend ClassMethods    
       end      
       
-      module ClassMethods      
-      
+      module ClassMethods
         def http_request_with_timeout(service, args, options)
-
           uri = URI.parse(service)
-
-          http = Net::HTTP.new(uri.host, uri.port)
-          if options[:encrypted] || require_ssl?
-            http.use_ssl = true
-            # Self-signed certs give streams of "warning: peer certificate won't be verified in this SSL session"
-            http.verify_mode = OpenSSL::SSL::VERIFY_NONE 
-            LVS::JsonService::Logger.debug "Using SSL"
-            if options[:auth_cert]
-              LVS::JsonService::Logger.debug "Using Auth"
-              http.cert = OpenSSL::X509::Certificate.new(File.read(options[:auth_cert]))
-              http.key = OpenSSL::PKey::RSA.new(File.read(options[:auth_key]), options[:auth_key_password])
-            end
-          end
-        
-          http.open_timeout = options[:timeout] || 1
-          http.read_timeout = options[:timeout] || 1
         
           req = Net::HTTP::Post.new(uri.path)
           req.form_data = { "object_request" => args.to_json }
 
+          options[:encrypted] ||= require_ssl?
           retries = options[:retries] || 0
+          hard_retries = 1 # For persistent connection failures
 
           begin
-            retries -= 1          
-            response = http.start { |connection| connection.request(req) }
+            retries -= 1
+                    
+            http = LVS::JsonService::ConnectionManager.get_connection(uri.host, uri.port, options)
+            response = http.request(req)
+          
+          rescue Errno::EPIPE, EOFError, Errno::ECONNRESET
+            hard_retries -= 1
+            if hard_retries >= 0
+              sleep(1)
+              LVS::JsonService::ConnectionManager.reset_connection(uri.host, uri.port, options)
+              retry
+            end
           
           rescue Timeout::Error => e
             if retries >= 0
@@ -83,21 +78,27 @@ module LVS
             response, result = Rails.cache.fetch([service, args].cache_key, :expires_in => options[:cached_for]) do
               start = Time.now
               response = http_request_with_timeout(service, args, options)
+              net_timing = ("%.1f" % ((Time.now - start) * 1000)) + "ms"
+              start = Time.now
               result = JSON.parse(response.body)
-              timing = ("%.1f" % ((Time.now - start) * 1000)) + "ms"
+              parse_timing = ("%.1f" % ((Time.now - start) * 1000)) + "ms"
+              timing = "Net: #{net_timing}, Parse: #{parse_timing}"
               [response, result]
             end
           else
             start = Time.now
             response = http_request_with_timeout(service, args, options)
+            net_timing = ("%.1f" % ((Time.now - start) * 1000)) + "ms"
+            start = Time.now
             result = JSON.parse(response.body)
-            timing = ("%.1f" % ((Time.now - start) * 1000)) + "ms"
+            parse_timing = ("%.1f" % ((Time.now - start) * 1000)) + "ms"
+            timing = "Net: #{net_timing}, Parse: #{parse_timing}"
           end
-          
+
           if response.body.size < 1024 || options[:debug]
             LVS::JsonService::Logger.debug "Response (#{timing}): #{response.body.gsub(/\n/, '')}"
           else
-            LVS::JsonService::Logger.debug "Response Snippet (#{timing} to return #{"%.1f" % (response.body.size/1024)}kB): #{response.body.gsub(/\n/, '')[0..1024]}"
+            LVS::JsonService::Logger.debug "Response Snippet (#{timing} / #{"%.1f" % (response.body.size/1024)}kB): #{response.body.gsub(/\n/, '')[0..1024]}"
           end
           if result.is_a?(Hash) && result.has_key?("PCode")
             raise LVS::JsonService::Error.new(result["message"], result["PCode"], service, args, result)

data/spec/lvs/json_service/connection_manager_spec.rb

@@ -0,0 +1,294 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require File.dirname(__FILE__) + '/mock_net_http'
+
+describe LVS::JsonService::ConnectionManager do
+  before :each do
+    LVS::JsonService::ConnectionManager.reset_all_connections
+    Net::HTTP.stub!(:new).and_return {MockNetHttp.new}
+  end
+
+  it "should return a new HTTP object on the first call" do
+    http = LVS::JsonService::ConnectionManager.get_connection('www.google.com', 80, {})
+    http.class.should eql(MockNetHttp)
+  end
+
+  it "should return an existing HTTP object on subsequent calls" do
+    http = LVS::JsonService::ConnectionManager.get_connection('www.google.com', 80, {})
+    http_subsequent = LVS::JsonService::ConnectionManager.get_connection('www.google.com', 80, {})
+    http.should eql(http_subsequent)
+  end
+
+  it "should reset the connection to a new object if requested" do
+    http = LVS::JsonService::ConnectionManager.get_connection('www.google.com', 80, {})
+    LVS::JsonService::ConnectionManager.reset_connection('www.google.com', 80, {})
+    http_subsequent = LVS::JsonService::ConnectionManager.get_connection('www.google.com', 80, {})
+    http.should_not eql(http_subsequent)
+  end
+
+  it "should reset all connections to requested" do
+    http_google            = LVS::JsonService::ConnectionManager.get_connection('www.google.com', 80, {})
+    http_yahoo             = LVS::JsonService::ConnectionManager.get_connection('www.yahoo.com', 80, {})
+    
+    LVS::JsonService::ConnectionManager.reset_all_connections
+    
+    http_google_subsequent = LVS::JsonService::ConnectionManager.get_connection('www.google.com', 80, {})
+    http_yahoo_subsequent  = LVS::JsonService::ConnectionManager.get_connection('www.yahoo.com', 80, {})
+    
+    http_google.should_not eql(http_google_subsequent)
+    http_yahoo.should_not eql(http_yahoo_subsequent)
+  end
+
+end
+
+__END__
+  
+  describe ".http_request_with_timeout" do
+    before :each do 
+      @mock_post = mock(:post, :null_object => true)
+      Net::HTTP::Post.stub!(:new).and_return(@mock_post)
+      
+      @mock_http = MockNetHttp.new
+      @connection = @mock_http.connection
+      Net::HTTP.stub!(:new).and_return(@mock_http)      
+    end
+    
+    it "should set Net::HTTP#open_timeout" do
+      @mock_http.should_receive(:open_timeout=).with(@options[:timeout])
+      do_request      
+    end
+    
+    it "should set Net::HTTP#read_timeout" do
+      @mock_http.should_receive(:read_timeout=).with(@options[:timeout])      
+      do_request      
+    end    
+    
+    it "should default to a timeout of 1 if not set" do
+      @options = {:timeout => nil}
+      @mock_http.should_receive(:read_timeout=).with(1)     
+      do_request
+    end
+    
+    it "should pass through the domain and port to Net::HTTP" do
+      Net::HTTP.should_receive(:new).with(@domain, @port).and_return(@mock_http)
+      do_request
+    end
+    
+    it "should create a Net::HTTP::Post object" do
+      Net::HTTP::Post.should_receive(:new).with(@path).and_return(@mock_post)
+      do_request
+    end
+    
+    it "should assign the JSON parameters to a Net::HTTP::Post object" do
+      @mock_post.should_receive(:form_data=).with({ "object_request" => @args.to_json })
+      do_request
+    end
+    
+    it "should send one request to Net::HTTP#start" do
+      @connection.should_receive(:request).once.with(@mock_post)
+      do_request
+    end
+    
+    it "should return the response from the service" do
+      response = "some response"
+      @connection.should_receive(:request).and_return(response)
+      do_request.should == response
+    end
+    
+    describe "with 2 retries of Timeout::Error" do
+      
+      before :each do
+        @options = {:retries => 2}
+      end
+
+      describe "with subsequent success" do
+
+        it "should post the request 2 times" do
+          @connection.should_receive(:request).with(@mock_post).exactly(1).times.ordered.and_raise(Timeout::Error.new(nil))                
+          @connection.should_receive(:request).with(@mock_post).exactly(1).times.ordered
+          do_request                
+        end   
+        
+        it "should return the response from the service" do
+          response = "some response"
+          @connection.should_receive(:request).with(@mock_post).exactly(1).times.ordered.and_raise(Timeout::Error.new(nil))                
+          @connection.should_receive(:request).with(@mock_post).exactly(1).times.ordered.and_return(response)
+          do_request.should == response          
+        end
+        
+      end
+            
+      it "should log the retry attempt" do
+        @connection.stub!(:request).and_raise(Timeout::Error.new(nil))
+        LVS::JsonService::Logger.stub!(:debug)
+        LVS::JsonService::Logger.should_receive(:debug).at_least(1).times.
+          with("Retrying #{@url} due to TimeoutError")
+        do_request_catching_errors
+      end
+      
+      describe "with subseqent failure" do
+
+        before :each do
+          @connection.stub!(:request).and_raise(Timeout::Error.new(nil))
+        end
+
+        it "should post the request 3 times (original + 2 retries)" do
+          @connection.should_receive(:request).with(@mock_post).exactly(3).times.and_raise(Timeout::Error.new(nil))        
+          do_request_catching_errors
+        end
+
+        it "should raise an LVS::JsonService::TimeoutError exception" do
+          lambda {
+            do_request
+          }.should raise_error(LVS::JsonService::TimeoutError)
+        end
+      end
+        
+    end
+    
+    describe "with 2 retries of Errno::ECONNREFUSED" do
+      
+      before :each do
+        @options = {:retries => 2}
+        ClassWithRequest.stub!(:sleep)                  
+      end
+      
+      it "should sleep for 1 second before each timeout" do
+        @connection.stub!(:request).and_raise(Errno::ECONNREFUSED)        
+        ClassWithRequest.should_receive(:sleep).with(1)
+        do_request_catching_errors
+      end
+      
+      describe "with subsequent success" do
+
+        it "should post the request 2 times" do
+          @connection.should_receive(:request).with(@mock_post).exactly(1).times.ordered.and_raise(Errno::ECONNREFUSED)                
+          @connection.should_receive(:request).with(@mock_post).exactly(1).times.ordered
+          do_request                
+        end   
+        
+        it "should return the response from the service" do
+          response = "some response"
+          @connection.should_receive(:request).with(@mock_post).exactly(1).times.ordered.and_raise(Errno::ECONNREFUSED)                
+          @connection.should_receive(:request).with(@mock_post).exactly(1).times.ordered.and_return(response)
+          do_request.should == response
+        end
+      end
+
+      describe "with subsequent failure" do
+        
+        before :each do
+          @connection.stub!(:request).and_raise(Errno::ECONNREFUSED)      
+        end        
+        
+        it "should post the request 3 times (original + 2 retries)" do
+          @connection.should_receive(:request).with(@mock_post).exactly(3).times.and_raise(Errno::ECONNREFUSED)        
+          do_request_catching_errors
+        end      
+
+        it "should raise an LVS::JsonService::BackendUnavailableError exception" do
+          lambda {
+            do_request
+          }.should raise_error(LVS::JsonService::BackendUnavailableError)
+        end
+
+      end
+
+      it "should log the retry attempt" do
+        @connection.stub!(:request).and_raise(Errno::ECONNREFUSED)
+        LVS::JsonService::Logger.stub!(:debug)
+        LVS::JsonService::Logger.should_receive(:debug).at_least(1).times.
+          with("Retrying #{@url} due to Errno::ECONNREFUSED")
+        do_request_catching_errors
+      end
+    end
+
+    it "should raise LVS::JsonService::NotFoundError if Net::HTTPNotFound is raised" do
+      @connection.stub!(:request).and_return(Net::HTTPNotFound.new(404, 1.1, "Not Found"))
+      lambda {
+        do_request
+      }.should raise_error(LVS::JsonService::NotFoundError)
+    end
+    
+    it "should raise LVS::JsonService::NotModified if HTTPNotModified is raised" do
+      @connection.stub!(:request).and_return(Net::HTTPNotModified.new(304, 1.1, "Not Modified"))
+      lambda {
+        do_request
+      }.should raise_error(LVS::JsonService::NotModified)
+    end
+    
+    def do_request
+      ClassWithRequest.http_request_with_timeout(@url, @args, @options)
+    end
+    
+    def do_request_catching_errors
+      do_request
+    rescue LVS::JsonService::Error
+    end
+    
+  end
+
+  describe ".run_remote_request" do
+    before :each do
+      @response = load_fixture('response.yml')
+    end
+
+    it "should call http_request_with_timeout with service, args and options" do
+      ClassWithRequest.should_receive(:http_request_with_timeout).
+        with(@url, @args, @options).
+        and_return(@response)
+      ClassWithRequest.run_remote_request(@url, @args, @options)
+    end
+
+    it "should return the parsed JSON result" do
+      expected_result = [
+        {"id"=>1100, "description"=>"Handball (ABP)"},
+        {"id"=>978400, "description"=>"Casino Roulette"}
+      ]
+      ClassWithRequest.stub!(:http_request_with_timeout).and_return(@response)
+      ClassWithRequest.run_remote_request(@url, @args, @options).should == expected_result
+    end
+
+    it "should raise an error if the response contains PCode" do
+      error_response = load_fixture('error_response.yml')
+      ClassWithRequest.stub!(:http_request_with_timeout).
+        and_return(error_response)
+
+      lambda {
+        ClassWithRequest.run_remote_request(@url, @args, @options)
+      }.should raise_error(LVS::JsonService::Error)
+    end
+  end
+  
+end
+
+def load_fixture (file)
+  response_file = File.join(File.dirname(__FILE__), '..', '..', 'fixtures', file)
+  YAML.load_file(response_file)
+end
+
+class MockNetHttp
+  
+  attr_accessor :connection
+  
+  def initialize(*args)
+    @connection = mock(:connection)    
+  end
+  
+  def start
+    yield @connection if block_given?
+  end  
+    
+  def method_missing(*args)
+    return self
+  end
+    
+end
+
+class ClassWithRequest
+  include LVS::JsonService::Request
+  
+  def self.require_ssl?
+    false
+  end
+end
+

data/spec/lvs/json_service/json_methods_spec.rb

@@ -0,0 +1,57 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+class TestServiceForJsonMethodsCall < LVS::JsonService::Base
+  self.agp_location = "http://doesntmatter.anything"
+  self.site = 'testjsonservices/'
+  self.service_prefix = 'com.json.commands.'
+  self.field_prefix = 'event_'
+
+  fake_service :details, 
+    '{"id":1, "status":"OK", "count":2, "startDate":1240498565709, "hasOwner":1, 
+    "bets":[{"betAmount":123}, {"betAmount":456}],
+    "startDate":1240498565709, "with123":1}'
+end
+
+describe LVS::JsonService::Base do
+  it "should include an array of bets" do
+    TestServiceForJsonMethodsCall.details(:num_results => 5).bets.should be_an(Array)
+  end
+  
+  it "should respond to bet_amount on the first element of the array of bets" do
+    TestServiceForJsonMethodsCall.details(:num_results => 5).bets[0].respond_to?(:bet_amount).should be_true
+  end
+  
+  it "should not respond to bet_other on the first element of the array of bets" do
+    TestServiceForJsonMethodsCall.details(:num_results => 5).bets[0].respond_to?(:bet_other).should be_false
+  end
+  
+  it "should have an id of 1" do
+    TestServiceForJsonMethodsCall.details(:num_results => 5).id.should eql(1)
+  end
+  
+  it "should have a first child in the bets array with a bet_amount parameter of 123" do
+    TestServiceForJsonMethodsCall.details(:num_results => 5).bets.first.bet_amount.should eql(123)
+  end
+  
+  it "should have a working question mark method for boolean field has_owner" do
+    TestServiceForJsonMethodsCall.details(:num_results => 5).owner?.should be_true
+  end
+  
+  it "should convert date columns to dates" do
+    TestServiceForJsonMethodsCall.details.start_date.utc.to_s(:rfc822).should eql("Thu, 23 Apr 2009 14:56:05 +0000")
+  end
+  
+  it "should recognise keys with integers in them" do
+    TestServiceForJsonMethodsCall.details.with123.should eql(1)
+  end
+  
+  it "should find camelCase attributes using camelCase or ruby_sytax" do
+    class AttributeNames < LVS::JsonService::Base
+      self.ignore_missing = true
+      fake_service :call, '{"longMethodName":1}'
+    end
+    obj = AttributeNames.call
+    obj.longMethodName.should eql(1)
+    obj.long_method_name.should eql(1)
+  end
+end

data/spec/lvs/json_service/mock_net_http.rb

@@ -0,0 +1,17 @@
+class MockNetHttp
+  
+  attr_accessor :connection
+  
+  def initialize(*args)
+    @connection = mock(:connection)    
+  end
+  
+  def start
+    yield @connection if block_given?
+  end  
+    
+  def method_missing(*args)
+    return self
+  end
+    
+end

data/spec/lvs/json_service/request_spec.rb

@@ -1,4 +1,5 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require File.dirname(__FILE__) + '/mock_net_http'
 
 # Explicitly requiring this now to ensure it is loaded before we try to
 # unmarshall response from the yaml fixture file.
@@ -13,6 +14,7 @@ describe LVS::JsonService::Request do
 
     @args   = {:some => "thing"}
     @options= {:timeout => 100}
+    LVS::JsonService::ConnectionManager.reset_all_connections
   end
   
   describe ".http_request_with_timeout" do
@@ -92,6 +94,7 @@ describe LVS::JsonService::Request do
             
       it "should log the retry attempt" do
         @connection.stub!(:request).and_raise(Timeout::Error.new(nil))
+        LVS::JsonService::Logger.stub!(:debug)
         LVS::JsonService::Logger.should_receive(:debug).at_least(1).times.
           with("Retrying #{@url} due to TimeoutError")
         do_request_catching_errors
@@ -167,6 +170,7 @@ describe LVS::JsonService::Request do
 
       it "should log the retry attempt" do
         @connection.stub!(:request).and_raise(Errno::ECONNREFUSED)
+        LVS::JsonService::Logger.stub!(:debug)
         LVS::JsonService::Logger.should_receive(:debug).at_least(1).times.
           with("Retrying #{@url} due to Errno::ECONNREFUSED")
         do_request_catching_errors
@@ -237,24 +241,6 @@ def load_fixture (file)
   YAML.load_file(response_file)
 end
 
-class MockNetHttp
-  
-  attr_accessor :connection
-  
-  def initialize(*args)
-    @connection = mock(:connection)    
-  end
-  
-  def start
-    yield @connection
-  end  
-    
-  def method_missing(*args)
-    return self
-  end
-    
-end
-
 class ClassWithRequest
   include LVS::JsonService::Request
   

data/spec/lvs/json_service/setting_fields_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+class TestServiceForFakingCall < LVS::JsonService::Base
+  self.agp_location = "http://doesntmatter.anything"
+  self.site = 'testjsonservices/'
+  self.service_prefix = 'com.json.commands.'
+  self.field_prefix = 'event_'
+
+  fake_service :details, 
+    '{"id":1, "status":"OK", "count":2, "startDate":1240498565709, "hasOwner":1, 
+    "bets":[{"betAmount":123}, {"betAmount":456}],
+    "startDate":1240498565709}'
+end
+
+describe LVS::JsonService::Base do
+  it "should return stored values as is without playing" do
+    
+    obj = TestServiceForFakingCall.details
+    test_hash = {:abc => [1, 2, 3]}
+    obj.status = test_hash
+    obj.status.should eql(test_hash)
+  end
+  
+end

metadata

@@ -1,10 +1,11 @@
 --- !ruby/object:Gem::Specification 
 name: LVS-JSONService
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
+  version: 0.3.2
 platform: ruby
 authors: 
 - LVS
+- andyjeffries
 autorequire: 
 bindir: bin
 cert_chain: []
@@ -34,16 +35,22 @@ files:
 - lib/lvs/json_service/base.rb
 - lib/lvs/json_service/logger.rb
 - lib/lvs/json_service/request.rb
+- lib/lvs/json_service/connection_manager.rb
 - spec/fixtures/error_response.yml
 - spec/fixtures/response.yml
 - spec/json_service_spec.rb
 - spec/lvs/json_service/base_spec.rb
+- spec/lvs/json_service/connection_manager_spec.rb
+- spec/lvs/json_service/json_methods_spec.rb
 - spec/lvs/json_service/logger_spec.rb
 - spec/lvs/json_service/request_spec.rb
+- spec/lvs/json_service/mock_net_http.rb
+- spec/lvs/json_service/setting_fields_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
 has_rdoc: false
 homepage: http://github.com/lvs/JSONService
+licenses: 
 post_install_message: 
 rdoc_options: 
 - --charset=UTF-8
@@ -64,7 +71,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.2.0
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: A Ruby library for interacting with external JSON services