goodreads 0.6.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 7f5dc59e124930f2aa9295a56d4a0058d46b7aa2
-  data.tar.gz: 7a7053c2a4916fe3ae4bd29a978072597351cb4a
+SHA256:
+  metadata.gz: 328c7dcd4de9aaf162c5dba7982e50451abfe96ca12d078367a9dd0293b5d6da
+  data.tar.gz: 413ab442ee0b50901b3e519e1d3cbd3bda0f18d04e28fb98ae65676b73399696
 SHA512:
-  metadata.gz: 16a77a800dba967e1941b2d9f546d2fbc11e4230dc4e25602c35d1513a17b2787193b5aeb8132bfbdf29cda2415db26e1db829ea7900e1edb792c8ddc5f1a2a6
-  data.tar.gz: b11fe6e4d95124964b4f1ba328f2c098a3699a8015d311932e258a535910c35503556d5bfe8c779443dfdca77b7d3402c532bcf0c5fb90da27822644dd4eb5bc
+  metadata.gz: 74594d009980dedd882344a3674da6bc5393ad399861b1cd1a0a1a59e112586c15975be0d2f691debf287074795e0e52e00035aac44575bbd1b710842e69c794
+  data.tar.gz: e355ba7c55d71f9fb1b3ac62b549eba718468f1cab8e8b8a2c922401da594c63927c9b060f305ad2c16439cbb1ba24684a866dcd486133f2d0d13969d94bd960

data/.travis.yml

@@ -1,10 +1,10 @@
 sudo: false
 
 rvm:
-  - 2.1
-  - 2.2
   - 2.3
   - 2.4
+  - 2.5
+  - 2.6
 
 script:
   - bundle exec rake test

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2011-2015 Dan Sosedoff <dan.sosedoff@gmail.com>
+Copyright (c) 2011-2020 Dan Sosedoff <dan.sosedoff@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in
@@ -17,4 +17,4 @@ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -2,6 +2,8 @@
 
 Ruby wrapper to communicate with Goodreads API.
 
+**NOTE: The Goodreads API [is being discontinued](https://www.goodreads.com/api).**
+
 ## Requirements
 
 - Ruby 1.9.3+
@@ -110,6 +112,17 @@ author.name   # => author name
 author.link   # => link to author's Goodreads page
 ```
 
+Look up books by an author:
+
+```ruby
+author = client.author_Book("id")
+
+author.id     # => author id
+author.name   # => author name
+author.link   # => link to author's Goodreads page
+author.books  # => array of books by this author
+```
+
 ### Reviews
 
 Pull recent reviews:
@@ -170,7 +183,6 @@ group_list.total         # => total number of groups
 group_list.group.count  # => number of groups returned in the request
 
 # Loop through the list to get details for each of the groups.
-
 group_list.group.each do |g|
   g.id                 # => group id
   g.access             # => access settings (private, public)
@@ -184,6 +196,14 @@ end
 The `sort` parameter is optional, and defaults to `my_activity`.
 For other sorting options, [see here](http://www.goodreads.com/api#group.list).
 
+### Pagination
+
+To retrieve results for a particular page use the `page` param when making calls:
+
+```ruby
+books = client.search_books("Term", page: 2)
+```
+
 ### OAuth
 
 For API calls requiring permission, such as write operations or browsing friends,
@@ -209,5 +229,3 @@ You're welcome to submit patches and new features.
 ## License
 
 The MIT License (MIT)
-
-Copyright (c) 2011-2015 Dan Sosedoff, <dan.sosedoff@gmail.com>

data/goodreads.gemspec

@@ -17,9 +17,9 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "yard",      "~> 0.9"
 
   spec.add_runtime_dependency "rest-client",   "~> 2.0"
-  spec.add_runtime_dependency "hashie",        "~> 2.0"
+  spec.add_runtime_dependency "hashie",        "~> 4.1.0"
   spec.add_runtime_dependency "activesupport", ">= 3.0"
-  spec.add_runtime_dependency "i18n",          "~> 0.6"
+  spec.add_runtime_dependency "i18n",          ">= 0.6", "< 2"
   spec.add_runtime_dependency "oauth",         "~> 0.4"
 
   spec.files         = `git ls-files`.split("\n")

data/lib/goodreads/client.rb

@@ -31,9 +31,18 @@ module Goodreads
     def initialize(options = {})
       fail(ArgumentError, "Options hash required.") unless options.is_a?(Hash)
 
-      @api_key    = options[:api_key] || Goodreads.configuration[:api_key]
-      @api_secret = options[:api_secret] || Goodreads.configuration[:api_secret]
+      @api_key     = options[:api_key] || Goodreads.configuration[:api_key]
+      @api_secret  = options[:api_secret] || Goodreads.configuration[:api_secret]
       @oauth_token = options[:oauth_token]
     end
+
+    # Return if this client is configured with OAuth credentials
+    # for a single user
+    #
+    # False when client is instantiated with an api_key and secret,
+    # true when client is instantiated with an oauth_token
+    def oauth_configured?
+      !oauth_token.nil?
+    end
   end
 end

data/lib/goodreads/client/authors.rb

@@ -8,6 +8,14 @@ module Goodreads
       Hashie::Mash.new(data["author"])
     end
 
+    # Get an author's books
+    #
+    def author_books(id, params = {})
+      params[:id] = id
+      data = request("/author/list", params)
+      Hashie::Mash.new(data["author"])
+    end
+
     # Search for an author by name
     #
     def author_by_name(name, params = {})

data/lib/goodreads/client/friends.rb

@@ -4,8 +4,8 @@ module Goodreads
     #
     # user_id - integer or string
     #
-    def friends(user_id)
-      data = oauth_request("/friend/user/#{user_id}")
+    def friends(user_id, options={})
+      data = oauth_request("/friend/user/#{user_id}", options)
       Hashie::Mash.new(data["friends"])
     end
   end

data/lib/goodreads/client/reviews.rb

@@ -31,5 +31,61 @@ module Goodreads
         []
       end
     end
+
+    # Get a user's review for a given book
+    def user_review(user_id, book_id, params = {})
+      data = request('/review/show_by_user_and_book.xml', params.merge(v: "2", user_id: user_id, book_id: book_id))
+      Hashie::Mash.new(data["review"])
+    end
+
+    # Add review for a book
+    #
+    # Params can include :review, :rating, and :shelf
+    #
+    # review: text of the review (optional)
+    # rating: rating (0-5) (optional, default is 0 (no rating))
+    # shelf: Name of shelf to add book to (optional, must exist, see: shelves.list)
+    #
+    # Note that Goodreads API documentation says that this endpoint accepts
+    # the read_at parameter but it does not appear to work as of 2018-06.
+    def create_review(book_id, params = {})
+      params = params.merge(book_id: book_id, v: "2")
+
+      params[:read_at] = params[:read_at].strftime('%Y-%m-%d') if params[:read_at].is_a?(Time)
+
+      params[:'review[review]'] = params.delete(:review) if params[:review]
+      params[:'review[rating]'] = params.delete(:rating) if params[:rating]
+      params[:'review[read_at]'] = params.delete(:read_at) if params[:read_at]
+
+      data = oauth_request_method(:post, '/review.xml', params)
+
+      Hashie::Mash.new(data["review"])
+    end
+
+    # Edit review for a book
+    #
+    # Params can include :review, :rating, :read_at and :shelf, and :finished
+    #
+    # review: text of the review (optional)
+    # rating: rating (0-5) (optional, default is 0 (no rating))
+    # shelf: Name of shelf to add book to (optional, must exist, see: shelves.list)
+    # read_at: Time object or String in YYYY-MM-DD format (optional)
+    # finished: true to mark finished reading (optional)
+    # shelf: Name of shelf to add book to (optional, must exist, see: shelves.list)
+    def edit_review(review_id, params = {})
+      params = params.merge(v: "2")
+
+      params[:read_at] = params[:read_at].strftime('%Y-%m-%d') if params[:read_at].is_a?(Time)
+
+      params[:'review[review]'] = params.delete(:review) if params[:review]
+      params[:'review[rating]'] = params.delete(:rating) if params[:rating]
+      params[:'review[read_at]'] = params.delete(:read_at) if params[:read_at]
+
+      # Documentation says that you should use HTTP PUT, but API returns
+      # 401 Unauthorized when PUT is used instead of POST
+      data = oauth_request_method(:post, "/review/#{review_id}.xml", params)
+
+      Hashie::Mash.new(data["review"])
+    end
   end
 end

data/lib/goodreads/client/shelves.rb

@@ -1,5 +1,36 @@
 module Goodreads
   module Shelves
+    # Lists shelves for a user
+    def shelves(user_id, options = {})
+      options = options.merge(user_id: user_id, v: 2)
+      data = request("/shelf/list.xml", options)
+      shelves = data["shelves"]
+
+      shelves = data["shelves"]["user_shelf"].map do |s|
+        Hashie::Mash.new({
+          id:             s["id"],
+          name:           s["name"],
+          book_count:     s["book_count"],
+          exclusive:      s["exclusive_flag"],
+          description:    s["description"],
+          sort:           s["sort"],
+          order:          s["order"],
+          per_page:       s["per_page"],
+          display_fields: s["display_fields"],
+          featured:       s["featured"],
+          recommend_for:  s["recommend_for"],
+          sticky:         s["sticky"],
+        })
+      end
+
+      Hashie::Mash.new(
+        start:   data["shelves"]["start"].to_i,
+        end:     data["shelves"]["end"].to_i,
+        total:   data["shelves"]["total"].to_i,
+        shelves: shelves
+      )
+    end
+
     # Get books from a user's shelf
     def shelf(user_id, shelf_name, options = {})
       options = options.merge(shelf: shelf_name, v: 2)
@@ -20,5 +51,42 @@ module Goodreads
         books: books
       )
     end
+
+    # Add book to a user's shelf
+    #
+    # Returns the user's review for the book, which includes all its current shelves
+    def add_to_shelf(book_id, shelf_name, options = {})
+      options = options.merge(book_id: book_id, name: shelf_name, v: 2)
+      data = oauth_request_method(:post, "/shelf/add_to_shelf.xml", options)
+
+      # when a book is on a single shelf it is a single hash
+      shelves = data["my_review"]["shelves"]["shelf"]
+      shelves = [shelves] unless shelves.instance_of?(Array)
+      shelves = shelves.map do |s|
+        Hashie::Mash.new({
+          id:             s["id"].to_i,
+          name:           s["name"],
+          exclusive:      s["exclusive"] == "true",
+          sortable:       s["sortable"] == "true",
+        })
+      end
+
+      Hashie::Mash.new(
+        id: data["my_review"]["id"].to_i,
+        book_id: data["my_review"]["book_id"].to_i,
+
+        rating: data["my_review"]["rating"].to_i,
+        body: data["my_review"]["body"],
+        body_raw: data["my_review"]["body_raw"],
+        spoiler: data["my_review"]["spoiler_flag"] == "true",
+
+        shelves: shelves,
+
+        read_at: data["my_review"]["read_at"],
+        started_at: data["my_review"]["started_at"],
+        date_added: data["my_review"]["date_added"],
+        updated_at: data["my_review"]["updated_at"],
+      )
+    end
   end
 end

data/lib/goodreads/errors.rb

@@ -4,4 +4,6 @@ module Goodreads
   class Forbidden < Error; end
   class Unauthorized < Error; end
   class NotFound < Error; end
+  class ServerError < Error; end
+  class UnknownError < Error; end
 end

data/lib/goodreads/request.rb

@@ -9,12 +9,26 @@ module Goodreads
 
     protected
 
-    # Perform an API request
+    # Perform an API request using API key or OAuth token
     #
     # path   - Request path
     # params - Parameters hash
     #
+    # Will make a request with the configured API key (application
+    # authentication) or OAuth token (user authentication) if available.
     def request(path, params = {})
+      if oauth_configured?
+        oauth_request(path, params)
+      else
+        http_request(path, params)
+      end
+    end
+
+    # Perform an API request using API key
+    #
+    # path   - Request path
+    # params - Parameters hash
+    def http_request(path, params)
       token = api_key || Goodreads.configuration[:api_key]
 
       fail(Goodreads::ConfigurationError, "API key required.") if token.nil?
@@ -32,24 +46,45 @@ module Goodreads
           fail(Goodreads::Forbidden)
         when 404
           fail(Goodreads::NotFound)
+        when 500..599
+          fail(Goodreads::ServerError.new(response.code))
+        else
+          fail(Goodreads::UnknownError.new(response.code))
         end
       end
 
       parse(resp)
     end
 
+    # Perform an OAuth API GET request. Goodreads must have been initialized with a valid OAuth access token.
+    #
+    # path   - Request path
+    # params - Parameters hash
+    #
+    def oauth_request(path, params = {})
+      oauth_request_method(:get, path, params)
+    end
+
     # Perform an OAuth API request. Goodreads must have been initialized with a valid OAuth access token.
     #
+    # http_method - HTTP verb supported by OAuth gem (one of :get, :post, :delete, etc.)
     # path   - Request path
     # params - Parameters hash
     #
-    def oauth_request(path, params = nil)
+    def oauth_request_method(http_method, path, params = {})
       fail "OAuth access token required!" unless @oauth_token
-      if params
-        url_params = params.map { |k, v| "#{k}=#{v}" }.join("&")
-        path = "#{path}?#{url_params}"
+
+      headers = { "Accept" => "application/xml" }
+
+      resp = if http_method == :get || http_method == :delete
+        if params
+          url_params = params.map { |k, v| "#{k}=#{v}" }.join("&")
+          path = "#{path}?#{url_params}"
+        end
+        @oauth_token.request(http_method, path, headers)
+      else
+        @oauth_token.request(http_method, path, params || {}, headers)
       end
-      resp = @oauth_token.get(path, "Accept" => "application/xml")
 
       case resp
       when Net::HTTPUnauthorized

data/lib/goodreads/version.rb

@@ -1,3 +1,3 @@
 module Goodreads
-  VERSION = "0.6.0"
+  VERSION = "0.9.0"
 end

data/spec/authentication_spec.rb

@@ -1,24 +1,37 @@
 require "spec_helper"
 
-describe "Client" do
+describe Goodreads::Client do
   before :each do
     Goodreads.reset_configuration
   end
 
-  it "raises Goodreads::ConfigurationError if API key was not provided" do
-    client = Goodreads::Client.new
+  let(:client) do
+    described_class.new(api_key: api_key)
+  end
+
+  context "API key is missing" do
+    let(:api_key) {}
 
-    expect { client.book_by_isbn("0307463745") }
-      .to raise_error(Goodreads::ConfigurationError, "API key required.")
+    it "throws an error" do
+      expect { client.book_by_isbn("0307463745") }
+        .to raise_error(Goodreads::ConfigurationError, "API key required.")
+    end
   end
 
-  it "raises Goodreads::Unauthorized if API key is not valid" do
-    client = Goodreads::Client.new(api_key: "INVALID_KEY")
+  context "API key is invalid" do
+    let(:api_key) { "INVALID_KEY" }
+
+    before do
+      stub_request(:get, "https://www.goodreads.com/book/isbn?format=xml&isbn=1&key=INVALID_KEY")
+        .to_return(status: 401)
 
-    stub_request(:get, "https://www.goodreads.com/book/isbn?format=xml&isbn=054748250711&key=INVALID_KEY")
-      .to_return(status: 401)
+      stub_request(:get, "https://www.goodreads.com/book/isbn?format=xml&isbn=2&key=INVALID_KEY")
+        .to_return(status: 403)
+    end
 
-    expect { client.book_by_isbn("054748250711") }
-      .to raise_error(Goodreads::Unauthorized)
+    it "throws errors" do
+      expect { client.book_by_isbn("1") }.to raise_error(Goodreads::Unauthorized)
+      expect { client.book_by_isbn("2") }.to raise_error(Goodreads::Forbidden)
+    end
   end
 end

data/spec/client_spec.rb

@@ -1,7 +1,7 @@
 require "spec_helper"
 require "oauth"
 
-describe "Client" do
+describe Goodreads::Client do
   let(:client)  { Goodreads::Client.new(api_key: "SECRET_KEY") }
   before(:each) { Goodreads.reset_configuration }
 
@@ -17,6 +17,45 @@ describe "Client" do
     end
   end
 
+  describe "#oauth_configured?" do
+    it "is true when OAuth token provided to constructor" do
+      client = Goodreads::Client.new(oauth_token: "a token")
+      expect(client.oauth_configured?).to be true
+    end
+
+    it "is true when oauth token is not provided to constructor" do
+      client = Goodreads::Client.new(api_key: "SECRET_KEY")
+      expect(client.oauth_configured?).to be false
+    end
+  end
+
+  describe "#request" do
+    context "with oauth token" do
+      it "makes an oauth request" do
+        oauth_token = double
+        response = double
+
+        allow(oauth_token).to receive(:request) { response }
+        allow(response).to receive(:body) { fixture("book.xml") }
+
+        client = Goodreads::Client.new(oauth_token: oauth_token)
+        expect(client.book(123)).to be_a Hash
+      end
+    end
+
+    context "without oauth token" do
+      before do
+        allow(client).to receive(:http_request) {
+          Hash.from_xml(fixture("book.xml"))["GoodreadsResponse"]
+        }
+      end
+
+      it "makes a request" do
+        expect(client.book(123)).to be_a Hash
+      end
+    end
+  end
+
   describe "#book_by_isbn" do
     before { stub_with_key_get("/book/isbn", { isbn: "0307463745" }, "book.xml") }
 
@@ -154,6 +193,26 @@ describe "Client" do
     end
   end
 
+  describe "#user_review" do
+    let(:consumer) { OAuth::Consumer.new("API_KEY", "SECRET_KEY", site: "https://www.goodreads.com") }
+    let(:token)    { OAuth::AccessToken.new(consumer, "ACCESS_TOKEN", "ACCESS_SECRET") }
+
+    it "returns a user's existing review" do
+      stub_request(:get, "https://www.goodreads.com/review/show_by_user_and_book.xml?book_id=50&user_id=1&v=2")
+        .to_return(status: 200, body: fixture("review_show_by_user_and_book.xml"))
+
+      client = Goodreads::Client.new(api_key: "SECRET_KEY", oauth_token: token)
+      review = client.user_review(1, 50)
+
+      expect(review.id).to eq("21")
+      expect(review.book.id).to eq(50)
+
+      expect(review.rating).to eq("5")
+      expect(review.body.strip).to eq("")
+      expect(review.date_added).to eq("Tue Aug 29 11:20:01 -0700 2006")
+    end
+  end
+
   describe "#author" do
     before { stub_with_key_get("/author/show", { id: "18541" }, "author.xml") }
 
@@ -203,6 +262,23 @@ describe "Client" do
     end
   end
 
+  describe "#author_books" do
+    before do
+      stub_with_key_get("/author/list", { id: "18541" }, "author_books.xml")
+    end
+
+    it "returns author's books" do
+      author = client.author_books("18541")
+
+      expect(author).to be_a(Hashie::Mash)
+      expect(author.id).to eq("18541")
+      expect(author.name).to eq("Tim O'Reilly")
+      expect(author.link).to eq("https://www.goodreads.com/author/show/18541.Tim_O_Reilly")
+
+      expect(author.books.book.size).to eq(30)
+    end
+  end
+
   describe "#user" do
     before { stub_with_key_get("/user/show", { id: "878044" }, "user.xml") }
 
@@ -287,6 +363,131 @@ describe "Client" do
     end
   end
 
+  describe "#add_to_shelf" do
+    let(:consumer) { OAuth::Consumer.new("API_KEY", "SECRET_KEY", site: "https://www.goodreads.com") }
+    let(:token)    { OAuth::AccessToken.new(consumer, "ACCESS_TOKEN", "ACCESS_SECRET") }
+
+    it "adds a book to a user's shelf" do
+      stub_request(:post, "https://www.goodreads.com/shelf/add_to_shelf.xml")
+        .with(:body => {"book_id"=>"456", "name"=>"read", "v"=>"2"})
+        .to_return(status: 201, body: fixture("shelf_add_to_shelf.xml"))
+
+      client = Goodreads::Client.new(api_key: "SECRET_KEY", oauth_token: token)
+      review = client.add_to_shelf(456, "read")
+
+      expect(review.id).to eq(2416981504)
+      expect(review.book_id).to eq(456)
+
+      expect(review.rating).to eq(0)
+      expect(review.body).to be nil
+      expect(review.body_raw).to be nil
+      expect(review.spoiler).to be false
+
+      expect(review.shelves.size).to eq(1)
+      expect(review.shelves.first.name).to eq("read")
+      expect(review.shelves.first.id).to eq(269274694)
+      expect(review.shelves.first.exclusive).to be true
+      expect(review.shelves.first.sortable).to be false
+
+
+      expect(review.read_at).to be nil
+      expect(review.started_at).to be nil
+      expect(review.date_added).to eq("Thu Jun 07 19:58:19 -0700 2018")
+      expect(review.updated_at).to eq("Thu Jun 07 19:58:53 -0700 2018")
+
+      expect(review.body).to be nil
+      expect(review.body_raw).to be nil
+      expect(review.spoiler).to be false
+    end
+  end
+
+  describe "#create_review" do
+    let(:consumer) { OAuth::Consumer.new("API_KEY", "SECRET_KEY", site: "https://www.goodreads.com") }
+    let(:token)    { OAuth::AccessToken.new(consumer, "ACCESS_TOKEN", "ACCESS_SECRET") }
+
+    it "creates a new review for a book" do
+      stub_request(:post, "https://www.goodreads.com/review.xml")
+        .with(:body => {
+          "book_id"=>"456",
+          "review" => {
+            "rating" => "3",
+            "review" => "Good book.",
+            "read_at" => "2018-01-02",
+          },
+          "shelf" => "read",
+          "v"=>"2",
+        })
+        .to_return(status: 201, body: fixture("review_create.xml"))
+
+      client = Goodreads::Client.new(api_key: "SECRET_KEY", oauth_token: token)
+      review = client.create_review(456, {
+        :review => "Good book.",
+        :rating => 3,
+        :read_at => Time.parse('2018-01-02'),
+        :shelf => "read",
+      })
+
+      expect(review.id).to eq("67890")
+      expect(review.book.id).to eq(456)
+      expect(review.rating).to eq("3")
+      expect(review.body).to eq("Good book.")
+    end
+  end
+
+  describe "#edit_review" do
+    let(:consumer) { OAuth::Consumer.new("API_KEY", "SECRET_KEY", site: "https://www.goodreads.com") }
+    let(:token)    { OAuth::AccessToken.new(consumer, "ACCESS_TOKEN", "ACCESS_SECRET") }
+
+    it "creates a new review for a book" do
+      stub_request(:post, "https://www.goodreads.com/review/67890.xml")
+        .with(:body => {
+          "finished" => "true",
+          "review" => {
+            "rating" => "5",
+            "review" => "Fantastic book.",
+            "read_at" => "2018-04-15",
+          },
+          "shelf" => "read",
+          "v"=>"2",
+        })
+        .to_return(status: 201, body: fixture("review_update.xml"))
+
+      client = Goodreads::Client.new(api_key: "SECRET_KEY", oauth_token: token)
+      review = client.edit_review(67890, {
+        :finished => true,
+        :review => "Fantastic book.",
+        :rating => 5,
+        :read_at => Time.parse('2018-04-15'),
+        :shelf => "read",
+      })
+
+      expect(review.id).to eq("67890")
+      expect(review.book.id).to eq(456)
+      expect(review.rating).to eq("5")
+      expect(review.body).to eq("Fantastic book.")
+    end
+  end
+
+  describe "#shelves" do
+    it "returns list of user's shelves" do
+      stub_with_key_get("/shelf/list.xml", { user_id: 123, v: "2" }, "shelf_list.xml")
+
+      response = client.shelves(123)
+
+      expect(response).to respond_to(:start)
+      expect(response).to respond_to(:end)
+      expect(response).to respond_to(:total)
+      expect(response).to respond_to(:shelves)
+
+      expect(response.start).to eq(1)
+      expect(response.end).to eq(3)
+      expect(response.total).to eq(3)
+      expect(response.shelves.length).to eq(3)
+      expect(response.shelves.first.id).to eq(9049904)
+      expect(response.shelves.first.name).to eq("read")
+    end
+  end
+
   describe "#user_id" do
     let(:consumer) { OAuth::Consumer.new("API_KEY", "SECRET_KEY", site: "https://www.goodreads.com") }
     let(:token)    { OAuth::AccessToken.new(consumer, "ACCESS_TOKEN", "ACCESS_SECRET") }