musicbrainz 0.7.7 → 0.8.0

data/spec/models/base_model_spec.rb

@@ -1,45 +1,73 @@
-# -*- encoding: utf-8 -*-
-
 require "spec_helper"
 
 describe MusicBrainz::BaseModel do
   describe '#validate_type' do
     describe 'Date' do
+      let(:xml) {
+        Nokogiri::XML.parse(response)
+      }
+      let(:bindings) {
+        MusicBrainz::Bindings::ReleaseGroup.parse(xml)
+      }
+      let(:release_group) {
+        MusicBrainz::ReleaseGroup.new(bindings)
+      }
+
       context 'nil value' do
+        let(:response) {
+          <<-XML
+            <release-group>
+              <first-release-date></first-release-date>
+            </release-group>
+          XML
+        }
+
         it 'returns 2030-12-31' do
-          response = '<release-group><first-release-date></first-release-date></release-group>'
-          xml = Nokogiri::XML.parse(response)
-          release_group = MusicBrainz::ReleaseGroup.new MusicBrainz::Bindings::ReleaseGroup.parse(xml)
-          release_group.first_release_date.should == Date.new(2030, 12, 31)
+          expect(release_group.first_release_date).to eq Date.new(2030, 12, 31)
         end
       end
-      
+
       context 'year only' do
+        let(:response) {
+          <<-XML
+            <release-group>
+              <first-release-date>1995</first-release-date>
+            </release-group>
+          XML
+        }
+
         it 'returns 1995-12-31' do
-          response = '<release-group><first-release-date>1995</first-release-date></release-group>'
-          xml = Nokogiri::XML.parse(response)
-          release_group = MusicBrainz::ReleaseGroup.new MusicBrainz::Bindings::ReleaseGroup.parse(xml)
-          release_group.first_release_date.should == Date.new(1995, 12, 31)
+          expect(release_group.first_release_date).to eq Date.new(1995, 12, 31)
         end
       end
-      
+
       context 'year and month only' do
+        let(:response) {
+          <<-XML
+            <release-group>
+              <first-release-date>1995-04</first-release-date>
+            </release-group>
+          XML
+        }
+
         it 'returns 1995-04-30' do
-          response = '<release-group><first-release-date>1995-04</first-release-date></release-group>'
-          xml = Nokogiri::XML.parse(response)
-          release_group = MusicBrainz::ReleaseGroup.new MusicBrainz::Bindings::ReleaseGroup.parse(xml)
-          release_group.first_release_date.should == Date.new(1995, 4, 30)
+          expect(release_group.first_release_date).to eq Date.new(1995, 4, 30)
         end
       end
-      
+
       context 'year, month and day' do
+        let(:response) {
+          <<-XML
+            <release-group>
+              <first-release-date>1995-04-30</first-release-date>
+            </release-group>
+          XML
+        }
+
         it 'returns 1995-04-30' do
-          response = '<release-group><first-release-date>1995-04-30</first-release-date></release-group>'
-          xml = Nokogiri::XML.parse(response)
-          release_group = MusicBrainz::ReleaseGroup.new MusicBrainz::Bindings::ReleaseGroup.parse(xml)
-          release_group.first_release_date.should == Date.new(1995, 4, 30)
+          expect(release_group.first_release_date).to eq Date.new(1995, 4, 30)
         end
       end
     end
   end
-end
+end

data/spec/models/recording_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+
+describe MusicBrainz::Recording do
+  describe '.find' do
+    before(:each) {
+      mock url: 'http://musicbrainz.org/ws/2/recording/b3015bab-1540-4d4e-9f30-14872a1525f7?',
+           fixture: 'recording/find_b3015bab-1540-4d4e-9f30-14872a1525f7.xml'
+    }
+    let(:recording) {
+      MusicBrainz::Recording.find("b3015bab-1540-4d4e-9f30-14872a1525f7")
+    }
+
+    it "gets no exception while loading release info" do
+      expect{ recording }.to_not raise_error(Exception)
+    end
+
+    it "gets correct instance" do
+      expect(recording).to be_an_instance_of(MusicBrainz::Recording)
+    end
+
+    it "gets correct track data" do
+      expect(recording.title).to eq "Empire"
+    end
+  end
+
+  describe '.search' do
+    before(:each) {
+      mock url: 'http://musicbrainz.org/ws/2/recording?query=recording:"Bound+for+the+floor" AND artist:"Local+H"&limit=10',
+           fixture: 'recording/search_bound_for_the_floor_local_h.xml'
+    }
+    let(:matches) {
+      MusicBrainz::Recording.search('Bound for the floor', 'Local H')
+    }
+
+    it "searches tracks (aka recordings) by artist name and title" do
+      expect(matches).to_not be_empty
+      expect(matches.first[:id]).to eq 'bb940e26-4265-4909-b128-4906d8b1079e'
+      expect(matches.first[:title]).to eq "Bound for the Floor"
+      expect(matches.first[:artist]).to eq "Local H"
+    end
+  end
+end

data/spec/models/release_group_spec.rb

@@ -1,85 +1,91 @@
-# -*- encoding: utf-8 -*-
-
 require "spec_helper"
 
 describe MusicBrainz::ReleaseGroup do
+  before(:each) {
+    mock url: 'http://musicbrainz.org/ws/2/release-group/6f33e0f0-cde2-38f9-9aee-2c60af8d1a61?inc=url-rels',
+         fixture: 'release_group/find_6f33e0f0-cde2-38f9-9aee-2c60af8d1a61.xml'
+
+    mock url: 'http://musicbrainz.org/ws/2/release-group?query=artist:"Kasabian" AND releasegroup:"Empire"&limit=10',
+             fixture: 'release_group/search_kasabian_empire.xml'
+
+    mock url: 'http://musicbrainz.org/ws/2/release-group?query=artist:"Kasabian" AND releasegroup:"Empire" AND type:"Album"&limit=10',
+             fixture: 'release_group/search_kasabian_empire_album.xml'
+
+    mock url: 'http://musicbrainz.org/ws/2/release?release-group=6f33e0f0-cde2-38f9-9aee-2c60af8d1a61&inc=media+release-groups&limit=100',
+         fixture: 'release/list_6f33e0f0-cde2-38f9-9aee-2c60af8d1a61.xml'
+  }
+
   describe '.find' do
+    let(:release_group) {
+      MusicBrainz::ReleaseGroup.find("6f33e0f0-cde2-38f9-9aee-2c60af8d1a61")
+    }
+
     it "gets no exception while loading release group info" do
-      lambda {
-        MusicBrainz::ReleaseGroup.find("6f33e0f0-cde2-38f9-9aee-2c60af8d1a61")
-      }.should_not raise_error(Exception)
+      expect { release_group }.to_not raise_error(Exception)
     end
-  
+
     it "gets correct instance" do
-      release_group = MusicBrainz::ReleaseGroup.find("6f33e0f0-cde2-38f9-9aee-2c60af8d1a61")
-      release_group.should be_an_instance_of(MusicBrainz::ReleaseGroup)
+      expect(release_group).to be_an_instance_of(MusicBrainz::ReleaseGroup)
     end
-  
+
     it "gets correct release group data" do
-      release_group = MusicBrainz::ReleaseGroup.find("6f33e0f0-cde2-38f9-9aee-2c60af8d1a61")
-      release_group.id.should == "6f33e0f0-cde2-38f9-9aee-2c60af8d1a61"
-      release_group.type.should == "Album"
-      release_group.title.should == "Empire"
-      release_group.first_release_date.should == Date.new(2006, 8, 28)
-      release_group.urls[:wikipedia].should == 'http://en.wikipedia.org/wiki/Empire_(Kasabian_album)'
+      expect(release_group.id).to eq "6f33e0f0-cde2-38f9-9aee-2c60af8d1a61"
+      expect(release_group.type).to eq "Album"
+      expect(release_group.title).to eq "Empire"
+      expect(release_group.first_release_date).to eq Date.new(2006, 8, 28)
+      expect(release_group.urls[:wikipedia]).to eq 'http://en.wikipedia.org/wiki/Empire_(Kasabian_album)'
     end
   end
-  
+
   describe '.search' do
     context 'without type filter' do
+      let(:matches) {
+        MusicBrainz::ReleaseGroup.search('Kasabian', 'Empire')
+      }
+
       it "searches release group by artist name and title" do
-        response = File.open(File.join(File.dirname(__FILE__), "../fixtures/release_group/search.xml")).read
-        MusicBrainz::Client.any_instance.stub(:get_contents).with('http://musicbrainz.org/ws/2/release-group?query=artist:"Kasabian" AND releasegroup:"Empire"&limit=10').
-        and_return({ status: 200, body: response})
-          
-        matches = MusicBrainz::ReleaseGroup.search('Kasabian', 'Empire')
-        matches.length.should be > 0
-        matches.first[:title].should == 'Empire'
-        matches.first[:type].should == 'Album'
+        expect(matches.length).to be > 0
+        expect(matches.first[:title]).to eq 'Empire'
+        expect(matches.first[:type]).to eq 'Album'
       end
     end
-    
+
     context 'with type filter' do
+      let(:matches) {
+        MusicBrainz::ReleaseGroup.search('Kasabian', 'Empire', 'Album')
+      }
+
       it "searches release group by artist name and title" do
-        matches = MusicBrainz::ReleaseGroup.search('Kasabian', 'Empire', 'Album')
-        matches.length.should be > 0
-        matches.first[:title].should == 'Empire'
-        matches.first[:type].should == 'Album'
+        expect(matches.length).to be > 0
+        expect(matches.first[:title]).to eq 'Empire'
+        expect(matches.first[:type]).to eq 'Album'
       end
     end
   end
-  
+
   describe '.find_by_artist_and_title' do
+    let(:release_group) {
+      MusicBrainz::ReleaseGroup.find_by_artist_and_title('Kasabian', 'Empire')
+    }
+
     it "gets first release group by artist name and title" do
-      response = File.open(File.join(File.dirname(__FILE__), "../fixtures/release_group/search.xml")).read
-      MusicBrainz::Client.any_instance.stub(:get_contents).with('http://musicbrainz.org/ws/2/release-group?query=artist:"Kasabian" AND releasegroup:"Empire"&limit=10').
-      and_return({ status: 200, body: response})
-      
-      response = File.open(File.join(File.dirname(__FILE__), "../fixtures/release_group/entity.xml")).read
-      MusicBrainz::Client.any_instance.stub(:get_contents).with('http://musicbrainz.org/ws/2/release-group/6f33e0f0-cde2-38f9-9aee-2c60af8d1a61?inc=url-rels').
-      and_return({ status: 200, body: response})
-      
-      release_group = MusicBrainz::ReleaseGroup.find_by_artist_and_title('Kasabian', 'Empire')
-      release_group.id.should == '6f33e0f0-cde2-38f9-9aee-2c60af8d1a61'
+      expect(release_group.id).to eq '6f33e0f0-cde2-38f9-9aee-2c60af8d1a61'
     end
   end
-  
+
   describe '#releases' do
+    let(:releases) {
+      MusicBrainz::ReleaseGroup.find("6f33e0f0-cde2-38f9-9aee-2c60af8d1a61").releases
+    }
+
     it "gets correct release group's releases" do
-      MusicBrainz::Client.any_instance.stub(:get_contents).with('http://musicbrainz.org/ws/2/release-group/6f33e0f0-cde2-38f9-9aee-2c60af8d1a61?inc=url-rels').
-      and_return({ status: 200, body: File.open(File.join(File.dirname(__FILE__), "../fixtures/release_group/entity.xml")).read})
-      
-      MusicBrainz::Client.any_instance.stub(:get_contents).with('http://musicbrainz.org/ws/2/release?release-group=6f33e0f0-cde2-38f9-9aee-2c60af8d1a61&inc=media+release-groups&limit=100').
-      and_return({ status: 200, body: File.open(File.join(File.dirname(__FILE__), "../fixtures/release/list.xml")).read})
-      
-      releases = MusicBrainz::ReleaseGroup.find("6f33e0f0-cde2-38f9-9aee-2c60af8d1a61").releases
-      releases.length.should be >= 5
-      releases.first.id.should == "30d5e730-ce0a-464d-93e1-7d76e4bb3e31"
-      releases.first.status.should == "Official"
-      releases.first.title.should == "Empire"
-      releases.first.date.should == Date.new(2006, 8, 28)
-      releases.first.country.should == "GB"
-      releases.first.type.should == "Album"
+      expect(releases.length).to be >= 5
+      expect(releases.first.id).to eq "2225dd4c-ae9a-403b-8ea0-9e05014c778f"
+      expect(releases.first.status).to eq "Official"
+      expect(releases.first.title).to eq "Empire"
+      expect(releases.first.date).to eq Date.new(2006, 8, 28)
+      expect(releases.first.country).to eq "GB"
+      expect(releases.first.type).to eq "Album"
     end
   end
 end

data/spec/models/release_spec.rb

@@ -1,38 +1,73 @@
-# -*- encoding: utf-8 -*-
-
 require "spec_helper"
 
 describe MusicBrainz::Release do
-  it "gets no exception while loading release info" do
-    lambda {
-      MusicBrainz::Release.find("2225dd4c-ae9a-403b-8ea0-9e05014c778f")
-    }.should_not raise_error(Exception)
-  end
+  before(:each) {
+    mock url: 'http://musicbrainz.org/ws/2/release/2225dd4c-ae9a-403b-8ea0-9e05014c778f?inc=media+release-groups',
+         fixture: 'release/find_2225dd4c-ae9a-403b-8ea0-9e05014c778f.xml'
+
+    mock url: 'http://musicbrainz.org/ws/2/release/2225dd4c-ae9a-403b-8ea0-9e05014c778f?inc=recordings+media&limit=100',
+         fixture: 'release/find_2225dd4c-ae9a-403b-8ea0-9e05014c778f_tracks.xml'
+
+    mock url: 'http://musicbrainz.org/ws/2/release/b94cb547-cf7a-4357-894c-53c3bf33b093?inc=media+release-groups',
+         fixture: 'release/find_b94cb547-cf7a-4357-894c-53c3bf33b093.xml'
+
+    mock url: 'http://musicbrainz.org/ws/2/discid/pmzhT6ZlFiwSRCdVwV0eqire5_Y-?',
+         fixture: 'release/find_by_discid_pmzhT6ZlFiwSRCdVwV0eqire5_Y-.xml'
+  }
 
-  it "gets correct instance" do
-    release = MusicBrainz::Release.find("2225dd4c-ae9a-403b-8ea0-9e05014c778f")
-    release.should be_an_instance_of(MusicBrainz::Release)
+  describe '.find' do
+    let(:release) {
+      MusicBrainz::Release.find("b94cb547-cf7a-4357-894c-53c3bf33b093")
+    }
+
+    it "gets no exception while loading release info" do
+      expect { release }.to_not raise_error(Exception)
+    end
+
+    it "gets correct instance" do
+      expect(release).to be_an_instance_of(MusicBrainz::Release)
+    end
+
+    it "gets correct release data" do
+      expect(release.id).to eq "b94cb547-cf7a-4357-894c-53c3bf33b093"
+      expect(release.title).to eq "Humanoid"
+      expect(release.status).to eq "Official"
+      expect(release.date).to eq Date.new(2009, 10, 6)
+      expect(release.country).to eq "US"
+      expect(release.asin).to eq 'B002NOYX6I'
+      expect(release.barcode).to eq '602527197692'
+      expect(release.quality).to eq 'normal'
+      expect(release.type).to eq 'Album'
+    end
   end
 
-  it "gets correct release data" do
-    release = MusicBrainz::Release.find("b94cb547-cf7a-4357-894c-53c3bf33b093")
-    release.id.should == "b94cb547-cf7a-4357-894c-53c3bf33b093"
-    release.title.should == "Humanoid"
-    release.status.should == "Official"
-    release.date.should == Date.new(2009, 10, 6)
-    release.country.should == "US"
-    release.asin.should == 'B002NOYX6I'
-    release.barcode.should == '602527197692'
-    release.quality.should == 'normal'
-    release.type.should == 'Album'
+  describe '#tracks' do
+    let(:release) {
+      MusicBrainz::Release.find("2225dd4c-ae9a-403b-8ea0-9e05014c778f")
+    }
+    let(:tracks) {
+      release.tracks
+    }
+
+    it "gets correct release tracks" do
+      expect(tracks.length).to eq 11
+      expect(tracks.first.position).to eq 1
+      expect(tracks.first.recording_id).to eq "b3015bab-1540-4d4e-9f30-14872a1525f7"
+      expect(tracks.first.title).to eq "Empire"
+      expect(tracks.first.length).to eq 233013
+    end
   end
 
-  it "gets correct release tracks" do
-    tracks = MusicBrainz::Release.find("2225dd4c-ae9a-403b-8ea0-9e05014c778f").tracks
-    tracks.length.should == 11
-    tracks.first.position.should == 1
-    tracks.first.recording_id.should == "b3015bab-1540-4d4e-9f30-14872a1525f7"
-    tracks.first.title.should == "Empire"
-    tracks.first.length.should == 233013
+  describe '.find_by_discid' do
+    let(:releases) {
+      MusicBrainz::Release.find_by_discid("pmzhT6ZlFiwSRCdVwV0eqire5_Y-")
+    }
+
+    it "gets a list of matching releases for a discid" do
+      expect(releases.length).to eq 2
+      expect(releases.first.id).to eq "7a31cd5f-6a57-4fca-a731-c521df1d3b78"
+      expect(releases.first.title).to eq "Kveikur"
+      expect(releases.first.asin).to eq "B00C1GBOU6"
+    end
   end
 end

data/spec/models/track_spec.rb

@@ -1,23 +1,27 @@
-# -*- encoding: utf-8 -*-
-
 require "spec_helper"
 
 describe MusicBrainz::Track do
-  it "gets no exception while loading release info" do
-    lambda {
+  describe '.find' do
+    before(:each) {
+      mock url: 'http://musicbrainz.org/ws/2/recording/b3015bab-1540-4d4e-9f30-14872a1525f7?',
+           fixture: 'recording/find_b3015bab-1540-4d4e-9f30-14872a1525f7.xml'
+    }
+    let(:track) {
       MusicBrainz::Track.find("b3015bab-1540-4d4e-9f30-14872a1525f7")
-    }.should_not raise_error(Exception)
-  end
+    }
 
-  it "gets correct instance" do
-    track = MusicBrainz::Track.find("b3015bab-1540-4d4e-9f30-14872a1525f7")
-    track.should be_an_instance_of(MusicBrainz::Track)
-  end
+    it "gets no exception while loading release info" do
+      expect { track }.to_not raise_error(Exception)
+    end
+
+    it "gets correct instance" do
+      expect(track).to be_an_instance_of(MusicBrainz::Track)
+    end
 
-  it "gets correct track data" do
-    track = MusicBrainz::Track.find("b3015bab-1540-4d4e-9f30-14872a1525f7")
-    track.recording_id.should == "b3015bab-1540-4d4e-9f30-14872a1525f7"
-    track.title.should == "Empire"
-    track.length.should == 233013
+    it "gets correct track data" do
+      expect(track.recording_id).to eq "b3015bab-1540-4d4e-9f30-14872a1525f7"
+      expect(track.title).to eq "Empire"
+      expect(track.length).to eq 233013
+    end
   end
 end

data/spec/spec_helper.rb

@@ -1,19 +1,19 @@
 require "rubygems"
 require "bundler/setup"
 require "musicbrainz"
+require "pry"
+require "awesome_print"
+require_relative 'support/mock_helpers'
 
 RSpec.configure do |c|
+  include MockHelpers
+
   c.order = 'random'
+  c.color = true
 end
 
 MusicBrainz.configure do |c|
-  test_email = `git config user.email`.chomp
-  test_email = "magnolia_fan@me.com" if test_email.empty?
-
   c.app_name = "MusicBrainzGemTestSuite"
   c.app_version = MusicBrainz::VERSION
-  c.contact = test_email
-
-  c.cache_path = File.join(File.dirname(__FILE__), '..', 'tmp', 'spec_cache')
-  c.perform_caching = true
+  c.contact = "root@localhost"
 end

data/spec/support/mock_helpers.rb

@@ -0,0 +1,13 @@
+module MockHelpers
+	def mock(url:, fixture:)
+    allow_any_instance_of(MusicBrainz::Client).to receive(:get_contents)
+      .with(url)
+      .and_return({ status: 200, body: read_fixture(fixture)})
+	end
+
+	def read_fixture(name)
+		spec_path = File.join(File.dirname(__FILE__), "..")
+		file_path = File.join(spec_path, "fixtures", name)
+		File.open(file_path).read
+	end
+end