wurfl_cloud_client_light 1.0.0

data/spec/wurfl_cloud/configuration_spec.rb

@@ -0,0 +1,111 @@
+#
+# This software is the Copyright of ScientiaMobile, Inc. 
+# Please refer to the LICENSE.txt file distributed with the software for licensing information
+#
+require 'spec_helper'
+describe WurflCloud::Configuration do
+  after(:all) do
+    WurflCloud.configuration = WurflCloud::Configuration.new
+  end
+  
+  it "should give a new instance if non defined" do
+    WurflCloud.configuration = nil
+    WurflCloud.configuration.should be_a(WurflCloud::Configuration)
+  end
+  
+  context "the configure method" do
+    it "should yield an instance of the configuration" do
+      WurflCloud.configure do |config|
+        config.should be_a(WurflCloud::Configuration)
+      end
+    end
+
+    it "should allow writing of the configuration" do
+      str = String.random
+      WurflCloud.configure do |config|
+        config.host = str
+      end
+      WurflCloud.configuration.host.should ==str
+    end
+  end
+  
+  {
+    :host => 'api.wurflcloud.com',
+    :path => '/v1/json',
+    :port => 80,
+    :schema => 'http',
+    :api_type => 'http',
+    :search_parameter => 'search:(%{capabilities})',
+    :search_parameter_separator => ',',
+    :cache_class => WurflCloud::Cache::Null,
+    :cache_options => {}
+  }.each do |key, value|
+    
+    it "should have the right default for #{key}" do
+      subject.send(key).should ==value
+    end
+    
+    it "should allow overriding default of #{key}" do 
+      v = String.random
+      subject.send(:"#{key}=", v)
+      subject.send(key).should ==v
+    end  
+     
+  end
+    
+  it "should return the correct api_uri" do
+    c = WurflCloud.configuration
+    c.schema = String.random
+    c.host = String.random
+    c.path = String.random
+    c.port = String.random
+    c.api_uri.should == "#{c.schema}://#{c.host}:#{c.port}#{c.path}"
+  end
+  
+  context "the cache method" do
+
+    it "should return a @cache_class object " do
+      subject.cache(Object.new).should be_a(subject.cache_class)
+    end
+    
+    it "should call the initialize method of the cache class " do
+      env = Object.new
+      subject.cache_class.should_receive(:new).with(subject.cache_options, env)
+      cache = subject.cache(env)
+    end
+    
+  end
+  context "the api_key method" do
+    
+    it "should have the right default" do
+      subject.api_key.should =='100000:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
+    end
+
+    it "should allow overriding the default" do 
+      u = 100000+rand(99999)
+      p = String.az_random(32)
+      subject.api_key = "#{u}:#{p}"
+      subject.api_key.should =="#{u}:#{p}"
+    end  
+
+    it "should throw an exception if called with a key with the worng format" do
+      expect { subject.api_key = "a wrong api key" }.to raise_error(WurflCloud::Errors::ConfigurationError)
+    end
+    
+    it "should have set the api_user value" do
+      u = 100000+rand(99999)
+      p = String.az_random(32)
+      subject.api_key = "#{u}:#{p}"
+      subject.api_user.should ==u
+    end
+    
+    it "should set the api_password value" do
+      u = 100000+rand(99999)
+      p = String.az_random(32)
+      subject.api_key = "#{u}:#{p}"
+      subject.api_password.should ==p
+    end
+    
+  end
+end
+

data/spec/wurfl_cloud/cookie_cache_spec.rb

@@ -0,0 +1,44 @@
+#
+# This software is the Copyright of ScientiaMobile, Inc. 
+# Please refer to the LICENSE.txt file distributed with the software for licensing information
+#
+require 'spec_helper'
+describe WurflCloud::Cache::Cookie do
+  subject { WurflCloud::Cache::Cookie.new({}, {}) }
+  
+  context "the object" do    
+    it { should respond_to(:[]).with(1).argument }
+    it { should respond_to(:[]=).with(2).arguments }
+    it { should respond_to(:mtime).with(0).arguments }
+    it { should respond_to(:mtime=).with(1).argument }
+    
+    it "should not throw errors calling []=" do
+      expect { subject[String.random] = String.random }.to_not raise_error
+    end
+
+    it "should store values" do
+      key = String.random
+      subject[key] = String.random
+      subject[key].should_not be_nil
+    end
+    
+  end
+  
+  context "for the environment" do
+    before(:each) do
+      @env = Hash.new
+      @cache = WurflCloud::Cache::Cookie.new({}, @env)
+    end
+    
+    it "should read the value from the wurfl.cookie.device_cache env variable" do
+      @env['wurfl.cookie.device_cache'] = String.random
+      @cache[String.random].should ==@env['wurfl.cookie.device_cache']
+    end
+
+    it "should set the value into the wurfl.cookie.device_cache env variable" do
+      value = String.random
+      @cache[String.random] = value
+      @env['wurfl.cookie.device_cache'].should ==value
+    end
+  end
+end

data/spec/wurfl_cloud/device_capabilities_spec.rb

@@ -0,0 +1,136 @@
+#
+# This software is the Copyright of ScientiaMobile, Inc. 
+# Please refer to the LICENSE.txt file distributed with the software for licensing information
+#
+require 'spec_helper'
+describe WurflCloud::DeviceCapabilities do
+  
+  context "the object" do    
+    it { should respond_to(:[]).with(1).argument }
+    it { should respond_to(:[]=).with(2).arguments }
+    it { should respond_to(:has_key?).with(1).argument }
+    it { should respond_to(:merge).with(1).argument }
+    it { should respond_to(:empty?).with(0).arguments }
+    it { should respond_to(:mtime).with(0).arguments }
+    it { should respond_to(:id).with(0).arguments }
+    it { should respond_to(:user_agent).with(0).arguments }
+    
+    it "should store a value by key" do
+      key = String.random
+      val = String.random
+      subject[key] = val
+      subject[key].should ==val 
+    end
+
+    it "should return true from has_key? if the key is set" do
+      key = String.random
+      subject[key] = nil
+      subject.has_key?(key).should be_true 
+    end
+    
+    context "when merging" do
+      before(:each) do
+        subject = WurflCloud::DeviceCapabilities.new
+        @old_key = String.random
+        @old_val = String.random
+        subject[@old_key] = @old_val
+
+        @new_key = String.random
+        @new_val = String.random
+      end
+
+      
+      context "another DeviceCapabilities object" do
+        it "should store a value when merged" do
+          subject_2 = WurflCloud::DeviceCapabilities.new
+          subject_2[@new_key] = @new_val
+          subject.merge(subject_2)
+          subject[@new_key].should ==@new_val 
+        end
+
+        it "should overwrite a value when merged" do
+          subject_2 = WurflCloud::DeviceCapabilities.new
+          subject_2[@old_key] = @new_val
+          subject.merge(subject_2)
+          subject[@old_key].should ==@new_val 
+        end
+      end
+      
+    end
+    
+    context "the empty? method" do
+      it "should return true if there are no capabilities defined" do
+        WurflCloud::DeviceCapabilities.new.empty?.should be_true
+      end
+      
+      it "should return false if there are capabilities defined" do
+        subject[String.random] = String.random
+        subject.empty?.should be_false
+      end
+    end
+  end
+  
+  context "the parse class method" do
+    subject { WurflCloud::DeviceCapabilities }
+    
+    before(:each) do
+      @generic_filtered_json = File.new("#{File.dirname(__FILE__)}/../files/generic_filtered.json").read
+    end
+    it "should exist" do
+      WurflCloud::DeviceCapabilities.should respond_to(:parse).with(1).argument
+    end
+    
+    it "shuould return a DeviceCapabilities object" do
+      WurflCloud::DeviceCapabilities.parse(@generic_filtered_json).should be_a(WurflCloud::DeviceCapabilities)
+    end
+    
+    context "the parse result" do
+      before(:each) do 
+        @parsed = WurflCloud::DeviceCapabilities.parse(@generic_filtered_json)
+      end
+      { "is_wireless_device"=>false,
+        "browser_id"=>"browser_root",
+        "fall_back"=>"root",
+        "user_agent"=>"",
+        "device_os_version"=>10.5,
+        "resolution_width"=>800
+      }.each do |key, value|
+        it "should populate the DeviceCapabilities key #{key}  with the value #{value.to_s.empty? ? "''" : value} from the json pased in" do
+          @parsed[key].should ==value
+        end
+      end
+      
+      it "should have the mtime set to a Time object" do
+        @parsed.mtime.should ==Time.at(1330016154)
+      end
+      
+      it "should return the correct wurfl id calling its is method" do
+        @parsed.id.should =="generic"
+      end
+    end
+    
+    context "parsing capabilities with boolean and numeric casted to strings" do
+      before(:each) do 
+        @parsed = WurflCloud::DeviceCapabilities.parse(File.new("#{File.dirname(__FILE__)}/../files/strange_values.json").read)
+      end
+      { "is_tablet"=>false,
+        "is_wireless_device"=>true,
+        "resolution_width"=>800,
+        "release_date"=>"1994_january"
+      }.each do |key, value|
+        it "should populate the DeviceCapabilities key #{key}  with the correct value #{value.to_s.empty? ? "''" : value} from the json pased in" do
+          @parsed[key].should ==value
+        end
+      end
+    end
+
+    it "should be empty if no capabilities defined in the json" do 
+      @parsed = WurflCloud::DeviceCapabilities.parse(%{{"apiVersion":"WurflCloud 1.3.2","mtime":1330016154,"id":"generic","capabilities":{},"errors":{}}})
+    end
+    
+    it "should raise and error if the json is not in the correct format" do
+      expect { WurflCloud::DeviceCapabilities.parse(%{}) }.to raise_error(WurflCloud::Errors::MalformedResponseError)
+    end
+    
+  end
+end

data/spec/wurfl_cloud/environment_spec.rb

@@ -0,0 +1,86 @@
+#
+# This software is the Copyright of ScientiaMobile, Inc. 
+# Please refer to the LICENSE.txt file distributed with the software for licensing information
+#
+require 'spec_helper'
+describe WurflCloud::Environment do
+
+  context "the class" do  
+    it "should respond to new with 1 argument" do
+      WurflCloud::Environment.should respond_to(:new).with(1).argument
+    end
+  end
+  
+  context "the object" do
+    [
+      :user_agent,
+      :x_forwarded_for,
+      :x_accept,
+      :x_wap_profile
+    ].each do |header|
+      it { should respond_to(header) }
+      it "should return nil if not set in the constructor" do
+        subject.send(header).should be_nil
+      end
+    end
+    
+    context "the user_agent" do
+      [
+        'HTTP_X_DEVICE_USER_AGENT',
+    		'HTTP_X_ORIGINAL_USER_AGENT',
+    		'HTTP_X_OPERAMINI_PHONE_UA',
+    		'HTTP_X_SKYFIRE_PHONE',
+    		'HTTP_X_BOLT_PHONE_UA',
+    		'HTTP_USER_AGENT'
+  		].each do |user_agent_param|
+        it "should be read from #{user_agent_param} " do
+          env = {user_agent_param=>String.random}
+          WurflCloud::Environment.new(env).user_agent.should ==env[user_agent_param]
+        end
+  		end
+
+    end
+
+    context "the x_accept" do
+      it "should be read from HTTP_ACCEPT " do
+        env = {"HTTP_ACCEPT"=>String.random}
+        WurflCloud::Environment.new(env).x_accept.should ==env["HTTP_ACCEPT"]
+      end
+    end
+
+    context "the x_wap_profile" do
+      it "should be read from HTTP_X_WAP_PROFILE if present and HTTP_PROFILE is null" do
+        env = {"HTTP_X_WAP_PROFILE"=>String.random}
+        WurflCloud::Environment.new(env).x_wap_profile.should ==env["HTTP_X_WAP_PROFILE"]
+      end
+
+      it "should be read from HTTP_X_WAP_PROFILE if present and HTTP_PROFILE is present" do
+        env = {"HTTP_X_WAP_PROFILE"=>String.random, "HTTP_PROFILE"=>String.random}
+        WurflCloud::Environment.new(env).x_wap_profile.should ==env["HTTP_X_WAP_PROFILE"]
+      end
+      
+      it "should be read from HTTP_PROFILE if present and HTTP_X_WAP_PROFILE is nil" do
+        env = {"HTTP_PROFILE"=>String.random}
+        WurflCloud::Environment.new(env).x_wap_profile.should ==env["HTTP_PROFILE"]
+      end
+    end
+
+    context "the x_forwarded_for" do
+      it "should be the REMOTE_ADDR if present and HTTP_X_FORWARDED_FOR is absent" do
+        env = {"REMOTE_ADDR"=>String.random}
+        WurflCloud::Environment.new(env).x_forwarded_for.should ==env["REMOTE_ADDR"]
+      end
+      
+      it "should be the REMOTE_ADDR, HTTP_X_FORWARDED_FOR if both are present" do
+        env = {"REMOTE_ADDR"=>String.random, "HTTP_X_FORWARDED_FOR"=>String.random}
+        WurflCloud::Environment.new(env).x_forwarded_for.should =="#{env["REMOTE_ADDR"]}, #{env["HTTP_X_FORWARDED_FOR"]}"
+      end
+      
+      it "should be nil if REMOTE_ADDR and HTTP_X_FORWARDED_FOR is present" do
+        env = {"HTTP_X_FORWARDED_FOR"=>String.random}
+        WurflCloud::Environment.new(env).x_forwarded_for.should be_nil
+      end
+    end
+    
+  end
+end

data/spec/wurfl_cloud/helper_spec.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+#
+# This software is the Copyright of ScientiaMobile, Inc. 
+# Please refer to the LICENSE.txt file distributed with the software for licensing information
+#
+require 'spec_helper'
+require 'wurfl_cloud/helper'
+
+describe WurflCloud::Helper do
+  include WurflCloud::Helper
+  
+  context "the wurfl_detect_device method" do
+
+    it "should return a WurflCloud::Client object" do
+      
+      cookie = {'date_set' => Time.now.to_i, 'capabilities' => {'name'=>'example'}}
+      env = env_with_params("/", {}, {"HTTP_USER_AGENT"=>String.random, "HTTP_COOKIE" => "#{WurflCloud::Rack::CacheManager::COOKIE_NAME}=#{::Rack::Utils.escape(cookie.to_json)}"})
+      
+      @device_data = File.new("#{File.dirname(__FILE__)}/../files/generic.json").read
+      stub_request(:any, authenticated_uri).to_return(:status=>200, :body => @device_data)
+
+      @wurfl_device = wurfl_detect_device(env)     
+      @wurfl_device.should be_instance_of(WurflCloud::Client)
+
+    end
+  end
+
+end

data/spec/wurfl_cloud/null_cache_spec.rb

@@ -0,0 +1,30 @@
+#
+# This software is the Copyright of ScientiaMobile, Inc. 
+# Please refer to the LICENSE.txt file distributed with the software for licensing information
+#
+require 'spec_helper'
+describe WurflCloud::Cache::Null do
+  subject { WurflCloud::Cache::Null.new({}, Object.new) }
+  
+  context "the object" do    
+    it { should respond_to(:[]).with(1).argument }
+    it { should respond_to(:[]=).with(2).arguments }
+    it { should respond_to(:mtime).with(0).arguments }
+    it { should respond_to(:mtime=).with(1).argument }
+    
+    it "should not throw errors calling []=" do
+      expect { subject[String.random] = String.random }.to_not raise_error
+    end
+
+    it "should not store values" do
+      key = String.random
+      subject[key] = String.random
+      subject[key].should be_nil
+    end
+    
+    it "should not store the mtime" do
+      subject.mtime = rand
+      subject.mtime.should be_nil
+    end
+  end
+end

data/spec/wurfl_cloud/rack_cache_manager_spec.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+#
+# This software is the Copyright of ScientiaMobile, Inc. 
+# Please refer to the LICENSE.txt file distributed with the software for licensing information
+#
+require 'spec_helper'
+
+describe WurflCloud::Rack::CacheManager do
+
+  context "the wurfl.cookie.device_cache env parameter" do
+        
+    it "should be inserted if the cookie exists" do
+      cookie = {'date_set' => Time.now.to_i, 'capabilities' => {'name'=>'example'}}
+      env = env_with_params("/", {}, {"HTTP_COOKIE" => "#{WurflCloud::Rack::CacheManager::COOKIE_NAME}=#{::Rack::Utils.escape(cookie.to_json)}"})
+      setup_rack(success_app).call(env)
+      env["wurfl.cookie.device_cache"].should_not be_nil
+    end
+
+    it "should be decoded from json" do
+      cookie = {'date_set' => Time.now.to_i, 'capabilities' => {'name'=>'example'}}
+      env = env_with_params("/", {}, {"HTTP_COOKIE" => "#{WurflCloud::Rack::CacheManager::COOKIE_NAME}=#{::Rack::Utils.escape(cookie.to_json)}"})
+      setup_rack(success_app).call(env)
+      env["wurfl.cookie.device_cache"].should =={'name'=>'example'}
+    end
+
+    it "should be nil if it doesn't exist" do
+      env = env_with_params("/", {}, {})
+      setup_rack(success_app).call(env)
+      env["wurfl.cookie.device_cache"].should be_nil
+    end
+
+    it "should be nil if not a valid json object" do
+      cookie = {}
+      env = env_with_params("/", {}, {"HTTP_COOKIE" => "#{WurflCloud::Rack::CacheManager::COOKIE_NAME}=#{::Rack::Utils.escape("{}")}"})
+      setup_rack(success_app).call(env)
+      env["wurfl.cookie.device_cache"].should be_nil
+    end
+    
+    it "should be nil if it lacks the date_set field" do
+      cookie = {'capabilities' => {}}
+      env = env_with_params("/", {}, {"HTTP_COOKIE" => "#{WurflCloud::Rack::CacheManager::COOKIE_NAME}=#{::Rack::Utils.escape(cookie.to_json)}"})
+      setup_rack(success_app).call(env)
+      env["wurfl.cookie.device_cache"].should be_nil
+    end
+
+    it "should be nil if it lacks the capabilities field" do
+      cookie = {'date_set' => Time.now.to_i}
+      env = env_with_params("/", {}, {"HTTP_COOKIE" => "#{WurflCloud::Rack::CacheManager::COOKIE_NAME}=#{::Rack::Utils.escape(cookie.to_json)}"})
+      setup_rack(success_app).call(env)
+      env["wurfl.cookie.device_cache"].should be_nil
+    end
+
+    it "should be nil if the capabilities field is empty" do
+      cookie = {'date_set' => (Time.now-WurflCloud::Rack::CacheManager::EXPIRY-1).to_i, 'capabilities' => {}}
+      env = env_with_params("/", {}, {"HTTP_COOKIE" => "#{WurflCloud::Rack::CacheManager::COOKIE_NAME}=#{::Rack::Utils.escape(cookie.to_json)}"})
+      setup_rack(success_app).call(env)
+      env["wurfl.cookie.device_cache"].should be_nil
+    end
+
+    it "should be nil if the cookie was expired" do
+      cookie = {'date_set' => (Time.now-WurflCloud::Rack::CacheManager::EXPIRY-1).to_i, 'capabilities' => {'name'=>'example'}}
+      env = env_with_params("/", {}, {"HTTP_COOKIE" => "#{WurflCloud::Rack::CacheManager::COOKIE_NAME}=#{::Rack::Utils.escape(cookie.to_json)}"})
+      setup_rack(success_app).call(env)
+      env["wurfl.cookie.device_cache"].should be_nil
+    end
+
+  end
+
+end