wurfl_cloud_client 1.0.1

data/spec/support/string_extensions.rb

@@ -0,0 +1,33 @@
+#
+# Copyright (c) 2015 ScientiaMobile Inc.
+#
+# The WURFL Cloud Client is intended to be used in both open-source and
+# commercial environments. To allow its use in as many situations as possible,
+# the WURFL Cloud Client is dual-licensed. You may choose to use the WURFL
+# Cloud Client under either the GNU GENERAL PUBLIC LICENSE, Version 2.0, or
+# the MIT License.
+#
+# Refer to the COPYING.txt file distributed with this package.
+#
+class String
+  class << self
+    def random(length=20)
+      self.generic_random(length, ("0".."z"))
+    end
+    def az_random(length=20)
+      self.generic_random(length, ("a".."z"))
+    end  
+    def aznum_random(length=20)
+      self.generic_random(length, ("a".."z").to_a + ("0".."9").to_a)
+    end  
+    def az_random_with_num(length=20, num_lenght=20)
+      self.generic_random(length, ("a".."z").to_a)+self.generic_random(length, ("0".."9").to_a)
+    end  
+    def generic_random(length,char_range)
+      chars = char_range.to_a
+      Array.new.tap do |a|
+        1.upto(length) { |i| a << chars[rand(chars.size-1)]}
+      end.join
+    end
+  end
+end

data/spec/wurfl_cloud/client_spec.rb

@@ -0,0 +1,207 @@
+#
+# Copyright (c) 2015 ScientiaMobile Inc.
+#
+# The WURFL Cloud Client is intended to be used in both open-source and
+# commercial environments. To allow its use in as many situations as possible,
+# the WURFL Cloud Client is dual-licensed. You may choose to use the WURFL
+# Cloud Client under either the GNU GENERAL PUBLIC LICENSE, Version 2.0, or
+# the MIT License.
+#
+# Refer to the COPYING.txt file distributed with this package.
+#
+require 'spec_helper'
+require 'wurfl_cloud/cache/local_memory'
+
+describe WurflCloud::Client do
+  subject { WurflCloud::Client.new(WurflCloud::Environment.new, nil) }
+  
+  it "should contain a device_capabilities object" do
+    subject.device_capabilities.should be_instance_of(WurflCloud::DeviceCapabilities)
+  end
+  
+  it "should delegate the [] method to the device_capabilities object" do
+    capability_name = String.random
+    subject.device_capabilities.should_receive(:[]).with(capability_name)
+    subject[capability_name]
+  end
+
+  it "should have a read_from_cache method" do
+    subject.should respond_to(:read_from_cache)
+  end
+  
+  context "the detect_device method" do
+    it "should be defined with 2 parameters" do
+      WurflCloud::Client.should respond_to(:detect_device).with(2).arguments
+    end
+    
+  end
+  
+  context "when using with the default null cache" do
+    before(:each) do
+      @http_env = {
+        "HTTP_USER_AGENT"=>String.random,
+        "HTTP_ACCEPT"=>String.random,
+        "HTTP_X_WAP_PROFILE"=>String.random,
+        "REMOTE_ADDR"=>String.random
+      }
+      @environment = WurflCloud::Environment.new(@http_env)
+      @cache = WurflCloud.configuration.cache(nil)
+      
+      @device_data = File.new("#{File.dirname(__FILE__)}/../files/generic.json").read
+
+      stub_request(:any, authenticated_uri).to_return(:status=>200, :body => @device_data)
+      
+      @wurfl_client = WurflCloud::Client.detect_device(@environment, @cache)
+      
+    end
+    
+    it "should validate the cache when loading from server" do
+      @cache.should_receive(:validate).with(1330016154)
+      @wurfl_client.load_from_server!
+    end
+
+    it "should return an instance of the client class" do
+      @wurfl_client.should be_instance_of(WurflCloud::Client)
+    end
+
+    it "should call the remote webservice" do
+      WebMock.should have_requested(:get, authenticated_uri)
+    end
+
+    it "should call the remote webservice each time detect_device is called" do
+      WurflCloud::Client.detect_device(@environment, @cache)
+      WebMock.should have_requested(:get, authenticated_uri).times(2)
+    end
+    
+    
+    it "should pass the correct headers" do
+      headers = {
+        'User-Agent' => @http_env["HTTP_USER_AGENT"],
+        'X-Cloud-Client' => "WurflCloudClient/Ruby_#{WurflCloud::VERSION}",
+        'X-Forwarded-For' => @http_env["REMOTE_ADDR"],
+        'X-Accept' => @http_env["HTTP_ACCEPT"],
+        'X-Wap-Profile' => @http_env["HTTP_X_WAP_PROFILE"],
+      }
+      stub_request(:any, authenticated_uri).with(:headers=>headers).to_return(:status=>200, :body => @device_data)
+      WurflCloud::Client.detect_device(@environment, @cache)
+    end
+    
+    { "is_wireless_device"=>false,
+      "browser_id"=>"browser_root",
+      "fall_back"=>"root",
+      "user_agent"=>"",
+      "resolution_width"=>90
+    }.each do |key, value|
+      it "should return the right values for the capability #{key}" do
+        @wurfl_client[key].should ==value
+      end
+      it "should not call the webservice to read a capability that's present in the answer" do
+        value = @wurfl_client[key]
+        WebMock.should have_requested(:get, authenticated_uri).times(1)
+      end
+    end
+    
+  end
+
+  context "when using with a simple local memory cache" do
+    
+    before(:each) do
+      @http_env = {
+        "HTTP_USER_AGENT"=>String.random,
+        "HTTP_ACCEPT"=>String.random,
+        "HTTP_X_WAP_PROFILE"=>String.random,
+        "REMOTE_ADDR"=>String.random
+      }
+      @environment = WurflCloud::Environment.new(@http_env)
+      @cache = WurflCloud::Cache::LocalMemory.new
+      
+      @device_data = File.new("#{File.dirname(__FILE__)}/../files/generic.json").read
+      
+      stub_request(:any, authenticated_uri).to_return(:status=>200, :body => @device_data)
+      @wurfl_client = WurflCloud::Client.detect_device(@environment, @cache)
+    end
+    
+
+    it "should call the remote webservice once if the same agent is detected twice" do
+      WurflCloud::Client.detect_device(@environment, @cache)
+      WebMock.should have_requested(:get, authenticated_uri).times(1)
+    end
+    
+    context "requesting a non existent capability" do
+      context "just after the capabilities have been read from the server" do
+        it "should not call again the webservice" do
+          value = @wurfl_client['my_non_existent_capability']
+          WebMock.should have_requested(:get, authenticated_uri).times(1)
+        end
+        it "should return nil" do
+          @wurfl_client['my_non_existent_capability'].should be_nil
+        end
+      end
+      
+      context "detecting the device from the cache" do
+        before(:each) do
+          @wurfl_client = WurflCloud::Client.detect_device(@environment, @cache)
+        end
+        
+        it "should call again the webservice" do
+          value = @wurfl_client['my_non_existent_capability']
+          WebMock.should have_requested(:get, authenticated_uri).times(2)
+        end
+        
+        it "should return nil if it doesn't exist" do
+          @wurfl_client['my_non_existent_capability'].should be_nil
+        end
+
+        it "should return the right value if exists" do
+          stub_request(:any, authenticated_uri).to_return(:status=>200, :body => %{{"apiVersion":"WurflCloud 1.3.2","mtime":1330016154,"id":"generic","capabilities":{"my_non_existent_capability":"OK"},"errors":{}}})
+          @wurfl_client['my_non_existent_capability'].should =="OK"
+        end        
+
+        it "should call the webservice only once for each access to the capability value" do
+          stub_request(:any, authenticated_uri).to_return(:status=>200, :body => %{{"apiVersion":"WurflCloud 1.3.2","mtime":1330016154,"id":"generic","capabilities":{"my_non_existent_capability":"OK"},"errors":{}}})
+          value = @wurfl_client['my_non_existent_capability']
+          value = @wurfl_client['my_non_existent_capability']
+          WebMock.should have_requested(:get, authenticated_uri).times(2)
+        end        
+      end
+    end
+  end
+
+  context "when the webservice has errors" do
+    before(:each) do
+      @http_env = {
+        "HTTP_USER_AGENT"=>String.random,
+        "HTTP_ACCEPT"=>String.random,
+        "HTTP_X_WAP_PROFILE"=>String.random,
+        "REMOTE_ADDR"=>String.random
+      }
+      @environment = WurflCloud::Environment.new(@http_env)
+      @cache = WurflCloud.configuration.cache(nil)
+      
+      @device_data = File.new("#{File.dirname(__FILE__)}/../files/generic.json").read
+    end
+    
+    it "should raise WurflCloud::Errors::ConnectionError if there are connection timeouts" do
+      stub_request(:any, authenticated_uri).to_timeout
+  
+      expect { WurflCloud::Client.detect_device(@environment, @cache) }.to raise_error(WurflCloud::Errors::ConnectionError)
+    end
+    it "should raise WurflCloud::Errors::ConnectionError if there are connection errors" do
+      stub_request(:any, authenticated_uri).to_raise("some error")
+  
+      expect { WurflCloud::Client.detect_device(@environment, @cache) }.to raise_error(WurflCloud::Errors::ConnectionError)    
+    end
+    it "should raise WurflCloud::Errors::ConnectionError if there are server errors" do
+      stub_request(:any, authenticated_uri).to_return(:status=>500)
+  
+      expect { WurflCloud::Client.detect_device(@environment, @cache) }.to raise_error(WurflCloud::Errors::ConnectionError)
+    end
+    it "should raise WurflCloud::Errors::MalformedResponseError if there are unparsable responses" do
+      stub_request(:any, authenticated_uri).to_return(:status=>200, :body => %{badjson})       
+  
+      expect { WurflCloud::Client.detect_device(@environment, @cache) }.to raise_error(WurflCloud::Errors::MalformedResponseError)
+    end
+  
+  end
+
+end

data/spec/wurfl_cloud/configuration_spec.rb

@@ -0,0 +1,118 @@
+#
+# Copyright (c) 2015 ScientiaMobile Inc.
+#
+# The WURFL Cloud Client is intended to be used in both open-source and
+# commercial environments. To allow its use in as many situations as possible,
+# the WURFL Cloud Client is dual-licensed. You may choose to use the WURFL
+# Cloud Client under either the GNU GENERAL PUBLIC LICENSE, Version 2.0, or
+# the MIT License.
+#
+# Refer to the COPYING.txt file distributed with this package.
+#
+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,51 @@
+#
+# Copyright (c) 2015 ScientiaMobile Inc.
+#
+# The WURFL Cloud Client is intended to be used in both open-source and
+# commercial environments. To allow its use in as many situations as possible,
+# the WURFL Cloud Client is dual-licensed. You may choose to use the WURFL
+# Cloud Client under either the GNU GENERAL PUBLIC LICENSE, Version 2.0, or
+# the MIT License.
+#
+# Refer to the COPYING.txt file distributed with this package.
+#
+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,143 @@
+#
+# Copyright (c) 2015 ScientiaMobile Inc.
+#
+# The WURFL Cloud Client is intended to be used in both open-source and
+# commercial environments. To allow its use in as many situations as possible,
+# the WURFL Cloud Client is dual-licensed. You may choose to use the WURFL
+# Cloud Client under either the GNU GENERAL PUBLIC LICENSE, Version 2.0, or
+# the MIT License.
+#
+# Refer to the COPYING.txt file distributed with this package.
+#
+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