7digital 0.0.1

data/lib/sevendigital/model/sevendigital_error.rb

@@ -0,0 +1,3 @@
+module Sevendigital
+  class SevendigitalError < StandardError; end
+end

data/lib/sevendigital/model/sevendigital_object.rb

@@ -0,0 +1,51 @@
+class Class
+
+  def sevendigital_basic_property(*properties)
+    @basic_properties = []
+    properties.each do |property|
+      @basic_properties << "@#{property}".to_sym
+      sevendigital_extended_property property, :get_details
+    end
+  end
+
+ def sevendigital_extended_property(accessor, get_method = nil)
+
+    get_method ||= "get_#{accessor.to_s}".to_sym
+    demand_method = "demand_#{accessor.to_s}".to_sym
+
+     define_method(demand_method) do |*options|
+       if instance_variable_get("@#{accessor}") == nil then
+         value = send(get_method, *options)
+         instance_variable_set("@#{accessor}", value) if get_method != :get_details
+       end
+     end
+
+     define_method("#{accessor}") do |*options|
+       send(demand_method, *options) if instance_variable_get("@#{accessor}").nil? && @api_client.configuration.lazy_load?
+       instance_variable_get("@#{accessor}")
+     end
+
+     define_method("#{accessor}=") do |val|
+       instance_variable_set("@#{accessor}",val)
+     end
+ end
+end
+
+module Sevendigital
+
+  class SevendigitalObject
+
+    def initialize(api_client)
+      @api_client = api_client
+    end
+
+    def copy_basic_properties_from(other_object)
+      self.class.instance_variable_get(:@basic_properties).each do |property|
+         instance_variable_set(property, other_object.instance_variable_get(property))
+      end
+    end
+
+  end
+
+end
+

data/lib/sevendigital/model/track.rb

@@ -0,0 +1,8 @@
+module Sevendigital 
+
+  class Track < SevendigitalObject
+    attr_accessor :id, :title, :version, :artist, :track_number,
+                  :duration, :explicit_content, :isrc, :release, :url, :price
+
+  end
+end

data/lib/sevendigital/pager.rb

@@ -0,0 +1,17 @@
+require "will_paginate/collection"
+
+module Sevendigital
+
+  class Pager
+    attr_accessor :page, :page_size, :total_items
+
+    def paginate_list(list)
+      paged_list = WillPaginate::Collection.create(@page, @page_size, @total_items) do |pager|
+        pager.replace(list)
+      end
+      return paged_list
+    end
+
+  end
+
+end

data/lib/sevendigital/proxy_police.rb

@@ -0,0 +1,24 @@
+module Sevendigital
+  class ProxyPolice
+
+    def ProxyPolice.ensure_is_proxy(xml_or_proxy, element_name)
+      if xml_or_proxy.kind_of? Peachy::Proxy then
+          return xml_or_proxy
+      else
+          return ProxyPolice.create_release_proxy(xml_or_proxy, element_name)
+      end
+    end
+
+    def ProxyPolice.create_release_proxy(xml, element_name)
+      #TODO don't use eval
+      parent_proxy = Peachy::Proxy.new(xml)
+      if element_name
+#        parent_proxy.send(element_name)
+        eval "parent_proxy.#{element_name.to_s}"
+      else
+        parent_proxy
+      end
+    end
+
+  end
+end

data/lib/sevendigital/version.rb

@@ -0,0 +1,3 @@
+module Sevendigital
+  VERSION = '0.0.1'
+end

data/spec/api_operator_cached_spec.rb

@@ -0,0 +1,47 @@
+require "spec"
+require 'sevendigital'
+require 'ostruct'
+
+describe "ApiOperatorCached" do
+
+  before do
+    @client = stub(Sevendigital::Client)
+    @cache = stub(Hash)
+    @cached_operator = Sevendigital::ApiOperatorCached.new(@client, @cache)
+  end
+
+  it "should not make an http request if response already in cache " do
+    @cached_operator.stub(:create_request_uri).and_return("key")
+    @cache.stub!(:get).with("key").and_return(:something)
+    @cached_operator.should_not_receive(:make_http_request_and_digest)
+    @cached_operator.call_api(@stub_api_request)
+  end
+  
+  it "should make an http request if response not yet in cache and return the result " do
+    api_response = fake_api_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_and_digest).with("key").and_return(api_response)
+    
+    response = @cached_operator.call_api(@stub_api_request)
+    response.should == api_response
+  end
+
+  it "should cache uncached api response" do
+    api_response = fake_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_digest).and_return(api_response)
+
+    @cache.should_receive(:set).with("key", api_response).and_return(nil)
+    response = @cached_operator.call_api(@stub_api_request)
+  end
+
+  def fake_api_response
+    return Net::HTTP.new("1.1", 200, "response_body")
+  end
+
+end

data/spec/api_operator_spec.rb

@@ -0,0 +1,108 @@
+require "spec"
+require 'sevendigital'
+require 'ostruct'
+
+describe "ApiOperator" do
+
+  before do
+    response_digestor = stub(Sevendigital::ApiResponseDigestor)
+    response_digestor.stub!(:from_http_response).and_return(fake_digested_response)
+
+    stub_api_client(test_configuration, response_digestor)
+
+    Net::HTTP.stub!(:get_response).and_return(fake_api_response)
+
+    @api_operator = Sevendigital::ApiOperator.new(@client)
+
+    @stub_api_request = stub_api_request()
+
+  end
+
+  it "should create request URI based on api method and client configuration" do
+
+    api_request = Sevendigital::ApiRequest.new("api/method", {:param1 => "value", :paramTwo => 2})
+
+    uri = @api_operator.create_request_uri(api_request)
+
+    uri.kind_of?(URI).should == true
+    uri.to_s.should == "http://base.api.url/version/api/method?oauth_consumer_key=oauth_consumer_key&param1=value&paramTwo=2&country=sk"
+
+  end
+
+  it "should make sure country is set before making request" do
+    @client.stub!(:country).and_return("sk")
+
+    @stub_api_request.should_receive(:ensure_country_is_set).with("sk")
+    
+    @api_operator.call_api(@stub_api_request)
+
+  end
+
+  it "should make HTTP request and get response" do
+
+    Net::HTTP.should_receive(:get_response).with(@api_operator.create_request_uri(@stub_api_request))
+
+    @api_operator.call_api(@stub_api_request)
+
+  end
+
+  it "should digest the HTTP response and get it out" do
+
+    http_response = fake_api_response
+
+    Net::HTTP.stub!(:get_response).and_return(http_response)
+
+    @client.api_response_digestor.should_receive(:from_http_response).with(http_response).and_return(fake_digested_response)
+
+    response = @api_operator.call_api(@stub_api_request)
+
+    response.kind_of?(Peachy::Proxy).should == true
+    response.to_s.should == fake_digested_response.to_s
+
+  end
+
+  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)
+    @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
+
+  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
+
+  def fake_api_response(code = 200, body = "response_body")
+    return Net::HTTP.new("1.1", code, body)
+  end
+
+  def fake_digested_response(is_ok = true)
+    proxy =  Peachy::Proxy.new('<response status="ok"><content>test</content></response>')
+    proxy.stub!(:ok?).and_return(is_ok)
+    proxy
+  end
+
+  def stub_api_client(configuration, response_digestor)
+  @client = stub(Sevendigital::Client)
+  @client.stub!(:configuration).and_return(configuration)
+  @client.stub!(:api_response_digestor).and_return(response_digestor)
+  @client.stub!(:country).and_return("sk")
+end
+
+def stub_api_request
+  api_request = stub(Sevendigital::ApiRequest)
+
+  api_request.stub!(:parameters).and_return({})
+  api_request.stub!(:api_method).and_return("m")
+  api_request.stub!(:ensure_country_is_set)
+  return api_request
+end
+
+end

data/spec/api_request_spec.rb

@@ -0,0 +1,27 @@
+require 'spec'
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe "ApiRequest" do
+
+  it "should merge method parameters and options with parameters taking preference" 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
+
+  end
+
+  it "should provide paging parameters in 7digital API format" do
+
+    request = Sevendigital::ApiRequest.new('method', {}, {:page => 5, :per_page => 3 })
+    request.parameters[:page].should == 5
+    request.parameters[:pageSize].should == 3
+
+	end
+
+end

data/spec/client_spec.rb

@@ -0,0 +1,46 @@
+require "spec"
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+require 'sevendigital'
+
+describe "Client" do
+
+  it "should load default configuration" do
+    client = Sevendigital::Client.new
+    client.configuration.api_url.should == 'api.7digital.com'
+  end
+
+  it "should override default configuration with configuration hash" do
+    client = Sevendigital::Client.new(:api_url => "test-hash.7digital.com")
+    client.configuration.api_url.should == 'test-hash.7digital.com'
+  end
+
+  it "should override default configuration with configuration class" do
+    client = Sevendigital::Client.new(OpenStruct.new(:api_url => "test-openstruct.7digital.com"))
+    client.configuration.api_url.should == 'test-openstruct.7digital.com'
+  end
+
+  it "should use simple configuration file" do
+    client = Sevendigital::Client.new(File.join(File.dirname(__FILE__),"data", "configuration_override.yml"))
+    client.configuration.api_url.should == 'test-yml-simple.7digital.com'
+  end
+
+  it "should use environment specific configuration file" do
+    client = Sevendigital::Client.new(File.join(File.dirname(__FILE__),"data", "configuration_env_override.yml"))
+    client.configuration.api_url.should == 'test-yml-common.7digital.com'
+  end
+
+  it "should use environment specific configuration file with environment specific settings" do
+    Object.const_set(:RAILS_ENV, "development") 
+    client = Sevendigital::Client.new(File.join(File.dirname(__FILE__),"data", "configuration_env_override.yml"))
+    client.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
+    Object.const_set(:RAILS_ROOT, File.join(File.dirname(__FILE__),"data"))
+    client = Sevendigital::Client.new()
+    client.configuration.api_url.should == 'test-yml-rails-common.7digital.com'
+    Object.instance_eval{ remove_const :RAILS_ROOT }
+  end
+
+end

data/spec/data/config/sevendigital.yml

@@ -0,0 +1,5 @@
+common:
+  api_url: test-yml-rails-common.7digital.com
+
+development:
+  api_url: test-yml-development.7digital.com

data/spec/data/configuration_env_override.yml

@@ -0,0 +1,5 @@
+common:
+  api_url: test-yml-common.7digital.com
+
+development:
+  api_url: test-yml-development.7digital.com

data/spec/data/configuration_override.yml

@@ -0,0 +1 @@
+api_url: test-yml-simple.7digital.com

data/spec/digestion_tract/api_response_digestor_spec.rb

@@ -0,0 +1,74 @@
+require 'spec'
+require File.join(File.dirname(__FILE__), %w[../spec_helper])
+
+
+describe "ApiResponseDigestor" do
+
+  before do
+    @api_response_digestor = Sevendigital::ApiResponseDigestor.new(nil)
+  end
+
+  it "should create a response with body from http ok response" do
+
+    stub_http_response = stub(Net::HTTPSuccess)
+    stub_http_response.stub!(:is_a?).with(Net::HTTPSuccess).and_return(true)
+    stub_http_response.stub!(:body).and_return('<response status="ok"></response>')
+
+    response =  @api_response_digestor.from_http_response(stub_http_response)
+    response.error_code.should == 0
+  end
+
+  it "should create an error response from http non-ok response" do
+    expected_message = 'Authorisation failed'
+    expected_error_code = 401
+
+    stub_http_response = stub(Net::HTTPSuccess)
+    stub_http_response.stub!(:is_a?).with(Net::HTTPSuccess).and_return(false)
+    stub_http_response.stub!(:code).and_return(expected_error_code.to_s)
+    stub_http_response.stub!(:body).and_return(expected_message)
+
+    response =  @api_response_digestor.from_http_response(stub_http_response)
+    response.error_code.should == 401
+    response.error_message.should == expected_message
+
+  end
+
+
+
+  it "should create a response with body from xml ok response" do
+
+    xml_response = <<XML
+    <response status="ok"><test></test></response>
+XML
+    response = @api_response_digestor.from_xml(xml_response)
+    response.error_code.should == 0
+    response.content.test.should_not == nil
+    response.content.nothing.should == nil
+  end
+
+
+  it "should create a response with error details from xml error response" do
+
+    xml_response = '<response status="error"><error code="1000"><errorMessage>expected error message</errorMessage></error></response>'
+    response = @api_response_digestor.from_xml(xml_response)
+    response.error_code.should == 1000
+    response.error_message.should == 'expected error message'
+  end
+
+  it "should create a response with error details from invalid xml response" do
+
+    xml_response = '<wrongresponse status="ok"><test /></wrongresponse>'
+    response = @api_response_digestor.from_xml(xml_response)
+    response.error_code.should == 10000
+    response.error_message.should == 'Invalid 7digital API response'
+  end
+
+    it "should create a response with error details from valid xml response with invalid status" do
+
+    xml_response = '<response status="unkown"><test></test></response>'
+    response = @api_response_digestor.from_xml(xml_response)
+    response.error_code.should == 10000
+    response.error_message.should == 'Invalid 7digital API response'
+  end
+
+end

data/spec/digestion_tract/artist_digestor_spec.rb

@@ -0,0 +1,83 @@
+require "spec"
+require "sevendigital"
+
+describe "ArtistDigestor" do
+
+  before do
+    @artist_digestor = Sevendigital::ArtistDigestor.new(Sevendigital::Client.new(nil))
+  end
+
+ it "should not digest from invalid xml but throw up (exception)" do
+
+    xml_response = <<XML
+    <release id="123">
+      <name>expected artist name</name>
+    </release>
+XML
+
+    running {@artist_digestor.from_xml(xml_response)}.should raise_error Sevendigital::DigestiveProblem
+
+  end
+
+  it "should digest artist xml and populate minimum available properties" do
+
+    xml_response = <<XML
+    <artist id="123">
+      <name>expected artist name</name>
+    </artist>
+XML
+
+    artist = @artist_digestor.from_xml(xml_response)
+    artist.id.should == 123
+    artist.name.should == "expected artist name"
+  end
+
+   it "should digest artist xml and populate all available properties" do
+
+    xml_response = load_sample_object_xml("artist")
+
+    artist = @artist_digestor.from_xml(xml_response)
+    artist.id.should == 123
+    artist.name.should == "The Expected Artist"
+    artist.sort_name.should == "Expected Artist, The"
+    artist.appears_as.should == "The E.A."
+    artist.image.should == "http://somewhere.com/tea.jpg"
+    artist.url.should == "http://7digital.com/artists/tea?partner=1"
+   end
+
+    it "should digest xml containing list of artists and return a paginated array" do
+
+    xml_response = load_sample_object_xml("artist_list")
+
+    artists = @artist_digestor.list_from_xml(xml_response, :artists)
+    artists[0].id.should == 14
+    artists[1].id.should == 20
+    artists[2].id.should == 106
+    artists.size.should == 3
+    artists.total_entries.should == 26
+
+  end
+
+  it "should digest xml containing empty list of releases and return an empty paginated array" do
+
+    xml_response = load_sample_object_xml("artist_list_empty")
+
+    artists = @artist_digestor.list_from_xml(xml_response, :artists)
+    artists.size.should == 0
+    artists.total_entries.should == 0
+
+  end
+
+   it "should not digest list from invalid xml but throw up (exception)" do
+
+    xml_response = <<XML
+    <release id="123">
+      <name>expected artist name</name>
+    </release>
+XML
+
+    running {@artist_digestor.list_from_xml(xml_response)}.should raise_error Sevendigital::DigestiveProblem
+
+  end
+
+end