alexandria-book-collection-manager 0.7.3 → 0.7.8

data/spec/alexandria/book_providers_spec.rb

@@ -1,186 +1,92 @@
 # frozen_string_literal: true
 
-# Copyright (C) 2005-2006 Laurent Sansonetti
-# Copyright (C) 2007 Joseph Method
-# Copyright (C) 2011, 2014, 2015 Matijs van Zuijlen
+# This file is part of Alexandria.
 #
-# This file is part of Alexandria, a GNOME book collection manager.
-#
-# Alexandria is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License as
-# published by the Free Software Foundation; either version 2 of the
-# License, or (at your option) any later version.
-#
-# Alexandria is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# General Public License for more details.
-#
-# You should have received a copy of the GNU General Public
-# License along with Alexandria; see the file COPYING.  If not,
-# write to the Free Software Foundation, Inc., 51 Franklin Street,
-# Fifth Floor, Boston, MA 02110-1301 USA.
+# See the file README.md for authorship and licensing information.
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Alexandria::BookProviders do
-  it 'should be less clever'
-
-  def assert_correct_search_result(provider, query,
-                                   search_type = Alexandria::BookProviders::SEARCH_BY_ISBN)
-    begin
-      results = provider.instance.search(query, search_type)
-    rescue SocketError
-      skip 'Service is offline'
-    end
-
-    puts results.inspect if $DEBUG
-
-    expect(results).to be_instance_of(Array), "Results are not an array for #{provider}"
-    expect(results).not_to be_empty, "Results are empty for #{provider}"
-
-    if search_type == Alexandria::BookProviders::SEARCH_BY_ISBN
-      expect(results.length).to be <= 2, "Results are greater than 2 for #{provider}"
-
-      book = results.first
-
-      expect(book).to be_instance_of(Alexandria::Book), "Result is not a Book for #{provider}"
+  it "should be less clever"
 
-      canonical_query = Alexandria::Library.canonicalise_ean(query)
-      canonical_result = Alexandria::Library.canonicalise_ean(book.isbn)
-      expect(canonical_query).
-        to eq(canonical_result),
-           "Result's isbn #{book.isbn} is not equivalent to the requested isbn #{query} for #{provider}"
-
-      if results.length == 2
-        cover_url = results.last
-        if cover_url
-          expect(cover_url).
-            to be_instance_of(String), "Unexpected cover_url #{cover_url.inspect} for #{provider}"
-        end
-      end
-    else
-      expect(results.first.first).
-        to be_instance_of(Alexandria::Book), "Result item is not a Book for #{provider}"
+  describe Alexandria::BookProviders::AmazonProvider do
+    before do
+      skip "Amazon requires an API key. Remove it altogether as a provider?"
     end
-    results
-  end
 
-  it 'should not piss off Rich Burridge' do
-    skip 'Amazon requires an API key. Remove it altogether as a provider?'
-    assert_correct_search_result(Alexandria::BookProviders::AmazonProvider,
-                                 '033025068X')
-  end
-
-  it 'amazon should work' do
-    skip 'Amazon requires an API key. Remove it altogether as a provider?'
-    assert_correct_search_result(Alexandria::BookProviders::AmazonProvider,
-                                 '9780385504201')
-  end
-
-  it 'amazon title should work' do
-    skip 'Amazon requires an API key. Remove it altogether as a provider?'
-    assert_correct_search_result(Alexandria::BookProviders::AmazonProvider,
-                                 'A Confederacy of Dunces', Alexandria::BookProviders::SEARCH_BY_TITLE)
-  end
-
-  it 'amazon authors should work' do
-    skip 'Amazon requires an API key. Remove it altogether as a provider?'
-    assert_correct_search_result(Alexandria::BookProviders::AmazonProvider,
-                                 'John Kennedy Toole', Alexandria::BookProviders::SEARCH_BY_AUTHORS)
-  end
+    it "does not piss off Rich Burridge" do
+      assert_correct_search_result(described_class, "033025068X")
+    end
 
-  it 'amazon keyword should work' do
-    skip 'Amazon requires an API key. Remove it altogether as a provider?'
-    assert_correct_search_result(Alexandria::BookProviders::AmazonProvider,
-                                 'Confederacy Dunces', Alexandria::BookProviders::SEARCH_BY_KEYWORD)
-  end
+    it "works" do
+      assert_correct_search_result(described_class, "9780385504201")
+    end
 
-  it 'LOC should work' do
-    assert_correct_search_result(Alexandria::BookProviders::LOCProvider,
-                                 '9780805335583')
-    # this book has non-ASCII letters
-    assert_correct_search_result(Alexandria::BookProviders::LOCProvider,
-                                 '9782070379248')
-  end
+    it "works when searching for title" do
+      assert_correct_search_result(described_class, "A Confederacy of Dunces",
+                                   Alexandria::BookProviders::SEARCH_BY_TITLE)
+    end
 
-  it 'BL should work' do
-    skip 'Not working: connect failed'
-    assert_correct_search_result(Alexandria::BookProviders::BLProvider,
-                                 '9781853260803')
-  end
+    it "amazon authors should work" do
+      assert_correct_search_result(described_class, "John Kennedy Toole",
+                                   Alexandria::BookProviders::SEARCH_BY_AUTHORS)
+    end
 
-  it 'SBN should work' do
-    assert_correct_search_result(Alexandria::BookProviders::SBNProvider,
-                                 '9788835926436')
+    it "amazon keyword should work" do
+      assert_correct_search_result(described_class, "Confederacy Dunces",
+                                   Alexandria::BookProviders::SEARCH_BY_KEYWORD)
+    end
   end
 
-  it 'Barnes and Noble should work' do
-    skip 'Barnes and Noble is not operational at the moment'
-    assert_correct_search_result(Alexandria::BookProviders::BarnesAndNobleProvider,
-                                 '9780961328917') # see #1433
-  end
+  describe Alexandria::BookProviders::LOCProvider do
+    it "works for a book with ASCII title" do
+      assert_correct_search_result(described_class, "9780805335583")
+    end
 
-  it 'Proxis should work' do
-    skip 'Needs fixing'
-    assert_correct_search_result(Alexandria::BookProviders::ProxisProvider,
-                                 '9789026965746')
-    assert_correct_search_result(Alexandria::BookProviders::ProxisProvider,
-                                 '9780586071403')
+    it "works for a book with a title with non-ASCII letters" do
+      assert_correct_search_result(described_class, "9782070379248")
+    end
   end
 
-  it 'Thalia should work' do
-    skip 'Needs fixing'
-    # german book
-    assert_correct_search_result(Alexandria::BookProviders::ThaliaProvider,
-                                 '9783896673305')
-    # international book
-    assert_correct_search_result(Alexandria::BookProviders::ThaliaProvider,
-                                 '9780440241904')
-    # movie dvd
-    assert_correct_search_result(Alexandria::BookProviders::ThaliaProvider,
-                                 '4010232037824')
-    # music cd
-    assert_correct_search_result(Alexandria::BookProviders::ThaliaProvider,
-                                 '0094638203520')
+  describe Alexandria::BookProviders::BLProvider do
+    it "works" do
+      skip "Not working: connect failed"
+      assert_correct_search_result(described_class, "9781853260803")
+    end
   end
 
-  it 'AdLibris should work' do
-    skip 'Needs fixing: site has changed'
-    assert_correct_search_result(Alexandria::BookProviders::AdLibrisProvider,
-                                 '9789100109332')
+  describe Alexandria::BookProviders::SBNProvider do
+    it "works" do
+      assert_correct_search_result(described_class, "9788835926436")
+    end
   end
 
-  it 'Siciliano should work' do
-    skip 'Needs fixing: no results found'
-    assert_correct_search_result(Alexandria::BookProviders::SicilianoProvider,
-                                 '9788599170380')
+  describe Alexandria::BookProviders::BarnesAndNobleProvider do
+    it "works" do
+      skip "Barnes and Noble is not operational at the moment"
+      assert_correct_search_result(described_class, "9780961328917") # see #1433
+    end
   end
 
-  it 'Renaud should work' do
-    skip 'Marked in code as not working; remove implementation entirely.'
-    # adultes
-    assert_correct_search_result(Alexandria::BookProviders::RENAUDProvider,
-                                 '9782894723388')
-    # jeunesse
-    assert_correct_search_result(Alexandria::BookProviders::RENAUDProvider,
-                                 '9782764605059')
+  describe Alexandria::BookProviders::ProxisProvider do
+    it "works" do
+      skip "Needs fixing"
+      assert_correct_search_result(described_class, "9789026965746")
+      assert_correct_search_result(described_class, "9780586071403")
+    end
   end
 
-  it 'Worldcat should work' do
-    assert_correct_search_result(Alexandria::BookProviders::WorldCatProvider,
-                                 '9780521247108')
-    # this one is with <div class=vernacular lang="[^"]+">)
-    assert_correct_search_result(Alexandria::BookProviders::WorldCatProvider,
-                                 '9785941454136')
+  describe Alexandria::BookProviders::AdLibrisProvider do
+    it "works" do
+      skip "Needs fixing: site has changed"
+      assert_correct_search_result(described_class, "9789100109332")
+    end
   end
 
-  it 'Worldcat should work with multiple authors' do
-    results = assert_correct_search_result(Alexandria::BookProviders::WorldCatProvider,
-                                           '9785941454136')
-    this_book = results.first
-    expect(this_book.authors).to be_instance_of(Array), 'Not an array!'
-    # puts this_book.authors
-    expect(this_book.authors.length).to eq(2), 'Wrong number of authors for this book!'
+  describe Alexandria::BookProviders::SicilianoProvider do
+    it "works" do
+      skip "Needs fixing: no results found"
+      assert_correct_search_result(described_class, "9788599170380")
+    end
   end
 end

data/spec/alexandria/book_spec.rb

@@ -18,41 +18,43 @@
 # write to the Free Software Foundation, Inc., 51 Franklin Street,
 # Fifth Floor, Boston, MA 02110-1301 USA.
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Alexandria::Book do
-  it 'should be a thing' do
+  it "is a thing" do
     an_artist_of_the_floating_world
   end
 
-  it 'should establish equality only with books with the same identity' do
+  it "establishes equality only with books with the same identity" do
     book = an_artist_of_the_floating_world
     same_book = an_artist_of_the_floating_world
     expect(same_book).to eq book
     different_book = an_artist_of_the_floating_world
-    different_book.isbn = '9780571147999'
+    different_book.isbn = "9780571147999"
     expect(different_book).not_to eq book
   end
 
-  describe '#rating' do
+  describe "#rating" do
     let(:book) { an_artist_of_the_floating_world }
-    it 'returns 0 by default' do
+
+    it "returns 0 by default" do
       expect(book.rating).to eq 0
     end
   end
 
-  describe '#rating=' do
+  describe "#rating=" do
     let(:book) { an_artist_of_the_floating_world }
-    it 'assigns rating' do
+
+    it "assigns rating" do
       book.rating = 5
       expect(book.rating).to eq 5
     end
 
-    it 'does not allow higher rating than 5 to be assigned' do
+    it "does not allow higher rating than 5 to be assigned" do
       expect { book.rating = 6 }.to raise_error ArgumentError
     end
 
-    it 'does not allow lower rating than 0 to be assigned' do
+    it "does not allow lower rating than 0 to be assigned" do
       expect { book.rating = -1 }.to raise_error ArgumentError
     end
   end

data/spec/alexandria/console_spec.rb

@@ -4,29 +4,24 @@
 #
 # See the file README.md for authorship and licensing information.
 
-require 'spec_helper'
+require "spec_helper"
 
 RSpec.describe Alexandria do
-  let(:lib_version) { File.join(LIBDIR, '0.6.2') }
+  let(:lib_version) { File.join(LIBDIR, "0.6.2") }
 
   before do
-    FileUtils.rm_rf(TESTDIR)
     FileUtils.cp_r(lib_version, TESTDIR)
   end
 
-  describe '.list_books_on_console' do
-    it 'returns a string containing a list of all books' do
-      expect(Alexandria.list_books_on_console).to eq <<~LIST
-        The Dispossessed, Ursula Le Guin
+  describe ".list_books_on_console" do
+    it "returns a string containing a list of all books" do
+      expect(described_class.list_books_on_console).to eq <<~LIST
         Pattern Recognition, William Gibson
         Bonjour Tristesse, Francoise Sagan & Irene Ash
         An Artist of the Floating World, Kazuo Ishiguro
+        The Dispossessed, Ursula Le Guin
         Neverwhere, Neil Gaiman
       LIST
     end
   end
-
-  after do
-    FileUtils.rm_rf(TESTDIR)
-  end
 end

data/spec/alexandria/export_library_spec.rb

@@ -4,67 +4,60 @@
 #
 # See the file README.md for authorship and licensing information.
 
-require 'spec_helper'
+require "spec_helper"
 
 RSpec.describe Alexandria::ExportLibrary do
-  let(:lib_version) { File.join(LIBDIR, '0.6.2') }
-
-  let(:loader) { Alexandria::LibraryStore.new(TESTDIR) }
-
+  let(:my_library) do
+    loader = Alexandria::LibraryStore.new(TESTDIR)
+    loader.load_library("My Library")
+  end
   let(:format) { Alexandria::ExportFormat.all.find { |it| it.message == message } }
-  let(:outfile_base) { format.ext ? "my-library.#{format.ext}" : 'my-library' }
-  let(:outfile) { File.join(Dir.tmpdir, outfile_base) }
-
+  let(:outfile) do
+    outfile_base = format.ext ? "my-library.#{format.ext}" : "my-library"
+    File.join(Dir.tmpdir, outfile_base)
+  end
   let(:unsorted) { Alexandria::LibrarySortOrder::Unsorted.new }
 
   before do
-    FileUtils.cp_r(lib_version, TESTDIR)
-    @my_library = loader.load_library('My Library')
-    expect(@my_library.size).to eq 5
+    test_library = File.join(LIBDIR, "0.6.2")
+    FileUtils.cp_r(test_library, TESTDIR)
+  end
+
+  after do
+    FileUtils.rm_rf(outfile) if File.exist? outfile
   end
 
-  describe '#export_as_csv_list' do
+  describe "#export_as_csv_list" do
     let(:message) { :export_as_csv_list }
 
     def load_rows_from_csv
-      CSV.read(outfile, col_sep: ';')
+      CSV.read(outfile, col_sep: ";", headers: true)
     end
 
-    it 'can sort by title' do
+    it "can sort by title" do
       sort_by_title = Alexandria::LibrarySortOrder.new(:title)
-      format.invoke(@my_library, sort_by_title, outfile)
-      expect(File.exist?(outfile)).to be_truthy
+      format.invoke(my_library, sort_by_title, outfile)
       rows = load_rows_from_csv
-      rows.shift
-      expect(rows.size).to eq(@my_library.size)
-      TITLE = 0
-      comparisons = rows.size - 1
-      comparisons.times do |index|
-        expect(rows[index][TITLE]).to be <= rows[index + 1][TITLE]
-      end
+      titles = rows.map { |it| it["Title"] }
+      expect(titles).to eq titles.sort
     end
 
-    it 'can sort in descending order' do
+    it "can sort in descending order" do
       sort_by_date_desc = Alexandria::LibrarySortOrder.new(:publishing_year, false)
-      format.invoke(@my_library, sort_by_date_desc, outfile)
-      expect(File.exist?(outfile)).to be_truthy
+      format.invoke(my_library, sort_by_date_desc, outfile)
       rows = load_rows_from_csv
-      rows.shift
-      expect(rows.size).to eq(@my_library.size)
-      DATE = 5
-      comparisons = rows.size - 1
-      comparisons.times do |index|
-        expect(rows[index][DATE]).to be >= rows[index + 1][DATE]
-      end
+      dates = rows.map { |it| it["Year Published"] }
+      expect(dates).to eq dates.sort.reverse
     end
   end
 
-  describe '#export_as_html' do
+  describe "#export_as_html" do
     let(:message) { :export_as_html }
-    let(:index) { File.join(outfile, 'index.html') }
 
-    it 'can export unsorted' do
-      format.invoke(@my_library, unsorted, outfile, Alexandria::WebTheme.all.first)
+    it "can export unsorted" do
+      format.invoke(my_library, unsorted, outfile, Alexandria::WebTheme.all.first)
+      index = File.join(outfile, "index.html")
+
       aggregate_failures do
         expect(File.exist?(outfile)).to be_truthy
         expect(File.exist?(index)).to be_truthy
@@ -73,11 +66,11 @@ RSpec.describe Alexandria::ExportLibrary do
     end
   end
 
-  describe '#export_as_onix_xml_archive' do
+  describe "#export_as_onix_xml_archive" do
     let(:message) { :export_as_onix_xml_archive }
 
-    it 'can export unsorted' do
-      format.invoke(@my_library, unsorted, outfile)
+    it "can export unsorted" do
+      format.invoke(my_library, unsorted, outfile)
       aggregate_failures do
         expect(File.exist?(outfile)).to be_truthy
         expect(File.size(outfile)).to be_nonzero
@@ -85,11 +78,11 @@ RSpec.describe Alexandria::ExportLibrary do
     end
   end
 
-  describe '#export_as_tellico_xml_archive' do
+  describe "#export_as_tellico_xml_archive" do
     let(:message) { :export_as_tellico_xml_archive }
 
-    it 'can export unsorted' do
-      format.invoke(@my_library, unsorted, outfile)
+    it "can export unsorted" do
+      format.invoke(my_library, unsorted, outfile)
       aggregate_failures do
         expect(File.exist?(outfile)).to be_truthy
         expect(File.size(outfile)).to be_nonzero
@@ -97,11 +90,11 @@ RSpec.describe Alexandria::ExportLibrary do
     end
   end
 
-  describe '#export_as_bibtex' do
+  describe "#export_as_bibtex" do
     let(:message) { :export_as_bibtex }
 
-    it 'can export unsorted' do
-      format.invoke(@my_library, unsorted, outfile)
+    it "can export unsorted" do
+      format.invoke(my_library, unsorted, outfile)
       aggregate_failures do
         expect(File.exist?(outfile)).to be_truthy
         expect(File.size(outfile)).to be_nonzero
@@ -109,11 +102,11 @@ RSpec.describe Alexandria::ExportLibrary do
     end
   end
 
-  describe '#export_as_isbn_list' do
+  describe "#export_as_isbn_list" do
     let(:message) { :export_as_isbn_list }
 
-    it 'can export unsorted' do
-      format.invoke(@my_library, unsorted, outfile)
+    it "can export unsorted" do
+      format.invoke(my_library, unsorted, outfile)
       aggregate_failures do
         expect(File.exist?(outfile)).to be_truthy
         expect(File.size(outfile)).to be_nonzero
@@ -121,21 +114,17 @@ RSpec.describe Alexandria::ExportLibrary do
     end
   end
 
-  describe '#export_as_ipod_notes' do
+  describe "#export_as_ipod_notes" do
     let(:message) { :export_as_ipod_notes }
-    let(:index) { File.join(outfile, 'index.linx') }
 
-    it 'can export unsorted' do
-      format.invoke(@my_library, unsorted, outfile, nil)
+    it "can export unsorted" do
+      format.invoke(my_library, unsorted, outfile, nil)
+      index = File.join(outfile, "index.linx")
+
       aggregate_failures do
         expect(File.exist?(outfile)).to be_truthy
         expect(File.size(index)).to be_nonzero
       end
     end
   end
-
-  after(:each) do
-    FileUtils.rm_rf(TESTDIR)
-    FileUtils.rm_rf(outfile) if File.exist? outfile
-  end
 end