7digital 0.0.2 → 0.0.5

data/spec/api_operator_spec.rb

@@ -1,5 +1,6 @@
-require File.join(File.dirname(__FILE__), %w[spec_helper])
+require "spec_helper"
 require 'ostruct'
+require 'oauth'
 
 describe "ApiOperator" do
 
@@ -17,7 +18,7 @@ describe "ApiOperator" do
 
   end
 
-  it "should create request URI based on api method and client configuration" do
+  it "should create http request uri based on api method and client configuration" do
 
     api_request = Sevendigital::ApiRequest.new("api/method", {:param1 => "value", :paramTwo => 2})
 
@@ -25,26 +26,134 @@ describe "ApiOperator" do
 
     uri.kind_of?(URI).should == true
 
-    uri.to_s.should =~ /http:\/\/base.api.url\/version\/api\/method\?oauth_consumer_key=oauth_consumer_key/
-    uri.to_s.should =~ /\&param1=value/
-    uri.to_s.should =~ /\&paramTwo=2/
+    uri.to_s.should =~ /http:\/\/base.api.url\/version\/api\/method/
+    uri.to_s.should =~ /[\?\&]param1=value/
+    uri.to_s.should =~ /[\?\&]paramTwo=2/
 
   end
 
-  it "should make sure country is set before making request" do
-    @client.stub!(:country).and_return("sk")
+  it "should URL encode parameters accourding to OAuth spec" do
 
-    @stub_api_request.should_receive(:ensure_country_is_set).with("sk")
-    
-    @api_operator.call_api(@stub_api_request)
+    api_request = Sevendigital::ApiRequest.new("api/method", {:param1 => "a+b@c.d", :paramTwo => "<a b>"})
+
+    uri = @api_operator.create_request_uri(api_request)
+
+    uri.to_s.should =~ /[\?\&]param1=a%2Bb%40c.d/
+    uri.to_s.should =~ /[\?\&]paramTwo=%3Ca%20b%3E/
 
   end
 
-  it "should make HTTP request and get response" do
+  it "should create http GET request by default" do
 
-    Net::HTTP.should_receive(:get_response).with(@api_operator.create_request_uri(@stub_api_request))
+    api_request = Sevendigital::ApiRequest.new("api/method", {:param1 => "value", :paramTwo => 2})
+
+    client, request = @api_operator.create_http_request(api_request)
 
-    @api_operator.call_api(@stub_api_request)
+    request.class.should == Net::HTTP::Get
+
+  end
+
+  it "should create http POST request" do
+
+    api_request = Sevendigital::ApiRequest.new("api/method", {:param1 => "value", :paramTwo => 2})
+    api_request.http_method = :POST
+
+    client, request = @api_operator.create_http_request(api_request)
+
+    request.class.should == Net::HTTP::Post
+
+  end
+
+  it "should create http DELETE request" do
+
+    api_request = Sevendigital::ApiRequest.new("api/method", {:param1 => "value", :paramTwo => 2})
+    api_request.http_method = :DELETE
+
+    client, request = @api_operator.create_http_request(api_request)
+
+    request.class.should == Net::HTTP::Delete
+
+  end
+
+  it "should create http PUT request" do
+
+    api_request = Sevendigital::ApiRequest.new("api/method", {:param1 => "value", :paramTwo => 2})
+    api_request.http_method = :PUT
+
+    client, request = @api_operator.create_http_request(api_request)
+
+    request.class.should == Net::HTTP::Put
+
+  end
+
+  it "should have empty body if no form parameters provided" do
+
+    api_request = Sevendigital::ApiRequest.new("api/method", {:param1 => "value", :paramTwo => 2})
+
+    client, request = @api_operator.create_http_request(api_request)
+
+    request.instance_variable_get("@body").empty?.should == true
+
+  end
+
+  it "should set up any form parameters in body" do
+
+    api_request = Sevendigital::ApiRequest.new("api/method", {:param1 => "value", :paramTwo => 2})
+    api_request.form_parameters[:shop_id] = "1234"
+    api_request.form_parameters[:email] = "test@example.com"
+    api_request.form_parameters[:ignore] = nil
+
+    client, request = @api_operator.create_http_request(api_request)
+
+    request.instance_variable_get("@body").should == "shopId=1234&email=test%40example.com"
+
+  end
+
+  it "should create HTTPS request uri based on api method that requires secure connection and client configuration" do
+
+    api_request = Sevendigital::ApiRequest.new("api/method", {:param1 => "value", :paramTwo => 2})
+    api_request.require_secure_connection
+
+    uri = @api_operator.create_request_uri(api_request)
+
+    uri.kind_of?(URI).should == true
+
+    uri.to_s.should =~ /https:\/\/base.api.url\/version\/api\/method/
+    uri.to_s.should =~ /[\?\&]param1=value/
+    uri.to_s.should =~ /[\?\&]paramTwo=2/
+
+  end
+
+  it "should create http request uri based on api method for non standard api service" do
+
+    @client.should_receive(:api_host_and_version).with(:media).and_return(["media-base.api.url","media-version"])
+
+    api_request = Sevendigital::ApiRequest.new("api/method", {:param1 => "value", :paramTwo => 2})
+    api_request.api_service = :media
+    uri = @api_operator.create_request_uri(api_request)
+
+    uri.kind_of?(URI).should == true
+
+    uri.to_s.should =~ /http:\/\/media-base.api.url\/media-version\/api\/method/
+    uri.to_s.should =~ /[\?\&]param1=value/
+    uri.to_s.should =~ /[\?\&]paramTwo=2/
+
+  end
+
+  it "should make HTTP request and get http response" do
+
+    http_response = fake_api_response
+
+    @stub_http_request = stub(Net::HTTP::Get)
+    @stub_http_client =  stub(Net::HTTP)
+
+    @api_operator.should_receive(:create_http_request).with(@stub_api_request).and_return([@stub_http_client, @stub_http_request])
+
+    @stub_http_client.should_receive(:request).with(@stub_http_request).and_return(http_response)
+
+    response = @api_operator.make_http_request(@stub_api_request)
+
+    response.should == http_response
 
   end
 
@@ -53,7 +162,20 @@ describe "ApiOperator" do
     http_response = fake_api_response
     digested_response = fake_digested_response
 
-    Net::HTTP.stub!(:get_response).and_return(http_response)
+    @client.api_response_digestor.should_receive(:from_http_response).with(http_response).and_return(digested_response)
+
+    response = @api_operator.digest_http_response(http_response)
+
+    response.should == digested_response
+
+  end
+
+    it "should call API by making an http request and digesting the response" do
+
+    http_response = fake_api_response
+    digested_response = fake_digested_response
+
+    @api_operator.should_receive(:make_http_request).and_return(http_response)
 
     @client.api_response_digestor.should_receive(:from_http_response).with(http_response).and_return(digested_response)
 
@@ -65,20 +187,116 @@ describe "ApiOperator" do
 
   it "should throw an exception if response is not ok" do
 
-    Net::HTTP.stub(:get_response).and_return(fake_api_response)
     failed_response = fake_digested_response(false)
-    failed_response.stub!(:error_code).and_return("4000")
+    failed_response.stub!(:error_code).and_return(4000)
     failed_response.stub!(:error_message).and_return("error")
-      @client.api_response_digestor.stub!(:from_http_response).and_return(failed_response)
+    @api_operator.should_receive(:make_http_request).and_return(fake_api_response)
+    @client.api_response_digestor.stub!(:from_http_response).and_return(failed_response)
+    
+    running { @api_operator.call_api(@stub_api_request) }.should raise_error(Sevendigital::SevendigitalError) { |error|
+      error.error_code.should == 4000
+      error.error_message.should == "error"
+    }
+
+  end
 
-    running { @api_operator.call_api(@stub_api_request) }.should raise_error(Sevendigital::SevendigitalError)
+  it "should create a 2-legged signed HTTP request" do
+    api_request = Sevendigital::ApiRequest.new("api/method", {:param1 => "value", :paramTwo => 2})
+    api_request.require_signature
+    http_client, http_request = @api_operator.create_http_request(api_request)
+    http_client.use_ssl?.should == false
+    http_request.path.should =~ /api\/method/
+    http_request.path.should =~ /param1=value/
+    http_request["Authorization"].should =~ /OAuth oauth_consumer_key="oauth_consumer_key"/
+    http_request["Authorization"].should =~ / oauth_signature=/
+#   http_request["Authorization"].should !=~ / oauth_token="token"/
+  end
+
+  it "should create a 3-legged signed HTTP request" do
+    api_request = Sevendigital::ApiRequest.new("api/method", {:param1 => "value", :paramTwo => 2})
+    api_request.require_signature
+    api_request.token = OAuth::AccessToken.new(@client.oauth_consumer, "token", "secret")
+    http_client, http_request = @api_operator.create_http_request(api_request)
+    http_client.use_ssl?.should == false
+    http_request.path.should =~ /api\/method/
+    http_request.path.should =~ /param1=value/
+    http_request["Authorization"].should =~ /OAuth oauth_consumer_key="oauth_consumer_key"/
+    http_request["Authorization"].should =~ / oauth_signature=/
+    http_request["Authorization"].should =~ / oauth_token="token"/
+  end
+
+  it "should create a 3-legged signed HTTPS request" do
+    api_request = Sevendigital::ApiRequest.new("api/method", {:param1 => "value", :paramTwo => 2})
+    api_request.require_signature
+    api_request.require_secure_connection
+    api_request.token = OAuth::AccessToken.new(@client.oauth_consumer, "token", "secret")
+    http_client, http_request = @api_operator.create_http_request(api_request)
+    http_client.inspect.should =~ /base\.api\.url:443/
+    http_client.use_ssl?.should == true
+    http_client.verify_mode.should == OpenSSL::SSL::VERIFY_NONE
+    http_request.path.should =~ /api\/method/
+    http_request.path.should =~ /param1=value/
+    http_request["Authorization"].should =~ /OAuth oauth_consumer_key="oauth_consumer_key"/
+    http_request["Authorization"].should =~ / oauth_signature=/
+    http_request["Authorization"].should =~ / oauth_token="token"/
+  end
+
+  it "should create a standard HTTP request" do
+    api_request = Sevendigital::ApiRequest.new("api/method", {:param1 => "value", :paramTwo => 2})
+    http_client, http_request = @api_operator.create_http_request(api_request)
+    http_client.inspect.should =~ /base\.api\.url:80/
+    http_client.use_ssl?.should == false
+    http_request.path.should =~ /api\/method/
+    http_request.path.should =~ /param1=value/
+    http_request.path.should =~ /oauth_consumer_key=oauth_consumer_key/
+  end
+
+  it "should add custom user agent info to created HTTP request" do
+
+    @client.stub!(:user_agent_info).and_return("7digital Gem")
+
+    api_request = Sevendigital::ApiRequest.new("api/method", {:param1 => "value", :paramTwo => 2})
+    http_client, http_request = @api_operator.create_http_request(api_request)
+    http_request["User-agent"].should =~ /7digital Gem/
+  end
+
+  it "get_request_uri should return oauth sign URI if api request requires signature" do
+
+    api_request = Sevendigital::ApiRequest.new("api/method", {:param1 => "value", :paramTwo => 2})
+    api_request.token = OAuth::AccessToken.new(nil, "token", "token_secret")
+    api_request.require_signature
+    api_request.require_secure_connection
+    signed_uri =  @api_operator.get_request_uri(api_request)
+
+    signed_uri.should =~ /oauth_signature=/
+    signed_uri.should =~ /oauth_consumer_key=oauth_consumer_key&/
+    signed_uri.should =~ /oauth_token=token&/
+    signed_uri.should =~ /https:\/\/base.api.url\/version\/api\/method/
+  end
+
+  it "get_request_uri should return simple request URI if api request does not require signature" do
+
+    api_request = Sevendigital::ApiRequest.new("api/method", {:param1 => "value", :paramTwo => 2})
+    signed_uri =  @api_operator.get_request_uri(api_request)
+
+    signed_uri.match(/oauth_signature=/).should == nil
+    signed_uri.should =~ /oauth_consumer_key=oauth_consumer_key/
+    signed_uri.should =~ /http:\/\/base.api.url\/version\/api\/method/
+  end
+
+  it "get_request_uri should return secure request URI if api request does not require signature" do
+
+    api_request = Sevendigital::ApiRequest.new("api/method", {:param1 => "value", :paramTwo => 2})
+    api_request.require_secure_connection
+    signed_uri =  @api_operator.get_request_uri(api_request)
 
+    signed_uri.match(/oauth_signature=/).should == nil
+    signed_uri.should =~ /oauth_consumer_key=oauth_consumer_key/
+    signed_uri.should =~ /https:\/\/base.api.url\/version\/api\/method/
   end
 
   def test_configuration
     configuration = OpenStruct.new
-    configuration.api_url = "base.api.url"
-    configuration.api_version = "version"
     configuration.oauth_consumer_key = "oauth_consumer_key"
     return configuration
   end
@@ -96,10 +314,13 @@ describe "ApiOperator" do
   def stub_api_client(configuration, response_digestor)
   @client = stub(Sevendigital::Client)
   @client.stub!(:configuration).and_return(configuration)
+  @client.stub!(:oauth_consumer).and_return(OAuth::Consumer.new( configuration.oauth_consumer_key, configuration.oauth_consumer_secret))
   @client.stub!(:api_response_digestor).and_return(response_digestor)
-  @client.stub!(:country).and_return("sk")
+  @client.stub!(:default_parameters).and_return({:country => 'sk'})
+  @client.stub!(:user_agent_info).and_return("7digital")
   @client.stub!(:verbose?).and_return(false)
   @client.stub!(:very_verbose?).and_return(false)
+  @client.stub!(:api_host_and_version).and_return(["base.api.url","version"])
 
 end
 
@@ -107,7 +328,10 @@ def stub_api_request
   api_request = stub(Sevendigital::ApiRequest)
 
   api_request.stub!(:parameters).and_return({})
+  api_request.stub!(:api_service).and_return(nil)
   api_request.stub!(:api_method).and_return("m")
+  api_request.stub!(:requires_signature?).and_return(false)
+  api_request.stub!(:requires_secure_connection?).and_return(false)
   api_request.stub!(:ensure_country_is_set)
   return api_request
 end

data/spec/api_request_spec.rb

@@ -1,26 +1,31 @@
-require File.join(File.dirname(__FILE__), %w[spec_helper])
+require "spec_helper"
 
 describe "ApiRequest" do
 
-  it "should merge method parameters and options with parameters taking preference" do
+  it "should always provide selected parameters in 7digital API format" do
 
-    parameters = {:trackId => 123, :releaseId => 456, :country => "CU"}
-    options = {:page => 1, :country => "US",  :trackId => "SS"}
-    request = Sevendigital::ApiRequest.new('method', parameters, options)
-    request.parameters[:trackId].should == 123
-    request.parameters[:releaseId].should == 456
-    request.parameters[:country].should == "CU"
-    request.parameters[:page].should == 1
-    request.parameters.keys.size.should == 4 # page_size == null
+    request = Sevendigital::ApiRequest.new('method', {
+            :page => 5,
+            :per_page => 3,
+            :shop_id => 99,
+            :image_size => 999
+    })
+    request.parameters[:page].should == 5
+    request.parameters[:pageSize].should == 3
+    request.parameters[:per_page].should == nil
+    request.parameters[:shopId].should == 99
+    request.parameters[:shop_id].should == nil
+    request.parameters[:imageSize].should == 999
+    request.parameters[:image_size].should == nil
 
   end
 
-  it "should provide paging parameters in 7digital API format" do
+  it "should not contain nil parameters" do
 
-    request = Sevendigital::ApiRequest.new('method', {}, {:page => 5, :per_page => 3 })
-    request.parameters[:page].should == 5
-    request.parameters[:pageSize].should == 3
+    request = Sevendigital::ApiRequest.new('method', {:key1 => "value", :key2 => nil})
+    request.parameters[:key1].should == "value"
+    request.parameters.has_key?(:key2).should == false
 
-	end
+  end
 
 end

data/spec/client_configuration_spec.rb

@@ -0,0 +1,75 @@
+require "spec_helper"
+
+describe "ClientConfiguration" do
+
+  it "should initialize with default configuration" do
+    configuration = Sevendigital::ClientConfiguration.new
+    configuration.api_url.should == 'api.7digital.com'
+    configuration.api_version.should == '1.2'
+    configuration.media_api_url.should == 'media-eu.7digital.com'
+    configuration.media_api_version.should == 'media'
+    configuration.account_api_url.should == 'account.7digital.com'
+    configuration.account_api_version.should == 'web'
+  end
+
+  it "should initialize using hash" do
+    configuration = Sevendigital::ClientConfiguration.new(:api_url => "test-hash.7digital.com")
+    configuration.api_url.should == 'test-hash.7digital.com'
+  end
+
+  it "should initialize using OpenStruct object" do
+    configuration = Sevendigital::ClientConfiguration.new(OpenStruct.new(:api_url => "test-openstruct.7digital.com"))
+    configuration.api_url.should == 'test-openstruct.7digital.com'
+  end
+
+  it "should initialize using simple YAML file" do
+    configuration = Sevendigital::ClientConfiguration.new(File.join(File.dirname(__FILE__),"data", "configuration_override.yml"))
+    configuration.api_url.should == 'test-yml-simple.7digital.com'
+  end
+
+  it "should initialize mixing configuration file name and explicit hash override" do
+   conf_file = File.join(File.dirname(__FILE__),"data", "configuration_override.yml")
+   configuration = Sevendigital::ClientConfiguration.new(conf_file, :api_url => 'hash-override')
+   configuration.api_url.should == 'hash-override'
+   configuration.api_version.should == 'yml-simple'
+  end
+
+  it "should initialize mixing hash settings and configuration file override" do
+    conf_file = File.join(File.dirname(__FILE__),"data", "configuration_override.yml")
+    configuration = Sevendigital::ClientConfiguration.new({:api_url => 'hash-override', :xxx => 'yyy'}, conf_file)
+    configuration.api_url.should == 'test-yml-simple.7digital.com'
+    configuration.xxx.should == 'yyy'
+  end
+  
+  it "should initialize mixing 2 explicit hash overrides" do
+    configuration = Sevendigital::ClientConfiguration.new( {:api_url => 'v1', :a => 'x'}, {:api_url => 'v2', :b => 'y'})
+    configuration.api_url.should == 'v2'
+    configuration.a.should == 'x'
+    configuration.b.should == 'y'
+  end
+
+  it "should use environment specific configuration file" do
+    conf_file = File.join(File.dirname(__FILE__),"data", "configuration_env_override.yml")
+    configuration = Sevendigital::ClientConfiguration.new(conf_file)
+    configuration.api_url.should == 'test-yml-common.7digital.com'
+  end
+
+  it "should use environment specific configuration file with environment specific settings" do
+    conf_file = File.join(File.dirname(__FILE__),"data", "configuration_env_override.yml")
+    puts conf_file
+    Object.const_set(:RAILS_ENV, "development") 
+    configuration = Sevendigital::ClientConfiguration.new(conf_file)
+    configuration.api_url.should == 'test-yml-development.7digital.com'
+    Object.instance_eval{ remove_const :RAILS_ENV }
+  end
+
+  it "should use rails/config/sevendigital configuration as default rails settings" do
+    rails_root = File.join(File.dirname(__FILE__),"data")
+    puts rails_root
+    Object.const_set(:RAILS_ROOT, rails_root)
+    configuration = Sevendigital::ClientConfiguration.new()
+    configuration.api_url.should == 'test-yml-rails-common.7digital.com'
+    Object.instance_eval{ remove_const :RAILS_ROOT }
+  end
+
+end