rhoconnect 3.0.0.beta1

data/spec/perf/store_perf_spec.rb

@@ -0,0 +1,27 @@
+require File.join(File.dirname(__FILE__),'perf_spec_helper')
+
+describe "Rhoconnect Performance" do
+  it_behaves_like "SharedRhoconnectHelper", :rhoconnect_data => false do
+    it "should process get/put for 1000 records (6000 elements)" do
+      @data = get_test_data(1000)
+      start = start_timer
+      Store.put_data('mdoc',@data).should == true
+      start = lap_timer('put_data duration',start)
+      Store.get_data('mdoc').should == @data
+      lap_timer('get_data duration',start)
+    end
+
+    it "should process single attribute update 1000-record doc" do
+      @data = get_test_data(1000)
+      @data1 = get_test_data(1000)
+      @data1['950']['Phone1'] = 'This is changed'
+      expected = {'950' => {'Phone1' => 'This is changed'}}
+      Store.put_data('mdoc',@data).should == true
+      Store.put_data('cdoc',@data1).should == true
+      start = start_timer
+      Store.get_diff_data('mdoc','cdoc').should == [expected,1]
+      lap_timer('get_diff_data duration', start)
+    end
+  end
+
+end

data/spec/ping/android_spec.rb

@@ -0,0 +1,91 @@
+require File.join(File.dirname(__FILE__),'..','spec_helper')
+require File.join(File.dirname(__FILE__), '..', 'support', 'shared_examples')
+
+describe "Ping Android" do
+  it_behaves_like "SharedRhoconnectHelper", :rhoconnect_data => false do
+    def setup_post_yield(response)
+      if RUBY_VERSION =~ /1.9/ or defined?(JRUBY_VERSION)
+        RestClient.stub!(:post).and_yield(response, nil, nil)
+      else
+        RestClient.stub!(:post).and_yield(response)
+      end
+    end
+    
+    before do
+      @params = {"device_pin" => @c.device_pin,
+        "sources" => [@s.name], "message" => 'hello world', 
+        "vibrate" => '5', "badge" => '5', "sound" => 'hello.mp3'}
+      @response = mock('response')
+    end
+
+    it "should ping android successfully" do
+      result = 'id=0:34234234134254%abc123\n'
+     	@response.stub!(:code).and_return(200)
+     	@response.stub!(:body).and_return(result)
+     	@response.stub!(:[]).and_return(false)
+     	@response.stub!(:return!).and_return(@response)
+     	setup_post_yield(@response)
+     	Android.ping(@params).body.should == result
+    end
+
+    it "should ping android with 503 connection error" do
+      error = 'Connection refused'
+      @response.stub!(:body).and_return(error)
+      RestClient.stub!(:post).and_return { raise RestClient::Exception.new(@response,503) }
+      Android.should_receive(:log).twice
+      lambda { Android.ping(@params) }.should raise_error(RestClient::Exception)
+    end
+
+    it "should ping android with 200 error message" do
+      error = 'Error=QuotaExceeded'
+      @response.stub!(:code).and_return(200)
+      @response.stub!(:body).and_return(error)
+      @response.stub!(:[]).and_return(nil)
+     	setup_post_yield(@response)
+      Android.should_receive(:log).twice
+      lambda { Android.ping(@params) }.should raise_error(Android::AndroidPingError, "Android ping error: QuotaExceeded")
+    end
+
+    it "should ping android with stale auth token" do
+      @response.stub!(:code).and_return(200)
+      @response.stub!(:body).and_return('')
+      @response.stub!(:[]).and_return({:update_client_auth => 'abc123'})
+     	setup_post_yield(@response)
+      Android.should_receive(:log).twice
+      lambda { Android.ping(@params) }.should raise_error(
+        Android::StaleAuthToken, "Stale auth token, please update :authtoken: in settings.yml."
+      )
+    end
+
+    it "should ping android with 401 error message" do
+      @response.stub!(:code).and_return(401)
+      @response.stub!(:body).and_return('')
+     	setup_post_yield(@response)
+      Android.should_receive(:log).twice
+      lambda { Android.ping(@params) }.should raise_error(
+        Android::InvalidAuthToken, "Invalid auth token, please update :authtoken: in settings.yml."
+      )
+    end
+
+    it "should compute c2d_message" do
+      expected = {'registration_id' => @c.device_pin, 'collapse_key' => "RAND_KEY",
+        'data.do_sync' => @s.name,
+        'data.alert' => "hello world",
+        'data.vibrate' => '5',
+        'data.sound' => "hello.mp3"}
+      actual = Android.c2d_message(@params)
+      actual['collapse_key'] = "RAND_KEY" unless actual['collapse_key'].nil?
+      actual.should == expected
+    end
+
+    it "should trim empty or nil params from c2d_message" do
+      expected = {'registration_id' => @c.device_pin, 'collapse_key' => "RAND_KEY",
+        'data.vibrate' => '5', 'data.do_sync' => '', 'data.sound' => "hello.mp3"}
+      params = {"device_pin" => @c.device_pin,
+        "sources" => [], "message" => '', "vibrate" => '5', "sound" => 'hello.mp3'}
+      actual = Android.c2d_message(params)
+      actual['collapse_key'] = "RAND_KEY" unless actual['collapse_key'].nil?
+      actual.should == expected
+    end
+  end  
+end

data/spec/ping/apple_spec.rb

@@ -0,0 +1,70 @@
+require File.join(File.dirname(__FILE__),'..','spec_helper')
+require File.join(File.dirname(__FILE__), '..', 'support', 'shared_examples')
+
+describe "Ping Apple" do
+  it_behaves_like "SharedRhoconnectHelper", :rhoconnect_data => false do
+    before do
+      @params = {"user_id" => @u.id, "api_token" => @api_token,
+        "sources" => [@s.name], "message" => 'hello world', 
+        "vibrate" => '5', "badge" => '5', "sound" => 'hello.mp3',
+        "device_pin" => @c.device_pin, "device_port" => @c.device_port}
+      ssl_ctx = mock("ssl_ctx")
+      ssl_ctx.stub!(:key=).and_return('key')
+      ssl_ctx.stub!(:cert=).and_return('cert')
+      OpenSSL::SSL::SSLContext.stub!(:new).and_return(ssl_ctx)
+      OpenSSL::PKey::RSA.stub!(:new)
+      OpenSSL::X509::Certificate.stub!(:new)
+
+      tcp_socket = mock("tcp_socket")
+      tcp_socket.stub!(:close)
+      TCPSocket.stub!(:new).and_return(tcp_socket)
+
+      @ssl_socket = mock("ssl_socket")
+      @ssl_socket.stub!(:sync=)
+      @ssl_socket.stub!(:connect)
+      @ssl_socket.stub!(:write)
+      @ssl_socket.stub!(:close)
+      OpenSSL::SSL::SSLSocket.stub!(:new).and_return(@ssl_socket)
+    end
+
+    # TODO: This should really test SSLSocket.write
+    it "should ping apple" do
+      Apple.ping(@params)
+    end
+
+    it "should log deprecation on iphone ping" do
+      Iphone.should_receive(
+        :log
+      ).once.with("DEPRECATION WARNING: 'iphone' is a deprecated device_type, use 'apple' instead")
+      Iphone.ping(@params)
+    end
+
+    it "should compute apn_message" do
+      expected_hash = {
+        "aps"=>{"vibrate"=>"5", "badge"=>5, "alert"=>"hello world", "sound"=>"hello.mp3"}, 
+        "do_sync"=>["SampleAdapter"] 
+      }
+      apn_message = Apple.apn_message(@params)
+      apn_message.start_with?("\000\000 \253\315\000g").should be_true 
+      JSON.parse(apn_message.sub("\000\000 \253\315\000g","")).should ==  expected_hash
+    end
+
+    it "should compute apn_message with source array" do
+      @params['sources'] << 'SimpleAdapter'
+      expected_hash = {
+        "aps"=>{"vibrate"=>"5", "badge"=>5, "alert"=>"hello world", "sound"=>"hello.mp3"}, 
+        "do_sync"=>["SampleAdapter", "SimpleAdapter"] 
+      }
+      apn_message = Apple.apn_message(@params)
+      apn_message.start_with?("\000\000 \253\315\000w").should be_true 
+      JSON.parse(apn_message.sub("\000\000 \253\315\000w","")).should ==  expected_hash
+    end
+
+    it "should raise SocketError if socket fails" do
+      error = 'socket error'
+      @ssl_socket.stub!(:write).and_return { raise SocketError.new(error) }
+      Apple.should_receive(:log).once.with("Error while sending ping: #{error}")
+      lambda { Apple.ping(@params) }.should raise_error(SocketError,error)
+    end
+  end  
+end

data/spec/ping/blackberry_spec.rb

@@ -0,0 +1,62 @@
+require File.join(File.dirname(__FILE__),'..','spec_helper')
+require File.join(File.dirname(__FILE__), '..', 'support', 'shared_examples')
+
+describe "Ping Blackberry" do
+  it_behaves_like "SharedRhoconnectHelper", :rhoconnect_data => false do
+    before do
+      @params = {"user_id" => @u.id, "api_token" => @api_token,
+        "sources" => [@s.name], "message" => 'hello world', 
+        "vibrate" => '5', "badge" => '5', "sound" => 'hello.mp3',
+        "device_pin" => @c.device_pin, "device_port" => @c.device_port}
+      post = mock('post')
+      post.stub!(:new).and_return(post)
+      post.stub!(:body=)
+      Net::HTTP::Post.stub!(:new).and_return(post)
+
+      @http = mock('http')
+      @http.stub!(:request)
+      @http.stub!(:start).and_yield(@http)
+      Net::HTTP.stub!(:new).and_return(@http)
+    end
+
+    it "should ping blackberry" do
+      Blackberry.ping(@params)
+    end
+
+    it "should ping blackberry with connection error" do
+      error = 'Connection refused'
+      @http.stub!(:request).and_return { raise SocketError.new(error) }
+      Blackberry.should_receive(:log).once.with("Error while sending ping: #{error}")
+      lambda { Blackberry.ping(@params) }.should raise_error(SocketError,error)
+    end
+
+    it "should compute pap_message" do
+      expected = <<PAP
+--asdlfkjiurwghasf
+Content-Type: application/xml; charset=UTF-8
+  
+<?xml version="1.0"?>
+<!DOCTYPE pap PUBLIC "-//WAPFORUM//DTD PAP 2.0//EN" 
+  "http://www.wapforum.org/DTD/pap_2.0.dtd" 
+  [<?wap-pap-ver supported-versions="2.0"?>]>
+<pap>
+<push-message push-id="pushID:RAND_ID" ppg-notify-requested-to="http://localhost:7778">
+
+<address address-value="WAPPUSH=0%3A100/TYPE=USER@rim.net"/>
+<quality-of-service delivery-method="preferconfirmed"/>
+</push-message>
+</pap>
+--asdlfkjiurwghasf
+Content-Type: text/plain
+
+do_sync=SampleAdapter
+alert=hello world
+vibrate=5
+sound=hello.mp3
+--asdlfkjiurwghasf-- 
+PAP
+      actual = Blackberry.pap_message(@params).gsub!(/pushID\:\d+/,'pushID:RAND_ID')
+      actual.gsub!(/\r|\n|\s/,"").should == expected.gsub!(/\r|\n|\s/,"")
+    end
+  end        
+end

data/spec/read_state_spec.rb

@@ -0,0 +1,35 @@
+require File.join(File.dirname(__FILE__),'spec_helper')
+require File.join(File.dirname(__FILE__), 'support', 'shared_examples')
+
+describe "ReadState" do
+  it_behaves_like "SharedRhoconnectHelper", :rhoconnect_data => false do
+    it "should create refresh with correct id" do
+      @r.id.should == "#{@a_fields[:name]}:#{@u_fields[:login]}:#{@s_fields[:name]}"
+    end
+
+    it "should create refresh with default fields" do
+      @r.refresh_time.should <= Time.now.to_i
+    end
+
+    it "should load refresh with params" do
+      @r1 = ReadState.load(:app_id => @a_fields[:name],
+        :user_id => @u_fields[:login],:source_name => @s_fields[:name])
+      @r1.refresh_time.should <= Time.now.to_i
+    end
+
+    it "should delete read_state from db" do
+      ReadState.delete(@a_fields[:name])
+      Store.db.keys("read_state*").should == []
+    end
+    
+    it "should delete read_state from source" do
+      time = Time.now.to_i
+      @s.read_state.refresh_time = time
+      @s.load_read_state.refresh_time.should == time
+
+      @s.delete_user_read_state
+      @s.load_read_state.should == nil
+    end
+      
+  end
+end

data/spec/rhosync_spec.rb

@@ -0,0 +1,75 @@
+require File.join(File.dirname(__FILE__),'spec_helper')
+require File.join(File.dirname(__FILE__), 'support', 'shared_examples')
+
+describe "Rhoconnect" do
+  include TestHelpers    
+  let(:test_app_name) { 'application' }  
+
+  before(:each) do 
+    Store.create
+    Store.db.flushdb
+  end
+  
+  it "should bootstrap Rhoconnect with block" do
+    Rhoconnect.bootstrap(get_testapp_path) do |rhoconnect|
+      rhoconnect.vendor_directory = 'foo'
+    end
+    path = get_testapp_path
+    File.expand_path(Rhoconnect.base_directory).should == path
+    File.expand_path(Rhoconnect.app_directory).should == path
+    File.expand_path(Rhoconnect.data_directory).should == File.join(path,'data')
+    Rhoconnect.vendor_directory.should == 'foo'
+    Rhoconnect.blackberry_bulk_sync.should == false
+    Rhoconnect.bulk_sync_poll_interval.should == 3600
+    Rhoconnect.environment.should == :test  
+    Rhoconnect.stats.should == false
+    Rhoconnect.appserver.should == 'http://test.rhoconnect.com'
+    Rhoconnect.cookie_expire.should == 9999999
+    App.is_exist?(test_app_name).should be_true
+  end
+
+  it "should bootstrap Rhoconnect with RHO_ENV provided" do
+    ENV['RHO_ENV'] = 'production'
+    Rhoconnect.bootstrap(get_testapp_path)
+    Rhoconnect.environment.should == :production
+    ENV.delete('RHO_ENV')
+  end
+  
+  it "should bootstrap Rhoconnect with RACK_ENV provided" do
+    env = ENV['RACK_ENV'].dup
+    ENV['RACK_ENV'] = 'production'
+    Rhoconnect.bootstrap(get_testapp_path)
+    Rhoconnect.environment.should == :production
+    ENV['RACK_ENV'] = env
+  end
+  
+  it "should bootstrap with existing app" do
+    app = App.create(:name => test_app_name)
+    App.should_receive(:load).once.with(test_app_name).and_return(app)
+    Rhoconnect.bootstrap(get_testapp_path)
+  end
+
+  it "should bootstrap app with no sources" do
+    App.create(:name => test_app_name).delete
+    Rhoconnect.bootstrap(get_emptyapp_path)
+    App.load(test_app_name).sources.should == []
+  end
+
+  it "should exit if schema config exists" do
+    config = Rhoconnect.get_config(get_testapp_path)
+    config[:sources]['FixedSchemaAdapter'].merge!(
+      'schema' => {'property' => 'foo'}
+    )
+    Rhoconnect.stub!(:get_config).and_return(config)
+    Rhoconnect.should_receive(:log).once.with(
+      "ERROR: 'schema' field in settings.yml is not supported anymore, please use source adapter schema method!"
+    )
+    lambda { Rhoconnect.bootstrap(get_testapp_path) }.should raise_error(SystemExit)
+  end
+
+  it "should add associations during bootstrap" do
+    Rhoconnect.bootstrap(get_testapp_path)
+    s = Source.load('SampleAdapter',{:app_id => test_app_name,:user_id => '*'})
+    s.has_many.should == "FixedSchemaAdapter,brand"
+  end
+end

data/spec/server/cors_spec.rb

@@ -0,0 +1,287 @@
+require 'rhoconnect/cors'
+require File.join(File.dirname(__FILE__),'..','spec_helper')
+
+require "cgi"
+
+COOKIE_NAME = 'some_cookie'
+COOKIE_VALUE = 'some_session_key=some_session_value'
+
+COOKIE_NV = "#{COOKIE_NAME}=#{COOKIE_VALUE}"
+COOKIE_ANOTHER_NV = "#{COOKIE_NAME}=#{COOKIE_VALUE}_another"
+
+PROPER_QUERY_STRING = "?abc=123&#{COOKIE_NAME}=#{CGI.escape(COOKIE_VALUE)}&de=45"
+WRONG_QUERY_STRING = "?abc=123&#{COOKIE_NAME}_wrong=#{CGI.escape(COOKIE_VALUE)}&de=45"
+
+PROPER_URI_NEW = '/api/application'
+PROPER_URI_OLD = '/application'
+WRONG_URI = '/some/wrong/path/to/rhoconnect/application'
+
+LOGIN_URI_NEW = '/api/application/clientlogin'
+LOGIN_URI_OLD = '/application/clientlogin'
+
+describe "CORS middleware" do
+
+  class StubApp
+    def call(env)
+      [200, {'Set-Cookie' => 'someCookie=someValue', 'Content-Length' => '0'}, '']
+    end
+  end
+
+  before(:each) do
+    @app ||= StubApp.new
+
+    @middleware = Rack::Cors.new @app, {} do |cfg|
+        cfg.allow do |allow|
+          allow.origins /allowed_origin/, 'file://'
+          allow.resource '/application',   :headers => :any, :methods => [:get, :post, :put, :delete], :credentials => true
+          allow.resource '/application/*', :headers => :any, :methods => [:get, :post, :put, :delete], :credentials => false
+          allow.resource '/api/application',   :headers => 'allowed_header', :methods => [:get, :post, :put, :delete], :credentials => true, :expose => 'Content-Length'
+          allow.resource '/api/application/*', :headers => :any, :methods => [:get, :post, :put, :delete], :credentials => true
+        end
+    end
+  end
+
+  it "preflight check should allow unknown origins if public access is configured" do
+    mv = Rack::Cors.new @app, {} do |cfg|
+        cfg.allow do |allow|
+          allow.origins '*', 'mock_value'
+          allow.resource '/mock+path',   :headers => :any, :methods => [:get, :post, :put, :delete], :credentials => true
+          allow.resource '/mock%20path',   :headers => :any, :methods => [:get, :post, :put, :delete], :credentials => true
+          allow.resource /\/mock_path/,   :headers => :any, :methods => [:get, :post, :put, :delete], :credentials => true
+
+          exception_happens = false
+          begin
+            allow.resource nil,   :headers => :any, :methods => [:get, :post, :put, :delete], :credentials => true
+          rescue Exception => e
+            exception_happens = true
+            e.is_a?(TypeError).should == true
+          end
+          exception_happens.should == true
+
+          allow.resource '/application',   :headers => :any, :methods => [:get, :post, :put, :delete], :credentials => true
+          allow.resource '/application/*', :headers => :any, :methods => [:get, :post, :put, :delete], :credentials => false
+          allow.resource '/api/application',   :headers => 'allowed_header', :methods => [:get, :post, :put, :delete], :credentials => true, :expose => 'Content-Length'
+          allow.resource '/api/application/*', :headers => :any, :methods => [:get, :post, :put, :delete], :credentials => true
+        end
+    end
+
+    env = {
+        'REQUEST_METHOD' => 'OPTIONS',
+        'PATH_INFO' => '/api/application',
+        'HTTP_ORIGIN' => 'wrong_origin',
+        'HTTP_ACCESS_CONTROL_REQUEST_METHOD' => 'POST'
+    }
+    status, headers, body = mv.call(env)
+    200.should == status
+    headers['Access-Control-Allow-Origin'].should == '*'
+  end
+
+  it "preflight check should disable unknown origins" do
+    env = {
+        'REQUEST_METHOD' => 'OPTIONS',
+        'PATH_INFO' => '/api/application',
+        'HTTP_ORIGIN' => 'wrong_origin',
+        'HTTP_ACCESS_CONTROL_REQUEST_METHOD' => 'POST'
+    }
+    status, headers, body = @middleware.call(env)
+    200.should == status
+    headers['Access-Control-Allow-Origin'].should_not == 'wrong_origin'
+  end
+
+  it "preflight check should allow known origins" do
+    env = {
+        'REQUEST_METHOD' => 'OPTIONS',
+        'PATH_INFO' => '/api/application',
+        'HTTP_ORIGIN' => 'allowed_origin',
+        'HTTP_ACCESS_CONTROL_REQUEST_METHOD' => 'POST'
+    }
+    status, headers, body = @middleware.call(env)
+    200.should == status
+    headers['Access-Control-Allow-Origin'].should == 'allowed_origin'
+  end
+
+  it "able to use fallback X-ORIGIN request header if ORIGIN header is undefined" do
+    env = {
+        'REQUEST_METHOD' => 'POST',
+        'PATH_INFO' => '/api/application',
+        'HTTP_X_ORIGIN' => 'allowed_origin',
+        'HTTP_ACCESS_CONTROL_REQUEST_METHOD' => 'POST'
+    }
+    status, headers, body = @middleware.call(env)
+    200.should == status
+    headers['Access-Control-Allow-Origin'].should == 'allowed_origin'
+  end
+
+  it "preflight check treats empty 'null' origin as 'file://' one" do
+    env = {
+        'REQUEST_METHOD' => 'OPTIONS',
+        'PATH_INFO' => '/api/application',
+        'HTTP_ORIGIN' => 'null',
+        'HTTP_ACCESS_CONTROL_REQUEST_METHOD' => 'POST'
+    }
+    status, headers, body = @middleware.call(env)
+    200.should == status
+    headers['Access-Control-Allow-Origin'].should == 'file://'
+  end
+
+  it "preflight check should enable allowed request headers" do
+    env = {
+        'REQUEST_METHOD' => 'OPTIONS',
+        'PATH_INFO' => '/api/application',
+        'HTTP_ORIGIN' => 'allowed_origin',
+        'HTTP_ACCESS_CONTROL_REQUEST_METHOD' => 'POST',
+        'HTTP_ACCESS_CONTROL_REQUEST_HEADERS' => 'allowed_header'
+    }
+    status, headers, body = @middleware.call(env)
+    200.should == status
+    #headers['Access-Control-Allow-Origin'].should == 'allowed_origin'
+    headers['Access-Control-Allow-Headers'].should == 'allowed_header'
+  end
+
+  it "preflight check should disable not allowed request headers" do
+    env = {
+        'REQUEST_METHOD' => 'OPTIONS',
+        'PATH_INFO' => '/api/application',
+        'HTTP_ORIGIN' => 'allowed_origin',
+        'HTTP_ACCESS_CONTROL_REQUEST_METHOD' => 'POST',
+        'HTTP_ACCESS_CONTROL_REQUEST_HEADERS' => 'not_allowed_header'
+    }
+    status, headers, body = @middleware.call(env)
+    200.should == status
+    #headers['Access-Control-Allow-Origin'].should == 'allowed_origin'
+    headers['Access-Control-Allow-Headers'].should_not == 'not_allowed_header'
+  end
+
+  it "preflight check should allow any request headers if configured so" do
+    env = {
+        'REQUEST_METHOD' => 'OPTIONS',
+        'PATH_INFO' => '/api/application/any_headers_allowed_here',
+        'HTTP_ORIGIN' => 'allowed_origin',
+        'HTTP_ACCESS_CONTROL_REQUEST_METHOD' => 'POST',
+        'HTTP_ACCESS_CONTROL_REQUEST_HEADERS' => 'not_allowed_header'
+    }
+    status, headers, body = @middleware.call(env)
+    200.should == status
+    #headers['Access-Control-Allow-Origin'].should == 'allowed_origin'
+    headers['Access-Control-Allow-Headers'].should == 'not_allowed_header'
+  end
+
+
+  it "only allowed response headers should be exposed" do
+    env = {
+        'REQUEST_METHOD' => 'POST',
+        'PATH_INFO' => '/api/application',
+        'HTTP_ORIGIN' => 'allowed_origin',
+        'HTTP_ACCESS_CONTROL_REQUEST_METHOD' => 'POST'
+    }
+    status, headers, body = @middleware.call(env)
+    200.should == status
+    headers['Access-Control-Expose-Headers'].should == 'Content-Length'
+  end
+
+  it "no response headers should be exposed by default" do
+    env = {
+        'REQUEST_METHOD' => 'POST',
+        'PATH_INFO' => '/api/application/no_headers_exposed_here_by_default',
+        'HTTP_ORIGIN' => 'allowed_origin',
+        'HTTP_ACCESS_CONTROL_REQUEST_METHOD' => 'POST'
+    }
+    status, headers, body = @middleware.call(env)
+    200.should == status
+    headers['Access-Control-Expose-Headers'].should == ''
+  end
+
+
+=begin
+  it "should skip if it isn't a sync protocol URI, for old REST routes" do
+    env = {
+        'PATH_INFO' => WRONG_URI,
+        'QUERY_STRING' => PROPER_QUERY_STRING
+    }
+    status, headers, body = @middleware_old_routes.call(env)
+    200.should == status
+    COOKIE_ANOTHER_NV.should == headers['Set-Cookie']
+    COOKIE_NV.should_not == env['HTTP_COOKIE']
+    headers['Content-Length'].should == body.length.to_s
+    ''.should == body
+  end
+
+  it "should process cookie from QUERY_STRING if it is a sync protocol URI, for new REST routes" do
+    env = {
+        'PATH_INFO' => PROPER_URI_NEW,
+        'QUERY_STRING' => PROPER_QUERY_STRING
+    }
+    status, headers, body = @middleware_new_routes.call(env)
+    200.should == status
+    COOKIE_ANOTHER_NV.should == headers['Set-Cookie']
+    env['HTTP_COOKIE'].should == COOKIE_VALUE
+    headers['Content-Length'].should == body.length.to_s
+    ''.should == body
+  end
+
+  it "should process cookie from QUERY_STRING if it is a sync protocol URI, for old REST routes" do
+    env = {
+        'PATH_INFO' => PROPER_URI_OLD,
+        'QUERY_STRING' => PROPER_QUERY_STRING
+    }
+    status, headers, body = @middleware_old_routes.call(env)
+    200.should == status
+    COOKIE_ANOTHER_NV.should == headers['Set-Cookie']
+    env['HTTP_COOKIE'].should == COOKIE_VALUE
+    headers['Content-Length'].should == body.length.to_s
+    ''.should == body
+  end
+
+  it "shouldn't process cookie from QUERY_STRING if there is no appropriate parameter name or value, for new REST routes" do
+    env = {
+        'PATH_INFO' => PROPER_URI_NEW,
+        'QUERY_STRING' => WRONG_QUERY_STRING
+    }
+    status, headers, body = @middleware_new_routes.call(env)
+    200.should == status
+    COOKIE_ANOTHER_NV.should == headers['Set-Cookie']
+    env['HTTP_COOKIE'].should_not == COOKIE_VALUE
+    headers['Content-Length'].should == body.length.to_s
+    ''.should == body
+  end
+
+  it "shouldn't process cookie from QUERY_STRING if there is no appropriate parameter name or value, for old REST routes" do
+    env = {
+        'PATH_INFO' => PROPER_URI_OLD,
+        'QUERY_STRING' => WRONG_QUERY_STRING
+    }
+    status, headers, body = @middleware_old_routes.call(env)
+    200.should == status
+    COOKIE_ANOTHER_NV.should == headers['Set-Cookie']
+    env['HTTP_COOKIE'].should_not == COOKIE_VALUE
+    headers['Content-Length'].should == body.length.to_s
+    ''.should == body
+  end
+
+  it "should respond with cookie in a body if it is a login URI, for new REST routes" do
+    env = {
+        'PATH_INFO' => LOGIN_URI_NEW,
+        'QUERY_STRING' => PROPER_QUERY_STRING
+    }
+    status, headers, body = @middleware_new_routes.call(env)
+    200.should == status
+    headers['Set-Cookie'].should == COOKIE_ANOTHER_NV
+    env['HTTP_COOKIE'].should == COOKIE_VALUE
+    headers['Content-Length'].should == body.length.to_s
+    ''.should_not == body
+  end
+
+  it "should respond with cookie in a body if it is a login URI, for old REST routes" do
+    env = {
+        'PATH_INFO' => LOGIN_URI_OLD,
+        'QUERY_STRING' => PROPER_QUERY_STRING
+    }
+    status, headers, body = @middleware_old_routes.call(env)
+    200.should == status
+    headers['Set-Cookie'].should == COOKIE_ANOTHER_NV
+    env['HTTP_COOKIE'].should == COOKIE_VALUE
+    headers['Content-Length'].should == body.length.to_s
+    ''.should_not == body
+  end
+=end
+end