7digital 0.1.2 → 0.1.5

data/spec/management/tag_manager_spec.rb

@@ -1,34 +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_doc).with(an_api_response.item_xml("tags") ).and_return(a_tag_list)
-
-    @client.should_receive(:make_api_request) \
-                   .with(:GET, "tag", {}, {}) \
-                   .and_return(an_api_response)
-
-
-    tags = @tag_manager.get_tag_list
-    tags.should == a_tag_list
-  end
-
-
-end
+# 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_doc).with(an_api_response.item_xml("tags") ).and_return(a_tag_list)
+
+    @client.should_receive(:make_api_request) \
+                   .with(:GET, "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,107 +1,111 @@
-# encoding: UTF-8
-require 'date'
-require File.expand_path('../../spec_helper', __FILE__)
-
-describe "TrackManager" do
-
-  before do
-
-    @client = stub(Sevendigital::Client)
-    @client.stub!(:operator).and_return(mock(Sevendigital::ApiOperator))
-    @track_manager = Sevendigital::TrackManager.new(@client)
-
-  end
-
-  it "get_details should call track/details api method and return digested track" do
-    a_track_id = 123
-    an_api_response = fake_api_response("track/details")
-    a_track = Sevendigital::Track.new(@client)
-
-    mock_client_digestor(@client, :track_digestor) \
-      .should_receive(:from_xml_doc).with(an_api_response.item_xml("track")).and_return(a_track)
-
-    @client.should_receive(:make_api_request) \
-                 .with(:GET, "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
-    track_3 = Sevendigital::Track.new(@client)
-    track_3.id = 3
-    a_track_list = [track_1, track_2, track_3]
-    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_2.id, a_release_id, options)
-    track.should == track_2
-  end
-
-  it "get_chart should call track/chart api method and digest the release list from response" do
-
-    an_api_response = fake_api_response("track/chart")
-    a_chart = []
-
-    mock_client_digestor(@client, :chart_item_digestor) \
-        .should_receive(:list_from_xml_doc).with(an_api_response.item_xml("chart")).and_return(a_chart)
-
-    @client.should_receive(:make_api_request) \
-                   .with(:GET, "track/chart", {}, {}) \
-                   .and_return(an_api_response)
-
-
-    chart = @track_manager.get_chart
-    chart.should == a_chart
-  end
-
-  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.should_receive(:create_api_request) \
-                   .with(:GET, "track/preview", {:trackId => track_id}, {}) \
-                   .and_return(fake_api_request)
-
-    @client.operator.should_receive(:get_request_uri) \
-      .with(fake_api_request) \
-      .and_return(fake_preview_url)
-
-    preview_url = @track_manager.build_preview_url(track_id)
-
-    preview_url.should == fake_preview_url
-  end
-
-  it "search should call track/search api method and digest the nested track list from response" do
-
-    query = "radiohead"
-    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_doc) \
-      .with(an_api_response.item_xml("searchResults"), :searchResult, :track) \
-      .and_return(a_track_list)
-
-    @client.should_receive(:make_api_request) \
-                   .with(:GET, "track/search", {:q => query}, {}) \
-                   .and_return(an_api_response)
-    
-    tracks = @track_manager.search(query)
-    tracks.should == a_track_list
-
-  end
-
-
-end
+# encoding: UTF-8
+require 'date'
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "TrackManager" do
+
+  before do
+
+    @client = stub(Sevendigital::Client)
+    @client.stub!(:operator).and_return(mock(Sevendigital::ApiOperator))
+    @track_manager = Sevendigital::TrackManager.new(@client)
+
+  end
+
+  it "get_details should call track/details api method and return digested track" do
+    a_track_id = 123
+    an_api_response = fake_api_response("track/details")
+    a_track = Sevendigital::Track.new(@client)
+
+    mock_client_digestor(@client, :track_digestor) \
+      .should_receive(:from_xml_doc).with(an_api_response.item_xml("track")).and_return(a_track)
+
+    @client.should_receive(:make_api_request) \
+                 .with(:GET, "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
+    track_3 = Sevendigital::Track.new(@client)
+    track_3.id = 3
+    a_track_list = [track_1, track_2, track_3]
+    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_2.id, a_release_id, options)
+    track.should == track_2
+  end
+
+  it "get_chart should call track/chart api method and digest the release list from response" do
+
+    an_api_response = fake_api_response("track/chart")
+    a_chart = []
+
+    mock_client_digestor(@client, :chart_item_digestor) \
+        .should_receive(:list_from_xml_doc).with(an_api_response.item_xml("chart")).and_return(a_chart)
+
+    @client.should_receive(:make_api_request) \
+                   .with(:GET, "track/chart", {}, {}) \
+                   .and_return(an_api_response)
+
+
+    chart = @track_manager.get_chart
+    chart.should == a_chart
+  end
+
+  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.should_receive(:create_api_request) \
+                   .with(:GET, "clip/#{track_id}", {}, {}) \
+                   .and_return(fake_api_request)
+
+    fake_api_request.should_receive(:api_service=).with(:previews)
+    fake_api_request.should_receive(:require_signature)
+
+
+    @client.operator.should_receive(:get_request_uri) \
+      .with(fake_api_request) \
+      .and_return(fake_preview_url)
+
+    preview_url = @track_manager.build_preview_url(track_id)
+
+    preview_url.should == fake_preview_url
+  end
+
+  it "search should call track/search api method and digest the nested track list from response" do
+
+    query = "radiohead"
+    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_doc) \
+      .with(an_api_response.item_xml("searchResults"), :searchResult, :track) \
+      .and_return(a_track_list)
+
+    @client.should_receive(:make_api_request) \
+                   .with(:GET, "track/search", {:q => query}, {}) \
+                   .and_return(an_api_response)
+    
+    tracks = @track_manager.search(query)
+    tracks.should == a_track_list
+
+  end
+
+
+end

data/spec/management/user_card_manager_spec.rb

@@ -1,79 +1,79 @@
-require File.expand_path('../../spec_helper', __FILE__)
-
-describe "UserCardManager" do
-
-  before do
-    @client = stub(Sevendigital::Client)
-    @client.stub!(:operator).and_return(mock(Sevendigital::ApiOperator))
-    @card_manager = Sevendigital::UserCardManager.new(@client)
-  end
-
-  it "get_card_list should call user/payment/card api method and return list of cards" do
-    a_token = OAuth::AccessToken.new(nil, "token", "token_secret")
-    a_card_list = [Sevendigital::Card.new(@client)]
-    an_api_response = fake_api_response("user/payment/card/index")
-    options = {:pagesize => 20 }
-
-    mock_client_digestor(@client, :user_card_digestor) \
-          .should_receive(:list_from_xml_doc).with(an_api_response.item_xml("cards")).and_return(a_card_list)
-
-    @client.should_receive(:make_signed_api_request) \
-              .with(:GET, "user/payment/card", {}, options, a_token) \
-              .and_return(an_api_response)
-
-    cards = @card_manager.get_card_list(a_token, options)
-    cards.should == a_card_list
-  end
-
-  it "add_card should call user/payment/card/add api method and return the added card" do
-    card_number = "4444333322221111"
-    card_type = "VISA"
-    card_holder_name = "Mr John Simth"
-    card_start_date = "200909"
-    card_expiry_date = "201109"
-    card_issue_number = "1"
-    card_verification_code ="123"
-    card_post_code = "EC2A 4HJ"
-    card_country = "GB"
-    a_token = OAuth::AccessToken.new(nil, "token", "token_secret")
-    a_card = Sevendigital::Card.new(@client)
-    an_api_response = fake_api_response("user/payment/card/add")
-    options = {:pagesize => 20 }
-
-    mock_client_digestor(@client, :user_card_digestor) \
-          .should_receive(:from_xml_doc).with(an_api_response.item_xml("card")).and_return(a_card)
-
-    @client.should_receive(:make_signed_api_request) \
-              .with(:POST, "user/payment/card/add", {
-                  :cardNumber => card_number,
-                  :cardType => card_type,
-                  :cardHolderName => card_holder_name,
-                  :cardStartDate => card_start_date,
-                  :cardExpiryDate => card_expiry_date,
-                  :cardIssueNumber => card_issue_number,
-                  :cardVerificationCode => card_verification_code,
-                  :cardPostCode => card_post_code,
-                  :cardCountry => card_country
-                }, options, a_token) \
-              .and_return(an_api_response)
-
-    card = @card_manager.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, a_token, options)
-    card.should == a_card
-  end
-
-  it "select_card should call user/payment/card/select api method and return true if successful " do
-    card_id = 123
-    a_token = OAuth::AccessToken.new(nil, "token", "token_secret")
-    an_api_response = fake_api_response("user/payment/card/select")
-    options = {:pagesize => 20 }
-
-    @client.should_receive(:make_signed_api_request) \
-              .with(:POST, "user/payment/card/select", {:cardId => card_id}, options, a_token) \
-              .and_return(an_api_response)
-
-    @card_manager.select_card(card_id, a_token, options).should == true
-  end
-
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "UserCardManager" do
+
+  before do
+    @client = stub(Sevendigital::Client)
+    @client.stub!(:operator).and_return(mock(Sevendigital::ApiOperator))
+    @card_manager = Sevendigital::UserCardManager.new(@client)
+  end
+
+  it "get_card_list should call user/payment/card api method and return list of cards" do
+    a_token = OAuth::AccessToken.new(nil, "token", "token_secret")
+    a_card_list = [Sevendigital::Card.new(@client)]
+    an_api_response = fake_api_response("user/payment/card/index")
+    options = {:pagesize => 20 }
+
+    mock_client_digestor(@client, :user_card_digestor) \
+          .should_receive(:list_from_xml_doc).with(an_api_response.item_xml("cards")).and_return(a_card_list)
+
+    @client.should_receive(:make_signed_api_request) \
+              .with(:GET, "user/payment/card", {}, options, a_token) \
+              .and_return(an_api_response)
+
+    cards = @card_manager.get_card_list(a_token, options)
+    cards.should == a_card_list
+  end
+
+  it "add_card should call user/payment/card/add api method and return the added card" do
+    card_number = "4444333322221111"
+    card_type = "VISA"
+    card_holder_name = "Mr John Simth"
+    card_start_date = "200909"
+    card_expiry_date = "201109"
+    card_issue_number = "1"
+    card_verification_code ="123"
+    card_post_code = "EC2A 4HJ"
+    card_country = "GB"
+    a_token = OAuth::AccessToken.new(nil, "token", "token_secret")
+    a_card = Sevendigital::Card.new(@client)
+    an_api_response = fake_api_response("user/payment/card/add")
+    options = {:pagesize => 20 }
+
+    mock_client_digestor(@client, :user_card_digestor) \
+          .should_receive(:from_xml_doc).with(an_api_response.item_xml("card")).and_return(a_card)
+
+    @client.should_receive(:make_signed_api_request) \
+              .with(:POST, "user/payment/card/add", {
+                  :cardNumber => card_number,
+                  :cardType => card_type,
+                  :cardHolderName => card_holder_name,
+                  :cardStartDate => card_start_date,
+                  :cardExpiryDate => card_expiry_date,
+                  :cardIssueNumber => card_issue_number,
+                  :cardVerificationCode => card_verification_code,
+                  :cardPostCode => card_post_code,
+                  :cardCountry => card_country
+                }, options, a_token) \
+              .and_return(an_api_response)
+
+    card = @card_manager.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, a_token, options)
+    card.should == a_card
+  end
+
+  it "select_card should call user/payment/card/select api method and return true if successful " do
+    card_id = 123
+    a_token = OAuth::AccessToken.new(nil, "token", "token_secret")
+    an_api_response = fake_api_response("user/payment/card/select")
+    options = {:pagesize => 20 }
+
+    @client.should_receive(:make_signed_api_request) \
+              .with(:POST, "user/payment/card/select", {:cardId => card_id}, options, a_token) \
+              .and_return(an_api_response)
+
+    @card_manager.select_card(card_id, a_token, options).should == true
+  end
+
 end

data/spec/management/user_manager_spec.rb

@@ -1,219 +1,219 @@
-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 "get_details should call user/details api method and return user's email" do
-    an_api_response = fake_api_response("user/details")
-    a_token = OAuth::AccessToken.new(nil, "token", "token_secret")
-    fake_user = [Sevendigital::User.new(@client)]
-    options = {:sort => "random"}
-
-    mock_client_digestor(@client, :user_digestor) \
-      .should_receive(:from_xml_doc).with(an_api_response.item_xml("user")).and_return(fake_user)
-
-    @client.should_receive(:make_signed_api_request) \
-        .with(:GET, "user/details", {}, options, a_token) \
-        .and_return(an_api_response)
-
-    @user_manager.get_details(a_token, options).should == fake_user
-  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 "sign_up should call user/signUp api method and return signed up and authenticated user" do
-    an_api_response = fake_api_response("user/signup")
-    fake_user = Sevendigital::User.new(@client)
-    options = {:country => "XX"}
-
-    mock_client_digestor(@client, :user_digestor) \
-      .should_receive(:from_xml_doc).with(an_api_response.item_xml("user")).and_return(fake_user)
-
-    @client.should_receive(:make_signed_api_request) \
-        .with(:POST, "user/signUp", {:emailAddress => @an_email, :password => @a_password}, options) \
-        .and_return(an_api_response)
-    
-    user = @user_manager.sign_up(@an_email, @a_password, options)
-    user.should == fake_user
-    user.authenticated?.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)]
-    options = {:sort => "random"}
-
-    mock_client_digestor(@client, :locker_digestor) \
-      .should_receive(:from_xml_doc).with(an_api_response.item_xml("locker")).and_return(fake_locker)
-
-    @client.should_receive(:make_signed_api_request) \
-        .with(:GET, "user/locker", {}, options, a_token) \
-        .and_return(an_api_response)
-    
-    @user_manager.get_locker(a_token, options).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_doc).with(an_api_response.item_xml("purchase")).and_return(fake_locker)
-
-    @client.should_receive(:make_signed_api_request) \
-           .with(:GET, "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 "purchase_basket should call user/purchase/basket api method and return digested locker items" do
-    an_api_response = fake_api_response("user/purchase/basket")
-    a_basket_id = 123456
-    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_doc).with(an_api_response.item_xml("purchase")).and_return(fake_locker)
-
-    @client.should_receive(:make_signed_api_request) \
-           .with(:GET, "user/purchase/basket", \
-                {:basketId => a_basket_id}, \
-                {}, a_token) \
-           .and_return(an_api_response)
-
-    @user_manager.purchase_basket(a_basket_id, 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(:GET, "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(:GET, "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
-
-
+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 "get_details should call user/details api method and return user's email" do
+    an_api_response = fake_api_response("user/details")
+    a_token = OAuth::AccessToken.new(nil, "token", "token_secret")
+    fake_user = [Sevendigital::User.new(@client)]
+    options = {:sort => "random"}
+
+    mock_client_digestor(@client, :user_digestor) \
+      .should_receive(:from_xml_doc).with(an_api_response.item_xml("user")).and_return(fake_user)
+
+    @client.should_receive(:make_signed_api_request) \
+        .with(:GET, "user/details", {}, options, a_token) \
+        .and_return(an_api_response)
+
+    @user_manager.get_details(a_token, options).should == fake_user
+  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 "sign_up should call user/signUp api method and return signed up and authenticated user" do
+    an_api_response = fake_api_response("user/signup")
+    fake_user = Sevendigital::User.new(@client)
+    options = {:country => "XX"}
+
+    mock_client_digestor(@client, :user_digestor) \
+      .should_receive(:from_xml_doc).with(an_api_response.item_xml("user")).and_return(fake_user)
+
+    @client.should_receive(:make_signed_api_request) \
+        .with(:POST, "user/signUp", {:emailAddress => @an_email, :password => @a_password}, options) \
+        .and_return(an_api_response)
+    
+    user = @user_manager.sign_up(@an_email, @a_password, options)
+    user.should == fake_user
+    user.authenticated?.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)]
+    options = {:sort => "random"}
+
+    mock_client_digestor(@client, :locker_digestor) \
+      .should_receive(:from_xml_doc).with(an_api_response.item_xml("locker")).and_return(fake_locker)
+
+    @client.should_receive(:make_signed_api_request) \
+        .with(:GET, "user/locker", {}, options, a_token) \
+        .and_return(an_api_response)
+    
+    @user_manager.get_locker(a_token, options).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_doc).with(an_api_response.item_xml("purchase")).and_return(fake_locker)
+
+    @client.should_receive(:make_signed_api_request) \
+           .with(:GET, "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 "purchase_basket should call user/purchase/basket api method and return digested locker items" do
+    an_api_response = fake_api_response("user/purchase/basket")
+    a_basket_id = 123456
+    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_doc).with(an_api_response.item_xml("purchase")).and_return(fake_locker)
+
+    @client.should_receive(:make_signed_api_request) \
+           .with(:GET, "user/purchase/basket", \
+                {:basketId => a_basket_id}, \
+                {}, a_token) \
+           .and_return(an_api_response)
+
+    @user_manager.purchase_basket(a_basket_id, 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(:GET, "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(:GET, "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