7digital 0.0.2 → 0.0.5

data/spec/management/release_manager_spec.rb

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 require 'date'
-require File.join(File.dirname(__FILE__), %w[../spec_helper])
+require File.expand_path('../../spec_helper', __FILE__)
 
 describe "ReleaseManager" do
 
@@ -20,11 +20,9 @@ describe "ReleaseManager" do
     mock_client_digestor(@client, :release_digestor) \
       .should_receive(:from_xml).with(api_response.content.release).and_return(a_release)
 
-    @client.operator.should_receive(:call_api) { |api_request|
-       api_request.api_method.should == "release/details"
-       api_request.parameters[:releaseId].should  == expected_release_id
-       api_response
-    }
+    @client.should_receive(:make_api_request) \
+      .with("release/details", {:releaseId => expected_release_id}, {}) \
+      .and_return(api_response)
 
     @release_manager.get_details(expected_release_id).should == a_release
 
@@ -39,12 +37,9 @@ describe "ReleaseManager" do
     mock_client_digestor(@client, :track_digestor) \
       .should_receive(:list_from_xml).with(api_response.content.tracks).and_return(a_track_list)
 
-    @client.operator.should_receive(:call_api) { |api_request|
-       api_request.api_method.should == "release/tracks"
-       api_request.parameters[:releaseId].should  == a_release_id
-       api_request.parameters[:pageSize].should  == 20
-       api_response
-    }
+    @client.should_receive(:make_api_request) \
+      .with("release/tracks", {:releaseId=>a_release_id}, expected_options) \
+      .and_return(api_response)
 
     tracks = @release_manager.get_tracks(a_release_id, expected_options)
     tracks.should == a_track_list
@@ -60,12 +55,9 @@ describe "ReleaseManager" do
     mock_client_digestor(@client, :track_digestor) \
       .should_receive(:list_from_xml).with(api_response.content.tracks).and_return(a_track_list)
 
-    @client.operator.should_receive(:call_api) { |api_request|
-       api_request.api_method.should == "release/tracks"
-       api_request.parameters[:releaseId].should  == a_release_id
-       api_request.parameters[:pageSize].should  == 100
-       api_response
-    }
+    @client.should_receive(:make_api_request) \
+      .with("release/tracks", {:releaseId => a_release_id}, {:page_size => 100}) \
+      .and_return(api_response)
 
     tracks = @release_manager.get_tracks(a_release_id)
     tracks.should == a_track_list
@@ -81,36 +73,15 @@ describe "ReleaseManager" do
     mock_client_digestor(@client, :chart_item_digestor) \
         .should_receive(:list_from_xml).with(api_response.content.chart).and_return(a_chart)
 
-    @client.operator.should_receive(:call_api) { |api_request|
-       api_request.api_method.should == "release/chart"
-       api_response
-    }
+    @client.should_receive(:make_api_request) \
+      .with("release/chart", {}, {}) \
+      .and_return(api_response)
 
     chart = @release_manager.get_chart
     chart.should == a_chart
   end
 
-  it "get_latest should call release/tracks api method and digest the track list from response" do
-
-    a_release_id = 123
-    api_response = fake_api_response("release/tracks")
-    a_track_list = []
-
-    mock_client_digestor(@client, :track_digestor) \
-      .should_receive(:list_from_xml).with(api_response.content.tracks).and_return(a_track_list)
-
-    @client.operator.should_receive(:call_api) { |api_request|
-       api_request.api_method.should == "release/tracks"
-       api_request.parameters[:releaseId].should  == a_release_id
-       api_response
-    }
-
-    tracks = @release_manager.get_tracks(a_release_id)
-    tracks.should == a_track_list
-
-  end
-
-  it "get_by_date should call release/tracks with supplied parameters and digest the release list from response" do
+  it "get_by_date should call release/byDate with supplied parameters and digest the release list from response" do
 
     from_date = DateTime.new(2010, 01, 01)
     to_date = DateTime.new(2010, 05, 01)
@@ -120,12 +91,9 @@ describe "ReleaseManager" do
     mock_client_digestor(@client, :release_digestor) \
       .should_receive(:list_from_xml).with(api_response.content.releases).and_return(a_release_list)
 
-    @client.operator.should_receive(:call_api) { |api_request|
-       api_request.api_method.should == "release/byDate"
-       api_request.parameters[:fromDate].should  == from_date.strftime("%Y%m%d")
-       api_request.parameters[:toDate].should  == to_date.strftime("%Y%m%d")
-       api_response
-    }
+    @client.should_receive(:make_api_request) \
+         .with("release/byDate", {:fromDate => from_date.strftime("%Y%m%d"), :toDate => to_date.strftime("%Y%m%d")}, {}) \
+         .and_return(api_response)
 
     tracks = @release_manager.get_by_date(from_date, to_date)
     tracks.should == a_release_list
@@ -140,15 +108,12 @@ describe "ReleaseManager" do
     mock_client_digestor(@client, :release_digestor) \
       .should_receive(:list_from_xml).with(api_response.content.releases).and_return(a_release_list)
 
-    @client.operator.should_receive(:call_api) { |api_request|
-       api_request.api_method.should == "release/byDate"
-       api_request.parameters.has_key?(:fromDate).should  == false
-       api_request.parameters.has_key?(:toDate).should  == false
-       api_response
-    }
+    @client.should_receive(:make_api_request) \
+         .with("release/byDate", {}, {}) \
+         .and_return(api_response)
 
-    tracks = @release_manager.get_by_date
-    tracks.should == a_release_list
+    releases = @release_manager.get_by_date
+    releases.should == a_release_list
 
   end
 
@@ -163,12 +128,10 @@ describe "ReleaseManager" do
       .with(api_response.content.recommendations, :recommended_item, :recommendations) \
       .and_return(a_release_list)
 
-    @client.operator.should_receive(:call_api) { |api_request|
-       api_request.api_method.should == "release/recommend"
-       api_request.parameters[:releaseId].should  == a_release_id
-       api_response
-    }
-    
+    @client.should_receive(:make_api_request) \
+         .with("release/recommend", {:releaseId => a_release_id}, {}) \
+         .and_return(api_response)
+   
     releases = @release_manager.get_recommendations(a_release_id)
     releases.should == a_release_list
 
@@ -185,12 +148,10 @@ describe "ReleaseManager" do
       .with(api_response.content.tagged_results, :tagged_item, :tagged_results) \
       .and_return(a_release_list)
 
-    @client.operator.should_receive(:call_api) { |api_request|
-       api_request.api_method.should == "release/byTag/top"
-       api_request.parameters[:tags].should == tags
-       api_response
-    }
-
+    @client.should_receive(:make_api_request) \
+         .with("release/byTag/top", {:tags => tags}, {}) \
+         .and_return(api_response)
+    
     releases = @release_manager.get_top_by_tag(tags)
     releases.should == a_release_list
 
@@ -207,11 +168,9 @@ describe "ReleaseManager" do
         .with(api_response.content.search_results, :search_result, :search_results) \
         .and_return(a_release_list)
 
-      @client.operator.should_receive(:call_api) { |api_request|
-         api_request.api_method.should == "release/search"
-         api_request.parameters[:q].should == query
-         api_response
-      }
+      @client.should_receive(:make_api_request) \
+           .with("release/search", {:q => query}, {}) \
+           .and_return(api_response)
 
       releases = @release_manager.search(query)
       releases.should == a_release_list

data/spec/management/tag_manager_spec.rb

@@ -0,0 +1,34 @@
+# encoding: UTF-8
+require 'date'
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "TagManager" do
+
+  before do
+
+    @client = stub(Sevendigital::Client)
+    @client.stub!(:operator).and_return(mock(Sevendigital::ApiOperator))
+    @tag_manager = Sevendigital::TagManager.new(@client)
+
+  end
+
+
+  it "get_tag_list should call tag api method and digest the tag list from response" do
+
+    an_api_response = fake_api_response("tag/index")
+    a_tag_list = [Sevendigital::Tag.new]
+
+    mock_client_digestor(@client, :tag_digestor) \
+        .should_receive(:list_from_xml).with(an_api_response.content.tags).and_return(a_tag_list)
+
+    @client.should_receive(:make_api_request) \
+                   .with("tag", {}, {}) \
+                   .and_return(an_api_response)
+
+
+    tags = @tag_manager.get_tag_list
+    tags.should == a_tag_list
+  end
+
+
+end

data/spec/management/track_manager_spec.rb

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 require 'date'
-require File.join(File.dirname(__FILE__), %w[../spec_helper])
+require File.expand_path('../../spec_helper', __FILE__)
 
 describe "TrackManager" do
 
@@ -20,28 +20,44 @@ describe "TrackManager" do
     mock_client_digestor(@client, :track_digestor) \
       .should_receive(:from_xml).with(an_api_response.content.track).and_return(a_track)
 
-    @client.operator.should_receive(:call_api) { |api_request|
-       api_request.api_method.should == "track/details"
-       api_request.parameters[:trackId].should  == a_track_id
-       an_api_response
-    }
+    @client.should_receive(:make_api_request) \
+                 .with("track/details", {:trackId => a_track_id}, {}) \
+                 .and_return(an_api_response)
 
     @track_manager.get_details(a_track_id).should == a_track
 
   end
 
+  it "get_details_from_release should get all tracks from the release and pick the relevant one" do
+
+    @client.stub!(:release).and_return(mock(Sevendigital::ReleaseManager))
+
+    options = []
+    track_1 = Sevendigital::Track.new(@client)
+    track_1.id = 1
+    track_2 = Sevendigital::Track.new(@client)
+    track_2.id = 2
+    a_track_list = [track_1, track_2]
+    a_release_id = 123456
+
+    @client.release.should_receive(:get_tracks).with(a_release_id, options).and_return(a_track_list)
+
+    track = @track_manager.get_details_from_release(track_1.id, a_release_id, options)
+    track.should == track_1
+  end
+
   it "get_chart should call track/chart api method and digest the release list from response" do
 
-    api_response = fake_api_response("track/chart")
+    an_api_response = fake_api_response("track/chart")
     a_chart = []
 
     mock_client_digestor(@client, :chart_item_digestor) \
-        .should_receive(:list_from_xml).with(api_response.content.chart).and_return(a_chart)
+        .should_receive(:list_from_xml).with(an_api_response.content.chart).and_return(a_chart)
+
+    @client.should_receive(:make_api_request) \
+                   .with("track/chart", {}, {}) \
+                   .and_return(an_api_response)
 
-    @client.operator.should_receive(:call_api) { |api_request|
-       api_request.api_method.should == "track/chart"
-       api_response
-    }
 
     chart = @track_manager.get_chart
     chart.should == a_chart
@@ -50,12 +66,15 @@ describe "TrackManager" do
   it "build_preview_url should return URL for track/preview api request" do
     track_id = 123456
     fake_preview_url = "http://7digital.com/track/preview"
+    fake_api_request = stub(Sevendigital::ApiRequest)
 
-    @client.operator.should_receive(:create_request_uri) { |api_request|
-       api_request.api_method.should == "track/preview"
-       api_request.parameters[:trackId].should  == track_id
-       fake_preview_url
-    }
+    @client.should_receive(:create_api_request) \
+                   .with("track/preview", {:trackId => track_id}, {}) \
+                   .and_return(fake_api_request)
+
+    @client.operator.should_receive(:create_request_uri) \
+      .with(fake_api_request) \
+      .and_return(fake_preview_url)
 
     preview_url = @track_manager.build_preview_url(track_id)
 
@@ -65,20 +84,18 @@ describe "TrackManager" do
   it "search should call track/search api method and digest the nested track list from response" do
 
     query = "radiohead"
-    api_response = fake_api_response("track/search")
+    an_api_response = fake_api_response("track/search")
     a_track_list = [Sevendigital::Track.new(@client)]
 
     mock_client_digestor(@client, :track_digestor) \
       .should_receive(:nested_list_from_xml) \
-      .with(api_response.content.search_results, :search_result, :search_results) \
+      .with(an_api_response.content.search_results, :search_result, :search_results) \
       .and_return(a_track_list)
 
-    @client.operator.should_receive(:call_api) { |api_request|
-       api_request.api_method.should == "track/search"
-       api_request.parameters[:q].should == query
-       api_response
-    }
-
+    @client.should_receive(:make_api_request) \
+                   .with("track/search", {:q => query}, {}) \
+                   .and_return(an_api_response)
+    
     tracks = @track_manager.search(query)
     tracks.should == a_track_list
 

data/spec/management/user_manager_spec.rb

@@ -0,0 +1,163 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "UserManager" do
+
+  before do
+
+    @an_email = "email"
+    @a_password = "password"
+    @a_request_token = fake_request_token
+    @an_access_token = fake_access_token
+
+    @client = stub(Sevendigital::Client)
+
+    @oauth_manager = mock(Sevendigital::OAuthManager)
+    @oauth_manager.stub!(:get_request_token).and_return(@a_request_token)
+    @oauth_manager.stub!(:authorise_request_token).and_return(true)
+    @oauth_manager.stub!(:get_access_token).and_return(@an_access_token)
+
+    @client.stub!(:operator).and_return(mock(Sevendigital::ApiOperator))
+    @client.stub!(:oauth).and_return(@oauth_manager )
+    @user_manager = Sevendigital::UserManager.new(@client)
+  end
+
+  it "should log in user using an existing access token" do
+    an_access_token = OAuth::AccessToken.new("aaa", "bbb", nil)
+    @user = @user_manager.login(an_access_token)
+    @user.authenticated?.should == true
+  end
+
+  it "should not log in user using an request token but raise an exception" do
+    a_request_token = OAuth::RequestToken.new("aaa", "bbb", nil)
+    running {@user = @user_manager.login(a_request_token)}.should raise_exception Sevendigital::SevendigitalError
+    @user.nil?.should == true
+  end
+
+  it "authenticate should return an authenticated user if supplied with valid login details" do
+    user = @user_manager.authenticate("email", "password")
+    user.kind_of?(Sevendigital::User).should == true
+    user.authenticated?.should == true
+  end
+
+  it "authenticate should return nil if user does not authenticate" do
+    @oauth_manager.stub!(:authorise_request_token).and_return(false)
+    user = @user_manager.authenticate("email", "password")
+    user.nil?.should == true
+  end
+
+  it "authenticate should get a request token" do
+    @client.oauth.should_receive(:get_request_token).and_return(nil)
+    @user_manager.authenticate("email", "password")
+  end
+
+  it "authenticate should attempt to authorise request token" do
+    @client.oauth.should_receive(:authorise_request_token).with(@an_email, @a_password, @a_request_token) \
+      .and_return(true)
+    @user_manager.authenticate(@an_email, @a_password)
+  end
+
+  it "authenticate should retrieve access_token for authenticated user" do
+    @client.oauth.should_receive(:get_access_token).with(@a_request_token) \
+      .and_return(@an_access_token)
+    user = @user_manager.authenticate(@an_email, @a_password)
+    user.oauth_access_token.should == @an_access_token
+  end
+
+  def fake_request_token
+    token = stub(OAuth::RequestToken)
+    token.stub(:token).and_return("key")
+    token
+  end
+
+  def fake_access_token
+    token = stub(OAuth::RequestToken)
+    token.stub(:token).and_return("key")
+    token
+  end
+
+  it "get_locker should call user/locker api method and return digested locker" do
+    an_api_response = fake_api_response("user/locker")
+    a_token = OAuth::AccessToken.new(nil, "token", "token_secret")
+    fake_locker = [Sevendigital::LockerRelease.new(@client)]
+
+    mock_client_digestor(@client, :locker_digestor) \
+      .should_receive(:from_xml).with(an_api_response.content.locker).and_return(fake_locker)
+
+    @client.should_receive(:make_signed_api_request) \
+        .with("user/locker", {}, {}, a_token) \
+        .and_return(an_api_response)
+    
+    @user_manager.get_locker(a_token).should == fake_locker
+
+  end
+
+  it "purchase should call user/purchase/item api method and return digested locker items" do
+    an_api_response = fake_api_response("user/purchase/item")
+    a_track_id = 123456
+    a_release_id = 56879
+    a_price = 0.99
+    a_token = OAuth::AccessToken.new(nil, "token", "token_secret")
+    fake_locker = [Sevendigital::LockerRelease.new(@client)]
+
+    mock_client_digestor(@client, :locker_digestor) \
+      .should_receive(:from_xml).with(an_api_response.content.purchase).and_return(fake_locker)
+
+    @client.should_receive(:make_signed_api_request) \
+           .with("user/purchase/item", \
+                {:trackId => a_track_id, :releaseId => a_release_id, :price => a_price}, \
+                {}, a_token) \
+           .and_return(an_api_response)
+
+    @user_manager.purchase(a_release_id, a_track_id, a_price, a_token).should == fake_locker
+
+  end
+
+  it "should get stream track URI" do
+    a_stream_track_uri = "http://media.com/streamtrack"
+    a_track_id = 123456
+    a_release_id = 78910
+    a_token = OAuth::AccessToken.new(nil, "token", "token_secret")
+    an_api_request = stub(Sevendigital::ApiRequest)
+
+    @client.should_receive(:create_api_request) \
+      .with("user/streamtrack", {:trackId => a_track_id, :releaseId => a_release_id}, {}) \
+      .and_return(an_api_request)
+
+    an_api_request.should_receive(:api_service=).with(:media)
+    an_api_request.should_receive(:require_signature)
+    an_api_request.should_not_receive(:require_secure_connection)
+    an_api_request.should_receive(:token=).with(a_token)
+
+    @client.operator.should_receive(:get_request_uri) \
+      .with(an_api_request) \
+      .and_return(a_stream_track_uri)
+
+    @user_manager.get_stream_track_url(a_release_id, a_track_id, a_token).should == a_stream_track_uri
+
+  end
+
+  it "should get add card URI" do
+    an_add_card_uri = "http://account.com/addcard"
+    a_token = OAuth::AccessToken.new(nil, "token", "token_secret")
+    a_return_url = "http://example.com/"
+     an_api_request = stub(Sevendigital::ApiRequest)
+
+    @client.should_receive(:create_api_request) \
+      .with("payment/addcard", {:returnUrl => a_return_url}, {}) \
+      .and_return(an_api_request)
+
+    an_api_request.should_receive(:api_service=).with(:account)
+    an_api_request.should_receive(:require_signature)
+    an_api_request.should_receive(:require_secure_connection)
+    an_api_request.should_receive(:token=).with(a_token)
+
+    @client.operator.should_receive(:get_request_uri) \
+      .with(an_api_request) \
+      .and_return(an_add_card_uri)
+
+    @user_manager.get_add_card_url(a_return_url, a_token).should == an_add_card_uri
+
+  end
+
+
+end