7digital 0.1.2 → 0.1.5

data/lib/sevendigital/model/user.rb

@@ -1,75 +1,75 @@
-module Sevendigital
-
-  class User < SevendigitalObject
-
-    attr_accessor :oauth_access_token, :id, :type
-
-    #Artist image URL (optional lazy-loaded property)
-    #@return [String]
-    sevendigital_basic_property :email_address
-
-    sevendigital_extended_property :locker
-
-    sevendigital_extended_property :cards
-
-    def authenticated?
-      return !@oauth_access_token.nil?
-    end
-
-    def get_details(options={})
-      raise Sevendigital::SevendigitalError if !authenticated?
-      user_with_details = @api_client.user.get_details(@oauth_access_token, options)
-      copy_basic_properties_from(user_with_details)
-      user_with_details
-    end
-
-    def get_locker(options={})
-      raise Sevendigital::SevendigitalError if !authenticated?
-      @api_client.user.get_locker(@oauth_access_token, options)
-    end
-
-    def get_cards(options={})
-      raise Sevendigital::SevendigitalError if !authenticated?
-      @api_client.user_payment_card.get_card_list(@oauth_access_token, options)
-    end
-
-    def add_card(card_number, card_type, card_holder_name, card_start_date, card_expiry_date, card_issue_number,
-            card_verification_code, card_post_code, card_country, options={})
-      raise Sevendigital::SevendigitalError if !authenticated?
-      @api_client.user_payment_card.add_card(card_number, card_type, card_holder_name, card_start_date, card_expiry_date, card_issue_number,
-            card_verification_code, card_post_code, card_country, @oauth_access_token, options)
-    end
-
-    def select_card(card_id, options={})
-      raise Sevendigital::SevendigitalError if !authenticated?
-      @api_client.user_payment_card.select_card(card_id, @oauth_access_token, options)
-    end
-
-    # <b>DEPRECATED:</b> Please use <tt>purchase_item!</tt> instead.
-    def purchase!(release_id, track_id, price, token, options={})
-      warn "[DEPRECATION] `purchase!` is deprecated.  Please use 'purchase_item!' instead."
-      purchase_item!(release_id, track_id, price, options={})
-    end
-
-    def purchase_item!(release_id, track_id, price, options={})
-      raise Sevendigital::SevendigitalError if !authenticated?
-      @api_client.user.purchase_item(release_id, track_id, price, @oauth_access_token, options)
-    end
-
-    def purchase_basket!(basket_id, options={})
-      raise Sevendigital::SevendigitalError if !authenticated?
-      @api_client.user.purchase_basket(basket_id, @oauth_access_token, options)
-    end
-
-    def stream_track_url(release_id, track_id, options={})
-      raise Sevendigital::SevendigitalError if !authenticated?
-      @api_client.user.get_stream_track_url(release_id, track_id, @oauth_access_token, options)
-    end
-
-    def add_card_url(return_url, options={})
-      raise Sevendigital::SevendigitalError if !authenticated?
-      @api_client.user.get_add_card_url(return_url, @oauth_access_token, options)
-    end
-
-  end
+module Sevendigital
+
+  class User < SevendigitalObject
+
+    attr_accessor :oauth_access_token, :id, :type
+
+    #Artist image URL (optional lazy-loaded property)
+    #@return [String]
+    sevendigital_basic_property :email_address
+
+    sevendigital_extended_property :locker
+
+    sevendigital_extended_property :cards
+
+    def authenticated?
+      return !@oauth_access_token.nil?
+    end
+
+    def get_details(options={})
+      raise Sevendigital::SevendigitalError if !authenticated?
+      user_with_details = @api_client.user.get_details(@oauth_access_token, options)
+      copy_basic_properties_from(user_with_details)
+      user_with_details
+    end
+
+    def get_locker(options={})
+      raise Sevendigital::SevendigitalError if !authenticated?
+      @api_client.user.get_locker(@oauth_access_token, options)
+    end
+
+    def get_cards(options={})
+      raise Sevendigital::SevendigitalError if !authenticated?
+      @api_client.user_payment_card.get_card_list(@oauth_access_token, options)
+    end
+
+    def add_card(card_number, card_type, card_holder_name, card_start_date, card_expiry_date, card_issue_number,
+            card_verification_code, card_post_code, card_country, options={})
+      raise Sevendigital::SevendigitalError if !authenticated?
+      @api_client.user_payment_card.add_card(card_number, card_type, card_holder_name, card_start_date, card_expiry_date, card_issue_number,
+            card_verification_code, card_post_code, card_country, @oauth_access_token, options)
+    end
+
+    def select_card(card_id, options={})
+      raise Sevendigital::SevendigitalError if !authenticated?
+      @api_client.user_payment_card.select_card(card_id, @oauth_access_token, options)
+    end
+
+    # <b>DEPRECATED:</b> Please use <tt>purchase_item!</tt> instead.
+    def purchase!(release_id, track_id, price, token, options={})
+      warn "[DEPRECATION] `purchase!` is deprecated.  Please use 'purchase_item!' instead."
+      purchase_item!(release_id, track_id, price, options={})
+    end
+
+    def purchase_item!(release_id, track_id, price, options={})
+      raise Sevendigital::SevendigitalError if !authenticated?
+      @api_client.user.purchase_item(release_id, track_id, price, @oauth_access_token, options)
+    end
+
+    def purchase_basket!(basket_id, options={})
+      raise Sevendigital::SevendigitalError if !authenticated?
+      @api_client.user.purchase_basket(basket_id, @oauth_access_token, options)
+    end
+
+    def stream_track_url(release_id, track_id, options={})
+      raise Sevendigital::SevendigitalError if !authenticated?
+      @api_client.user.get_stream_track_url(release_id, track_id, @oauth_access_token, options)
+    end
+
+    def add_card_url(return_url, options={})
+      raise Sevendigital::SevendigitalError if !authenticated?
+      @api_client.user.get_add_card_url(return_url, @oauth_access_token, options)
+    end
+
+  end
 end

data/lib/sevendigital/pager.rb

@@ -1,20 +1,20 @@
-begin
-  require "will_paginate/collection"
-rescue LoadError
-end
-
-module Sevendigital
-  #@private
-  #internal class used to page array results if will_paginate is available
-  class Pager # :nodoc:
-    attr_accessor :page, :page_size, :total_items
-
-    def paginate_list(list)
-      return list unless defined?(WillPaginate)
-      paged_list = WillPaginate::Collection.create(@page, @page_size, @total_items) do |pager|
-        pager.replace(list)
-      end
-      paged_list
-    end
-  end
-end
+begin
+  require "will_paginate/collection"
+rescue LoadError
+end
+
+module Sevendigital
+  #@private
+  #internal class used to page array results if will_paginate is available
+  class Pager # :nodoc:
+    attr_accessor :page, :page_size, :total_items
+
+    def paginate_list(list)
+      return list unless defined?(WillPaginate)
+      paged_list = WillPaginate::Collection.create(@page, @page_size, @total_items) do |pager|
+        pager.replace(list)
+      end
+      paged_list
+    end
+  end
+end

data/lib/sevendigital/version.rb

@@ -1,5 +1,5 @@
-module Sevendigital
-  # The version of the gem
-  NAME = "7digital"
-  VERSION = '0.1.2'
-end
+module Sevendigital
+  # The version of the gem
+  NAME = "7digital"
+  VERSION = '0.1.5'
+end

data/spec/api_operator_cached_spec.rb

@@ -1,179 +1,234 @@
-require "spec_helper"
-require 'ostruct'
-require 'time'
-
-describe "ApiOperatorCached" do
-
-  before do
-    conf = test_configuration
-    @client = stub_api_client(conf)
-    @cache = stub(Hash)
-    @cached_operator = Sevendigital::ApiOperatorCached.new(@client, @cache)
-    @stub_api_request = stub_api_request()
-  end
-
-  it "should not look into cache if request requires signature" do
-    http_response = stub_http_response
-    @stub_api_request.stub!(:requires_signature?).and_return(true)
-    @cached_operator.stub(:create_request_uri).and_return("key")
-    @cache.should_not_receive(:get)
-    @cached_operator.should_receive(:make_http_request).with(@stub_api_request).and_return(http_response)
-    @cached_operator.should_receive(:digest_http_response).with(http_response)
-    @cached_operator.call_api(@stub_api_request)
-  end
-
-  it "should not cache api response if request was signed" do
-
-    http_response = stub_http_response
-    @stub_api_request.stub!(:requires_signature?).and_return(true)
-    @cached_operator.stub(:create_request_uri).and_return("key")
-
-    @cached_operator.stub!(:make_http_request).and_return(http_response)
-    @cached_operator.stub!(:digest_http_response)
-    @cache.should_not_receive(:set)
-    @cached_operator.call_api(@stub_api_request)
-  end
-
-  it "should not make an http request if response already in cache and not out of date " do
-    http_response = stub_http_response
-    @cached_operator.stub(:create_request_uri).and_return("key")
-    @cache.stub!(:get).with("key").and_return(http_response)
-    @cached_operator.stub!(:response_out_of_date?).with(http_response).and_return(false)
-    @cached_operator.should_not_receive(:make_http_request)
-    @cached_operator.should_not_receive(:digest_http_response).with(http_response)
-    @cached_operator.call_api(@stub_api_request)
-  end
-
-  it "should make an http request if cached response is out of date " do
-
-    expired_http_response = stub_http_response
-    fresh_http_response = stub_http_response
-    @cached_operator.stub(:create_request_uri).and_return("key")
-    @cache.stub!(:get).with("key").and_return(expired_http_response)
-    @cached_operator.stub!(:response_out_of_date?).with(expired_http_response).and_return(true)
-
-    @cache.stub!(:set).and_return(nil)
-    @cached_operator.should_receive(:make_http_request).and_return(fresh_http_response)
-    @cached_operator.should_receive(:digest_http_response).with(fresh_http_response)
-    @cached_operator.call_api(@stub_api_request)
-  end
-
-  it "should make an http request if response not yet in cache, digest it and return the result " do
-    api_response = stub_api_response()
-    http_response = fake_http_response()
-
-    @cached_operator.stub(:create_request_uri).and_return("key")
-    @cache.stub!(:get).with("key").and_return(nil)
-    @cache.stub!(:set).and_return(nil)
-    @cached_operator.should_receive(:make_http_request).with(@stub_api_request).and_return(http_response)
-    @cached_operator.should_receive(:digest_http_response).with(http_response).and_return(api_response)
-
-    response = @cached_operator.call_api(@stub_api_request)
-    response.should == api_response
-  end
-
-  it "should cache uncached api response if request was not signed" do
-    http_response = stub_http_response()
-    api_response = stub_api_response()
-
-    @cached_operator.stub(:create_request_uri).and_return("key")
-    @cache.stub!(:get).with("key").and_return(nil)
-    @cached_operator.stub!(:make_http_request).and_return(http_response)
-    @cached_operator.stub!(:digest_http_response).with(http_response).and_return(api_response)
-
-    @cache.should_receive(:set).with("key", api_response).and_return(nil)
-    @cached_operator.call_api(@stub_api_request)
-  end
-
-  it "response should be out of date if it's past its cache max age" do
-    now = Time.now.utc
-    yesterday = now - 24*60*60
-    max_age = 12*60*60
-
-    http_response = stub_http_response
-    http_response.stub!(:headers).and_return({
-      "cache-control" => "private, max-age=#{max_age}",
-      "Date" => yesterday.httpdate
-    })
-
-    @cached_operator.response_out_of_date?(http_response, now).should == true
-
-  end
-
-
-  it "response should not be out of date if it's within its cache max age" do
-    now = Time.now.utc
-    yesterday = now - 24*60*60
-    max_age = 48*60*60
-
-    http_response = stub_http_response
-    http_response.stub!(:headers).and_return({
-      "cache-control" => "private, max-age=#{max_age}",
-      "Date" => yesterday.httpdate
-    })
-
-    @cached_operator.response_out_of_date?(http_response, now).should == false
-
-  end
-
-  it "response should be out of date if it is missing caching headers" do
-
-    http_response = stub_http_response
-    http_response.stub!(:headers).and_return({})
-    @cached_operator.response_out_of_date?(http_response, Time.now.utc).should == true
-
-    http_response.stub!(:headers).and_return({
-      "Date" => Time.now.utc.httpdate
-    })
-    @cached_operator.response_out_of_date?(http_response, Time.now.utc).should == true
-
-  end
-
-  it "response should be out of date if no max-age has been specified" do
-
-    http_response = stub_http_response
-    http_response.stub!(:headers).and_return({"cache-control" => "no-cache", "Date" => Time.now.utc.httpdate})
-    @cached_operator.response_out_of_date?(http_response, Time.now.utc).should == true
-
-  end
-
-  it "response should be out of date if it is missing Date header" do
-
-    http_response = stub_http_response
-    http_response.stub!(:headers).and_return({"cache-control" => "private, max-age=#{2**30}"})
-    @cached_operator.response_out_of_date?(http_response, Time.now.utc).should == true
-    
-  end
-
-
-  def fake_http_response
-    return Net::HTTP.new("1.1", 200, "response_body")
-  end
-  
-  def stub_http_response
-    stub(Net::HTTP)
-  end
-  
-  def stub_time(time)
-    Time.stub!(:now).and_return(time)
-  end
-
-  def stub_api_response
-    api_response = stub(Sevendigital::ApiResponse)
-    api_response.stub!(:out_of_date?).and_return(false)
-    api_response
-  end
-
-  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
-
+require "spec_helper"
+require 'ostruct'
+require 'time'
+
+describe "ApiOperatorCached" do
+
+  before do
+    conf = test_configuration
+    @client = stub_api_client(conf)
+    @cache = stub(Hash)
+    @cached_operator = Sevendigital::ApiOperatorCached.new(@client, @cache)
+    @stub_api_request = stub_api_request()
+  end
+
+  it "should not look into cache if request requires signature" do
+    http_response = stub_http_response
+    @stub_api_request.stub!(:requires_signature?).and_return(true)
+    @cached_operator.stub(:create_request_uri).and_return("key")
+    @cache.should_not_receive(:get)
+    @cached_operator.should_receive(:make_http_request).with(@stub_api_request).and_return(http_response)
+    @cached_operator.should_receive(:digest_http_response).with(http_response)
+    @cached_operator.call_api(@stub_api_request)
+  end
+
+  it "should not cache api response if request was signed" do
+
+    http_response = stub_http_response
+    @stub_api_request.stub!(:requires_signature?).and_return(true)
+    @cached_operator.stub(:create_request_uri).and_return("key")
+
+    @cached_operator.stub!(:make_http_request).and_return(http_response)
+    @cached_operator.stub!(:digest_http_response)
+    @cache.should_not_receive(:set)
+    @cached_operator.call_api(@stub_api_request)
+  end
+
+  it "should not make an http request if response already in cache and not out of date " do
+    http_response = stub_http_response
+    @cached_operator.stub(:create_request_uri).and_return("key")
+    @cache.stub!(:get).with("key").and_return(http_response)
+    @cached_operator.stub!(:response_out_of_date?).with(http_response, nil).and_return(false)
+    @cached_operator.should_not_receive(:make_http_request)
+    @cached_operator.should_not_receive(:digest_http_response).with(http_response)
+    @cached_operator.call_api(@stub_api_request)
+  end
+
+  it "should make an http request if cached response is out of date " do
+    expired_http_response = stub_http_response
+    fresh_http_response = stub_http_response
+    @cached_operator.stub(:create_request_uri).and_return("key")
+    @cache.stub!(:get).with("key").and_return(expired_http_response)
+    @cached_operator.stub!(:response_out_of_date?).with(expired_http_response, nil).and_return(true)
+
+    @cache.stub!(:set).and_return(nil)
+    @cached_operator.should_receive(:make_http_request).and_return(fresh_http_response)
+    @cached_operator.should_receive(:digest_http_response).with(fresh_http_response)
+    @cached_operator.call_api(@stub_api_request)
+  end
+
+  it "should use overridden cache_max_age when checking if response out of date" do
+    @stub_api_request.stub!(:options).and_return({:cache_max_age => 123})
+    expired_http_response = stub_http_response
+    fresh_http_response = stub_http_response
+    @cached_operator.stub(:create_request_uri).and_return("key")
+    @cache.stub!(:get).with("key").and_return(expired_http_response)
+    @cache.stub!(:set).and_return(nil)
+    @cached_operator.stub(:make_http_request).and_return(fresh_http_response)
+    @cached_operator.stub(:digest_http_response).with(fresh_http_response)
+
+    @cached_operator.should_receive(:response_out_of_date?).with(expired_http_response, 123).and_return(true)
+
+    @cached_operator.call_api(@stub_api_request)
+  end
+
+  it "should make an http request if response not yet in cache, digest it and return the result " do
+    api_response = stub_api_response()
+    http_response = fake_http_response()
+
+    @cached_operator.stub(:create_request_uri).and_return("key")
+    @cache.stub!(:get).with("key").and_return(nil)
+    @cache.stub!(:set).and_return(nil)
+    @cached_operator.should_receive(:make_http_request).with(@stub_api_request).and_return(http_response)
+    @cached_operator.should_receive(:digest_http_response).with(http_response).and_return(api_response)
+
+    response = @cached_operator.call_api(@stub_api_request)
+    response.should == api_response
+  end
+
+  it "should cache uncached api response if request was not signed" do
+    http_response = stub_http_response()
+    api_response = stub_api_response()
+
+    @cached_operator.stub(:create_request_uri).and_return("key")
+    @cache.stub!(:get).with("key").and_return(nil)
+    @cached_operator.stub!(:make_http_request).and_return(http_response)
+    @cached_operator.stub!(:digest_http_response).with(http_response).and_return(api_response)
+
+    @cache.should_receive(:set).with("key", api_response).and_return(nil)
+    @cached_operator.call_api(@stub_api_request)
+  end
+
+  it "response should be out of date if it's past its cache max age" do
+    now = Time.now.utc
+    yesterday = now - 24*60*60
+    max_age = 12*60*60
+
+    http_response = stub_http_response
+    http_response.stub!(:headers).and_return({
+      "cache-control" => "private, max-age=#{max_age}",
+      "Date" => yesterday.httpdate
+    })
+
+    @cached_operator.response_out_of_date?(http_response, nil, now).should == true
+
+  end
+
+
+  it "response should not be out of date if it's within its cache max age" do
+    now = Time.now.utc
+    yesterday = now - 24*60*60
+    max_age = 48*60*60
+
+    http_response = stub_http_response
+    http_response.stub!(:headers).and_return({
+      "cache-control" => "private, max-age=#{max_age}",
+      "Date" => yesterday.httpdate
+    })
+
+    @cached_operator.response_out_of_date?(http_response, nil, now).should == false
+
+  end
+
+  it "response should not be out of date if it's within overridden cache max age" do
+    now = Time.now.utc
+    yesterday = now - 24*60*60
+    max_age = 12*60*60
+    overridden_max_age = 48*60*60
+
+    http_response = stub_http_response
+    http_response.stub!(:headers).and_return({
+                                                 "cache-control" => "private, max-age=#{max_age}",
+                                                 "Date" => yesterday.httpdate
+                                             })
+
+    @cached_operator.response_out_of_date?(http_response, overridden_max_age, now).should == false
+
+  end
+
+  it "response should be out of date if it's not within overridden cache max age" do
+    now = Time.now.utc
+    yesterday = now - 24*60*60
+    max_age = 48*60*60
+    overridden_max_age = 12*60*60
+
+    http_response = stub_http_response
+    http_response.stub!(:headers).and_return({
+                                                 "cache-control" => "private, max-age=#{max_age}",
+                                                 "Date" => yesterday.httpdate
+                                             })
+
+    @cached_operator.response_out_of_date?(http_response, overridden_max_age, now).should == true
+
+  end
+
+
+  it "response should be out of date if it is missing caching headers" do
+
+    http_response = stub_http_response
+    http_response.stub!(:headers).and_return({})
+    @cached_operator.response_out_of_date?(http_response, Time.now.utc).should == true
+
+    http_response.stub!(:headers).and_return({
+      "Date" => Time.now.utc.httpdate
+    })
+    @cached_operator.response_out_of_date?(http_response, Time.now.utc).should == true
+
+  end
+
+  it "response should be out of date if no max-age has been specified" do
+
+    http_response = stub_http_response
+    http_response.stub!(:headers).and_return({"cache-control" => "no-cache", "Date" => Time.now.utc.httpdate})
+    @cached_operator.response_out_of_date?(http_response, Time.now.utc).should == true
+
+  end
+
+  it "response should be out of date if it is missing Date header" do
+
+    http_response = stub_http_response
+    http_response.stub!(:headers).and_return({"cache-control" => "private, max-age=#{2**30}"})
+    @cached_operator.response_out_of_date?(http_response, Time.now.utc).should == true
+    
+  end
+
+  it "should read default cache max age value from configuration" do
+    conf = test_configuration
+    conf.cache_max_age = {:"m" => 1000}
+    @client = stub_api_client(conf)
+    @cached_operator = Sevendigital::ApiOperatorCached.new(@client, @cache)
+    @cached_operator.default_cache_max_age(@stub_api_request).should == 1000
+  end
+
+  def fake_http_response
+    return Net::HTTP.new("1.1", 200, "response_body")
+  end
+  
+  def stub_http_response
+    stub(Net::HTTP)
+  end
+  
+  def stub_time(time)
+    Time.stub!(:now).and_return(time)
+  end
+
+  def stub_api_response
+    api_response = stub(Sevendigital::ApiResponse)
+    api_response.stub!(:out_of_date?).and_return(false)
+    api_response
+  end
+
+  def stub_api_request
+  api_request = stub(Sevendigital::ApiRequest)
+
+  api_request.stub!(:parameters).and_return({})
+  api_request.stub!(:options).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
+
 end