7digital 0.0.1

data/spec/management/artist_manager_spec.rb

@@ -0,0 +1,108 @@
+require "spec"
+require "sevendigital"
+
+describe "ArtistManager" do
+
+  before do
+    @client = stub(Sevendigital::Client)
+    @client.stub!(:operator).and_return(mock(Sevendigital::ApiOperator))
+    @artist_manager = Sevendigital::ArtistManager.new(@client)
+  end
+
+  it "get_details should call artist/details api method and return digested artist" do
+    an_artist_id = 123
+    an_artist = Sevendigital::Artist.new(@client)
+    an_api_response = fake_api_response("release/details")
+
+    mock_client_digestor(@client, :artist_digestor) \
+          .should_receive(:from_xml).with(an_api_response.content.artist).and_return(an_artist)
+
+    @client.operator.should_receive(:call_api) { |api_request|
+      api_request.api_method.should == "artist/details"
+      api_request.parameters[:artistId].should  == an_artist_id
+      an_api_response
+    }
+
+    artist = @artist_manager.get_details(an_artist_id)
+    artist.should == an_artist
+	end
+
+  it "get_releases should call artist/releases api method and return list of digested releases" do
+    an_artist_id = 123
+    a_list_of_releases = [Sevendigital::Release.new(@client), Sevendigital::Release.new(@client)]
+    an_api_response = fake_api_response("artist/releases")
+
+    mock_client_digestor(@client, :release_digestor) \
+         .should_receive(:list_from_xml).with(an_api_response.content.releases).and_return(a_list_of_releases)
+
+    @client.operator.should_receive(:call_api) { |api_request|
+      api_request.api_method.should == "artist/releases"
+      api_request.parameters[:artistId].should  == an_artist_id
+      an_api_response
+    }
+
+    releases = @artist_manager.get_releases(an_artist_id)
+    releases.should == a_list_of_releases
+  end
+
+  it "get_top_tracks should call artist/toptracks method and digest the returned list of tracks" do
+    an_artist_id = 123
+    a_top_tracks_list = [Sevendigital::Track.new(@client)]
+    an_api_response = fake_api_response("artist/toptracks")
+    
+    mock_client_digestor(@client, :track_digestor) \
+        .should_receive(:list_from_xml).with(an_api_response.content.tracks).and_return(a_top_tracks_list)
+
+    @client.operator.should_receive(:call_api) { |api_request|
+      api_request.api_method.should == "artist/toptracks"
+      api_request.parameters[:artistId].should  == an_artist_id
+      an_api_response
+    }
+
+    tracks = @artist_manager.get_top_tracks(an_artist_id)
+    tracks.should == a_top_tracks_list
+
+  end
+
+  it "get_similar should call artist/similar method and digest the returned list of artists" do
+    an_artist_id = 123
+    a_similar_artists_list = [Sevendigital::Artist.new(@client), Sevendigital::Artist.new(@client)]
+    an_api_response = fake_api_response("artist/similar")
+
+    mock_client_digestor(@client, :artist_digestor) \
+        .should_receive(:list_from_xml).with(an_api_response.content.artists).and_return(a_similar_artists_list)
+
+    @client.operator.should_receive(:call_api) { |api_request|
+      api_request.api_method.should == "artist/similar"
+      api_request.parameters[:artistId].should  == an_artist_id
+      an_api_response
+    }
+
+    artists = @artist_manager.get_similar(an_artist_id)
+    artists.should == a_similar_artists_list
+
+  end
+
+  it "get_top_by_tag should call artist/byTag/top api method and digest the nested artist list from response" do
+
+    tags = "alternative-indie"
+    api_response = fake_api_response("artist/byTag/top")
+    an_artist_list = []
+
+    mock_client_digestor(@client, :artist_digestor) \
+      .should_receive(:nested_list_from_xml) \
+      .with(api_response.content.tagged_results, :tagged_item, :tagged_results) \
+      .and_return(an_artist_list)
+
+    @client.operator.should_receive(:call_api) { |api_request|
+       api_request.api_method.should == "artist/byTag/top"
+       api_request.parameters[:tags].should == tags
+       api_response
+    }
+
+    releases = @artist_manager.get_top_by_tag(tags)
+    releases.should == an_artist_list
+
+  end
+
+end

data/spec/management/release_manager_spec.rb

@@ -0,0 +1,178 @@
+# encoding: UTF-8
+require 'spec'
+require 'date'
+require 'sevendigital'
+
+describe "ReleaseManager" do
+
+  before do
+
+    @client = stub(Sevendigital::Client)
+    @client.stub!(:operator).and_return(mock(Sevendigital::ApiOperator))
+    @release_manager = Sevendigital::ReleaseManager.new(@client)
+
+  end
+
+  it "should get release by release id" do
+    expected_release_id = 123
+    api_response = fake_api_response("release/details")
+    a_release = Sevendigital::Release.new(@client)
+
+    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
+    }
+
+    @release_manager.get_details(expected_release_id).should == a_release
+
+  end
+
+  it "get_tracks 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_chart should call release/chart api method and digest the release list from response" do
+
+    api_response = fake_api_response("release/chart")
+    a_chart = []
+
+    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
+    }
+
+    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
+
+    from_date = DateTime.new(2010, 01, 01)
+    to_date = DateTime.new(2010, 05, 01)
+    api_response = fake_api_response("release/bydate")
+    a_release_list = []
+
+    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
+    }
+
+    tracks = @release_manager.get_by_date(from_date, to_date)
+    tracks.should == a_release_list
+
+  end
+
+  it "get_by_date should call release/tracks with no parameters and digest the release list from response" do
+
+    api_response = fake_api_response("release/bydate")
+    a_release_list = []
+
+    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
+    }
+
+    tracks = @release_manager.get_by_date
+    tracks.should == a_release_list
+
+  end
+
+  it "get_recommendations should call release/recommend api method and digest the nested release list from response" do
+
+    a_release_id = 123
+    api_response = fake_api_response("release/recommend")
+    a_release_list = []
+
+    mock_client_digestor(@client, :release_digestor) \
+      .should_receive(:nested_list_from_xml) \
+      .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
+    }
+    
+    releases = @release_manager.get_recommendations(a_release_id)
+    releases.should == a_release_list
+
+  end
+
+    it "get_top_by_tag should call release/byTag/top api method and digest the nested release list from response" do
+
+    tags = "alternative-indie"
+    api_response = fake_api_response("release/byTag/top")
+    a_release_list = []
+
+    mock_client_digestor(@client, :release_digestor) \
+      .should_receive(:nested_list_from_xml) \
+      .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
+    }
+
+    releases = @release_manager.get_top_by_tag(tags)
+    releases.should == a_release_list
+
+  end
+
+
+end

data/spec/management/track_manager_spec.rb

@@ -0,0 +1,52 @@
+# encoding: UTF-8
+require 'spec'
+require 'date'
+require 'sevendigital'
+
+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).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
+    }
+
+    @track_manager.get_details(a_track_id).should == a_track
+
+  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")
+    a_chart = []
+
+    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 == "track/chart"
+       api_response
+    }
+
+    chart = @track_manager.get_chart
+    chart.should == a_chart
+  end
+
+
+end

data/spec/model/api_response_spec.rb

@@ -0,0 +1,32 @@
+require "spec"
+require 'sevendigital'
+
+describe "ApiResponse" do
+
+  it "should be ok if error code is 0 and content is not empty" do
+
+    response = Sevendigital::ApiResponse.new
+    response.error_code = 0
+    response.content = '<xml></xml>'
+    response.ok?.should == true
+
+  end
+
+  it "should not be ok if error code is not 0" do
+
+    response = Sevendigital::ApiResponse.new
+    response.error_code = 5
+    response.content = '<xml></xml>'
+    response.ok?.should == false
+
+    end
+
+  it "should not be ok if response content is nil" do
+
+    response = Sevendigital::ApiResponse.new
+    response.error_code = 0
+    response.ok?.should == false
+
+  end
+
+end

data/spec/model/artist_spec.rb

@@ -0,0 +1,122 @@
+require "spec"
+require "date"
+require 'sevendigital'
+
+describe "Artist" do
+
+  before do
+    @client = stub(Sevendigital::Client)
+    @artist_manager = mock(Sevendigital::ArtistManager)
+    @client.stub!(:artist).and_return @artist_manager
+    
+    @artist = Sevendigital::Artist.new(@client)
+    @artist.id = 1234
+  end
+
+  it "get_details should get artist's basic details from manager" do
+    expected_options = {:page => 2}
+    fresh_artist = fake_artist_with_details
+
+    @artist_manager.should_receive(:get_details) { |artist_id, options|
+      artist_id.should == @artist.id
+      (options.keys & expected_options.keys).should == expected_options.keys
+      fresh_artist
+    }
+    @artist.get_details(expected_options)
+    
+    @artist.sort_name.should == fresh_artist.sort_name
+    @artist.image.should == fresh_artist.image
+    @artist.url.should == fresh_artist.url
+   
+  end
+
+  it "get_releases should get releases from manager" do
+    expected_options = {:page => 2}
+   
+    @artist_manager.should_receive(:get_releases) { |artist_id, options|
+      artist_id.should == @artist.id
+      (options.keys & expected_options.keys).should == expected_options.keys
+      fake_release_list
+    }
+    @artist.get_releases(expected_options)
+
+  end
+
+  it "get_releases should link all releases back to artist itself" do
+
+    @artist_manager.should_receive(:get_releases) { |artist_id, options|
+      artist_id.should == @artist.id
+      fake_release_list
+    }
+
+    releases = @artist.get_releases()
+    releases.all?{|release| release.artist == @artist}.should == true
+
+  end
+  
+   it "get_top_tracks should get tracks from manager" do
+    expected_options = {:page => 2}
+   
+    @artist_manager.should_receive(:get_top_tracks) { |artist_id, options|
+      artist_id.should == @artist.id
+      (options.keys & expected_options.keys).should == expected_options.keys
+      fake_track_list
+    }
+    @artist.get_top_tracks(expected_options)
+
+  end
+
+  it "get_top_tracks should link all tracks back to artist itself" do
+
+    @artist_manager.should_receive(:get_top_tracks) { |artist_id, options|
+      artist_id.should == @artist.id
+      fake_track_list
+    }
+
+    tracks = @artist.get_top_tracks()
+
+    tracks.all?{|track| track.artist == @artist}.should == true
+
+  end
+
+   it "get_similar should get similar artists from manager" do
+    expected_options = {:page => 2}
+
+    @artist_manager.should_receive(:get_similar) { |artist_id, options|
+      artist_id.should == @artist.id
+      (options.keys & expected_options.keys).should == expected_options.keys
+      fake_artist_list
+    }
+    @artist.get_similar(expected_options)
+
+  end
+
+  def fake_track_list
+    tracks = Array.new
+    tracks << Sevendigital::Track.new(@client)
+    tracks << Sevendigital::Track.new(@client)
+    tracks
+  end
+
+  def fake_release_list
+    releases = Array.new
+    releases << Sevendigital::Release.new(@client)
+    releases << Sevendigital::Release.new(@client)
+    releases
+  end
+
+  def fake_artist_list
+    artists = Array.new
+    artists << Sevendigital::Artist.new(@client)
+    artists << Sevendigital::Artist.new(@client)
+    artists
+  end
+
+  def fake_artist_with_details
+    artist = Sevendigital::Artist.new(@client)
+    artist.sort_name = "The, The"
+    artist.image = "image"
+    artist.url = "url"
+    artist
+end
+end