discogs-wrapper 1.1.4 → 2.0.0

data/spec/wrapper_methods/get_user_collection_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Discogs::Wrapper do
+
+  before do
+    @wrapper = Discogs::Wrapper.new("some_user_agent")
+    @user_name = "mintfloss"
+  end
+
+  describe ".get_user_collection" do
+
+    before do
+      @http_request = mock(Net::HTTP)
+      @http_response = mock(Net::HTTPResponse, :code => "200", :body => read_sample("user_collection"))
+      @http_response_as_file = mock(StringIO, :read => read_sample("user_collection"))
+      Zlib::GzipReader.should_receive(:new).and_return(@http_response_as_file)
+      @http_request.should_receive(:start).and_return(@http_response)
+      Net::HTTP.should_receive(:new).and_return(@http_request)
+
+      @user_collection = @wrapper.get_user_collection(@user_name)
+    end
+
+    describe "when calling simple collection attributes" do
+
+      it "should have 5 releases per page" do
+        @user_collection.releases.length.should == 5
+      end
+
+      it "should have 309 releases total" do
+        @user_collection.pagination.items.should == 309
+      end
+
+      it "should not have a bogus attribute" do
+        @user_collection.bogus_attr.should be_nil
+      end
+        
+    end
+
+  end
+
+end 

data/spec/wrapper_methods/get_user_folder_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Discogs::Wrapper do
+
+  before do
+    @wrapper = Discogs::Wrapper.new("some_user_agent")
+    @user_name = "mintfloss"
+    @folder_id = 0
+  end
+
+  describe ".get_user_folder" do
+
+    before do
+      @http_request = mock(Net::HTTP)
+      @http_response = mock(Net::HTTPResponse, :code => "200", :body => read_sample("user_folder"))
+      @http_response_as_file = mock(StringIO, :read => read_sample("user_folder"))
+      Zlib::GzipReader.should_receive(:new).and_return(@http_response_as_file)
+      @http_request.should_receive(:start).and_return(@http_response)
+      Net::HTTP.should_receive(:new).and_return(@http_request)
+
+      @user_folder = @wrapper.get_user_folder(@user_name, @folder_id)
+    end
+
+    describe "when calling simple folder attributes" do
+
+      it "should have a name" do
+        @user_folder.name.should == "Uncategorized"
+      end
+
+      it "should have a count" do
+        @user_folder[:count].should == 20
+      end
+
+      it "should not have a bogus attribute" do
+        @user_folder.bogus_attr.should be_nil
+      end
+
+      it "should raise error if attempting to list non-0 folder" do
+        lambda { @wrapper.get_user_folder(@user_name, 1) }.should raise_error(Discogs::AuthenticationError)
+      end
+
+    end
+
+  end
+
+end 

data/spec/wrapper_methods/get_user_folders_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Discogs::Wrapper do
+
+  before do
+    @wrapper = Discogs::Wrapper.new("some_user_agent")
+    @user_name = "mintfloss"
+  end
+
+  describe ".get_user_folders" do
+
+    before do
+      @http_request = mock(Net::HTTP)
+      @http_response = mock(Net::HTTPResponse, :code => "200", :body => read_sample("user_folders"))
+      @http_response_as_file = mock(StringIO, :read => read_sample("user_folders"))
+      Zlib::GzipReader.should_receive(:new).and_return(@http_response_as_file)
+      @http_request.should_receive(:start).and_return(@http_response)
+      Net::HTTP.should_receive(:new).and_return(@http_request)
+
+      @user_folders = @wrapper.get_user_folders(@user_name)
+    end
+
+    describe "when calling simple folders attributes" do
+
+      it "should have 2 folders" do
+        @user_folders.folders.length.should == 2
+      end
+
+      it "should have a name for each folder" do
+        @user_folders.folders[0].name.should == "All"
+        @user_folders.folders[1].name.should == "Uncategorized"
+      end
+
+      it "should not have a bogus attribute" do
+      	@user_folders.bogus_attribute.should be_nil
+      end
+
+    end
+
+  end
+
+end 

data/spec/wrapper_methods/get_user_inventory_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Discogs::Wrapper do
+
+  before do
+    @wrapper = Discogs::Wrapper.new("some_user_agent")
+    @user_name = "abuntine"
+  end
+
+  describe ".get_user_inventory" do
+
+    before do
+      @http_request = mock(Net::HTTP)
+      @http_response = mock(Net::HTTPResponse, :code => "200", :body => read_sample("user_inventory"))
+      @http_response_as_file = mock(StringIO, :read => read_sample("user_inventory"))
+      Zlib::GzipReader.should_receive(:new).and_return(@http_response_as_file)
+      @http_request.should_receive(:start).and_return(@http_response)
+      Net::HTTP.should_receive(:new).and_return(@http_request)
+
+      @user_inventory = @wrapper.get_user_inventory(@user_name)
+    end
+
+    describe "when calling simple inventory attributes" do
+
+      it "should have 1 listing in total" do
+        @user_inventory.listings.length.should == 1
+      end
+
+      it "should have a For Sale listing" do
+        @user_inventory.listings[0].status.should == "For Sale"
+      end
+
+      it "should have a price for the first listing" do
+        @user_inventory.listings[0].price.value.should == 23.0
+      end
+
+      it "should not have a bogus attribute" do
+        @user_inventory.bogus_attr.should be_nil
+      end
+        
+    end
+
+  end
+
+end 

data/spec/wrapper_methods/get_user_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Discogs::Wrapper do
+
+  before do
+    @wrapper = Discogs::Wrapper.new("some_user_agent")
+    @user_name = "abuntine"
+  end
+
+  describe ".get_user" do
+
+    before do
+      @http_request = mock(Net::HTTP)
+      @http_response = mock(Net::HTTPResponse, :code => "200", :body => read_sample("user"))
+      @http_response_as_file = mock(StringIO, :read => read_sample("user"))
+      Zlib::GzipReader.should_receive(:new).and_return(@http_response_as_file)
+      @http_request.should_receive(:start).and_return(@http_response)
+      Net::HTTP.should_receive(:new).and_return(@http_request)
+
+      @user = @wrapper.get_user(@user_name)
+    end
+
+    describe "when calling simple user attributes" do
+
+      it "should have a rank" do
+        @user.rank.should == 1.0
+      end
+
+      it "should have a username" do
+        @user.username.should == "abuntine"
+      end
+
+      it "should have a uri" do
+        @user.uri.should == "http://www.discogs.com/user/abuntine"
+      end
+
+      it "should not have a bogus attribute" do
+      	@user.bogus_attribute.should be_nil
+      end
+
+    end
+
+  end
+
+end 

data/spec/wrapper_methods/get_user_wantlist_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Discogs::Wrapper do
+
+  before do
+    @wrapper = Discogs::Wrapper.new("some_user_agent")
+    @user_name = "mintfloss"
+  end
+
+  describe ".get_user_wantlist" do
+
+    before do
+      @http_request = mock(Net::HTTP)
+      @http_response = mock(Net::HTTPResponse, :code => "200", :body => read_sample("user_wantlist"))
+      @http_response_as_file = mock(StringIO, :read => read_sample("user_wantlist"))
+      Zlib::GzipReader.should_receive(:new).and_return(@http_response_as_file)
+      @http_request.should_receive(:start).and_return(@http_response)
+      Net::HTTP.should_receive(:new).and_return(@http_request)
+
+      @user_wantlist = @wrapper.get_user_wantlist(@user_name)
+    end
+
+    describe "when calling simple wantlist attributes" do
+
+      it "should have 5 wants per page" do
+        @user_wantlist.wants.length.should == 5
+      end
+
+      it "should have 77 wants total" do
+        @user_wantlist.pagination.items.should == 77
+      end
+
+      it "should have a want with a zero rating" do
+        @user_wantlist.wants.first.rating.should == 0
+      end
+
+      it "should have a want with some basic information" do
+        @user_wantlist.wants.first.basic_information.title.should == "18 Jahre Sein / Mach Keine Wellen"
+      end
+
+      it "should not have a bogus attribute" do
+        @user_wantlist.bogus_attr.should be_nil
+      end
+
+    end
+
+  end
+
+end 

data/spec/wrapper_methods/search_spec.rb

@@ -4,323 +4,52 @@ describe Discogs::Wrapper do
 
   before do
     @wrapper = Discogs::Wrapper.new("some_user_agent")
-    @search_term = "slaughter"
-  end
-
-  def mock_search(page)
-    @http_request = mock(Net::HTTP)
-    @http_response = mock(Net::HTTPResponse, :code => "200", :body => valid_search_xml(page))
-    @http_response_as_file = mock(StringIO, :read => valid_search_xml(page))
-    Zlib::GzipReader.should_receive(:new).and_return(@http_response_as_file)
-    @http_request.should_receive(:start).and_return(@http_response)
-    Net::HTTP.should_receive(:new).and_return(@http_request)
+    @search_term = "Winter Falls Over the Land"
+    @search_type = "release"
   end
 
   describe "when asking for search result information" do
 
     before do
-      mock_search(1)
-
-      @search = @wrapper.search(@search_term)
-    end
-
-    describe "when dealing with page information" do
-
-      it "should have a current_page method" do
-        @search.current_page.should == 1
-      end
-
-      it "should be able to report if this is the last page" do
-        @search.last_page?.should be_false
-      end
-
+      @http_request = mock(Net::HTTP)
+      @http_response = mock(Net::HTTPResponse, :code => "200", :body => read_sample("search_results"))
+      @http_response_as_file = mock(StringIO, :read => read_sample("search_results"))
+      Zlib::GzipReader.should_receive(:new).and_return(@http_response_as_file)
+      @http_request.should_receive(:start).and_return(@http_response)
+      Net::HTTP.should_receive(:new).and_return(@http_request)
+
+      @search = @wrapper.search(@search_term, :type => @search_type)
     end
 
     describe "when handling exact results" do
 
-      it "should have the exact results stored as an array" do
-        @search.exactresults.should be_instance_of(Array)
-      end
-
-      it "should be stored as result objects" do
-        @search.exactresults.each do |result|
-          result.should be_instance_of(Discogs::Search::Result)
-        end
-      end
-
-      it "should have a incrementing num for each exact result" do
-        @search.exactresults.each_with_index do |result, index|
-          result.num.should == (index + 1).to_s
-        end
-      end
-
-      it "should have a type for the first result" do
-        @search.exactresults[0].type.should == "artist"
-      end
-
-      it "should have an anv for the fifth result" do
-        @search.exactresults[5].anv.should == "Slaughter"
-      end
-
-      it "should be able to filter all non-artists from exact results" do
-        @search.exact(:artist).should be_instance_of(Array)
-        @search.exact(:artist).length.should == 6
-      end
-
-      it "should be able to filter all non-releases from exact results" do
-        @search.exact(:release).should be_instance_of(Array)
-        @search.exact(:release).length.should == 1
-      end
-
-      it "should be able to filter all non-labels from exact results" do
-        @search.exact(:label).should be_instance_of(Array)
-        @search.exact(:label).length.should == 1
-      end
-
-      it "should return an empty array on a junk filter" do
-        @search.exact(:cheesecake).should be_instance_of(Array)
-        @search.exact(:cheesecake).should be_empty
-      end
-
-      it "should simply return all exact results without a filter" do
-        @search.exact.should be_instance_of(Array)
-        @search.exact.length.should == 8
-      end
-
-      it "should have a shortcut for accessing the first exact artist" do
-        @search.closest(:artist).should be_instance_of(Discogs::Search::Result)
-        @search.closest(:artist).should == @search.exact(:artist)[0]
-      end
-
-      it "should have a shortcut for accessing the first exact release" do
-        @search.closest(:release).should be_instance_of(Discogs::Search::Result)
-        @search.closest(:release).should == @search.exact(:release)[0]
-      end
-
-      it "should have a shortcut for accessing the first exact label" do
-        @search.closest(:label).should be_instance_of(Discogs::Search::Result)
-        @search.closest(:label).should == @search.exact(:label)[0]
-      end
-
-      it "should return nil on junk filter for closest match" do
-        @search.closest(:alcoholic).should be_nil
-      end
-
-   end
-
-    describe "when handling search results" do
-
-      it "should have a start attribute" do
-        @search.start.should == "1"
-      end
-
-      it "should have an end attribute" do
-        @search.end.should == "20"
-      end
-
-      it "should have number of results attribute" do
-        @search.total_results.should == 1846
-      end
-
-      it "should have number of pages attribute" do
-        @search.total_pages.should == 93
-      end
-
-      it "should have the search results stored as an array" do
-        @search.searchresults.should be_instance_of(Array)
-      end
-
-      it "should be stored as result objects" do
-        @search.searchresults.each do |result|
-          result.should be_instance_of(Discogs::Search::Result)
-        end
-      end
-
-   end
-
-    describe "when handling search results" do
-
-      it "should have a start attribute" do
-        @search.start.should == "1"
-      end
-
-      it "should have an end attribute" do
-        @search.end.should == "20"
-      end
-
-      it "should have number of results attribute" do
-        @search.total_results.should == 1846
-      end
-
-      it "should have number of pages attribute" do
-        @search.total_pages.should == 93
-      end
-
-      it "should have the search results stored as an array" do
-        @search.searchresults.should be_instance_of(Array)
-      end
-
-      it "should be stored as result objects" do
-        @search.searchresults.each do |result|
-          result.should be_instance_of(Discogs::Search::Result)
-        end
-      end
-
-   end
-
-    describe "when handling search results" do
-
-      it "should have a start attribute" do
-        @search.start.should == "1"
-      end
-
-      it "should have an end attribute" do
-        @search.end.should == "20"
-      end
-
-      it "should have number of results attribute" do
-        @search.total_results.should == 1846
-      end
-
-      it "should have number of pages attribute" do
-        @search.total_pages.should == 93
-      end
-
-      it "should have the search results stored as an array" do
-        @search.searchresults.should be_instance_of(Array)
-      end
-
-      it "should be stored as result objects" do
-        @search.searchresults.each do |result|
-          result.should be_instance_of(Discogs::Search::Result)
-        end
-      end
-
-      it "should have a incrementing num for each search result" do
-        @search.searchresults.each_with_index do |result, index|
-          result.num.should == (index + 1).to_s
-        end
-      end
-
-      it "should have a type for the third result" do
-        @search.searchresults[2].type.should == "label"
-      end
-
-      it "should have a title for the fourth result" do
-        @search.searchresults[3].title.should == "Satanic Slaughter"
-      end
-
-      it "should have a summary for the sixth result" do
-        @search.searchresults[5].summary.should == "Gary Slaughter"
-      end
-
-      it "should be able to filter all non-artists from extended results" do
-        @search.results(:artist).should be_instance_of(Array)
-        @search.results(:artist).length.should == 12
-      end
-
-      it "should be able to filter all non-releases from extended results" do
-        @search.results(:release).should be_instance_of(Array)
-        @search.results(:release).length.should == 6
-      end
-
-      it "should be able to filter all non-labels from extended results" do
-        @search.results(:label).should be_instance_of(Array)
-        @search.results(:label).length.should == 2
-      end
-
-      it "should return an empty array on a junk filter" do
-        @search.results(:cheesecake).should be_instance_of(Array)
-        @search.results(:cheesecake).should be_empty
-      end
-
-      it "should simply return all extended results without a filter" do
+      it "should have the results stored as an array" do
         @search.results.should be_instance_of(Array)
-        @search.results.length.should == 20
-      end
-
-    end
- 
-  end
-
-  describe "when getting the next page" do
-
-    before do
-      mock_search(2)
-
-      @search = @wrapper.search(@search_term, :page => 2)
-    end
-
-    describe "when dealing with page information" do
-
-      it "should have a current_page method" do
-        @search.current_page.should == 2
-      end
-
-      it "should be able to report if this is the last page" do
-        @search.last_page?.should be_false
-      end
-
-    end
-
-    describe "when handling exact results" do
-
-      it "should not have any exact results" do
-        @search.exactresults.should be_nil
-      end
-
-      it "should return empty array for exact filtering" do
-        @search.exact.should == []
       end
 
-      it "should still allow filtering and return an empty array" do
-        @search.exact(:artist).should == []
+      it "should have a type for the first result" do
+        @search.results[0].type.should == "release"
       end
 
-      it "should return nil for closest matches when no exact results are available" do
-        @search.closest(:artist).should be_nil
-        @search.closest(:release).should be_nil
-        @search.closest(:label).should be_nil
+      it "should have a style array for the first result" do
+        @search.results[0].style.should be_instance_of(Array)
+        @search.results[0].style[0].should == "Black Metal"
       end
 
-      it "should return nil on junk filter for closest match" do
-        @search.closest(:alcoholic).should be_nil
+      it "should have a type for the fourth result" do
+        @search.results[3].type.should == "release"
       end
 
     end
 
     describe "when handling search results" do
 
-      it "should have a start attribute" do
-        @search.start.should == "21"
-      end
-
-      it "should have an end attribute" do
-        @search.end.should == "40"
+      it "should have number of results per page attribute" do
+        @search.pagination.per_page.should == 50
       end
 
-      it "should have number of results attribute" do
-        @search.total_results.should == 1846
-      end
-
-      it "should have number of pages attribute (still)" do
-        @search.total_pages.should == 93
-      end
-
-      it "should have the search results stored as an array" do
-        @search.searchresults.should be_instance_of(Array)
-      end
-
-      it "should be stored as result objects" do
-        @search.searchresults.each do |result|
-          result.should be_instance_of(Discogs::Search::Result)
-        end
-      end
-
-      it "should have a incrementing num for each search result" do
-        @search.searchresults.each_with_index do |result, index|
-          result.num.should == (index + 21).to_s
-        end
+      it "should have number of pages attribute" do
+        @search.pagination.pages.should == 1
       end
 
     end