alexandria-book-collection-manager 0.7.3 → 0.7.8

data/spec/alexandria/library_spec.rb

@@ -4,88 +4,88 @@
 #
 # See the file README.md for authorship and licensing information.
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Alexandria::Library do
   let(:loader) { Alexandria::LibraryStore.new(TESTDIR) }
 
-  describe '::EXT' do
-    it 'has symbolic references to file extensions' do
+  describe "::EXT" do
+    it "has symbolic references to file extensions" do
       extensions = Alexandria::Library::EXT
       expect(extensions[:book]).not_to be_nil
       expect(extensions[:cover]).not_to be_nil
     end
   end
 
-  describe '#valid_isbn?' do
-    it 'returns a true value for valid isbns' do
-      for x in ['014143984X', '0-345-43192-8']
-        expect(Alexandria::Library.valid_isbn?(x)).to be_truthy
+  describe "#valid_isbn?" do
+    it "returns a true value for valid isbns" do
+      ["014143984X", "0-345-43192-8"].each do |x|
+        expect(described_class.valid_isbn?(x)).to be_truthy
       end
     end
   end
 
-  describe '#valid_ean?' do
-    it 'returns a true value for valid EANs' do
-      expect(Alexandria::Library.valid_ean?('9780345431929')).to be_truthy
-      expect(Alexandria::Library.valid_ean?('978034543192912345')).to be_truthy
+  describe "#valid_ean?" do
+    it "returns a true value for valid EANs" do
+      expect(described_class.valid_ean?("9780345431929")).to be_truthy
+      expect(described_class.valid_ean?("978034543192912345")).to be_truthy
 
       # Regression test: this EAN has a checksum of 10, which should be
       # treated like a checksum of 0.
-      expect(Alexandria::Library.valid_ean?('9784047041790')).to be_truthy
+      expect(described_class.valid_ean?("9784047041790")).to be_truthy
     end
 
-    it 'returns a false value for invalid EANs' do
-      expect(Alexandria::Library.valid_ean?('780345431929')).to be_falsey
-      expect(Alexandria::Library.valid_ean?('97803454319290')).to be_falsey
-      expect(Alexandria::Library.valid_ean?('97803454319291234')).to be_falsey
-      expect(Alexandria::Library.valid_ean?('9780345431929123456')).to be_falsey
-      expect(Alexandria::Library.valid_ean?('9780345431928')).to be_falsey
-      expect(Alexandria::Library.valid_ean?('9780345431929A')).to be_falsey
+    it "returns a false value for invalid EANs" do
+      expect(described_class.valid_ean?("780345431929")).to be_falsey
+      expect(described_class.valid_ean?("97803454319290")).to be_falsey
+      expect(described_class.valid_ean?("97803454319291234")).to be_falsey
+      expect(described_class.valid_ean?("9780345431929123456")).to be_falsey
+      expect(described_class.valid_ean?("9780345431928")).to be_falsey
+      expect(described_class.valid_ean?("9780345431929A")).to be_falsey
 
-      expect(Alexandria::Library.valid_ean?('9784047041791')).to be_falsey
+      expect(described_class.valid_ean?("9784047041791")).to be_falsey
     end
   end
 
-  describe '#valid_upc?' do
-    it 'returns a true value for valid UPCs' do
-      expect(Alexandria::Library.valid_upc?('97803454319312356')).to be_truthy
+  describe "#valid_upc?" do
+    it "returns a true value for valid UPCs" do
+      expect(described_class.valid_upc?("97803454319312356")).to be_truthy
     end
 
-    it 'returns a false value for invalid UPCs' do
-      expect(Alexandria::Library.valid_upc?('978034543193123567')).to be_falsey
-      expect(Alexandria::Library.valid_upc?('9780345431931235')).to be_falsey
+    it "returns a false value for invalid UPCs" do
+      expect(described_class.valid_upc?("978034543193123567")).to be_falsey
+      expect(described_class.valid_upc?("9780345431931235")).to be_falsey
 
-      expect(Alexandria::Library.valid_upc?('97803454319412356')).to be_falsey
-      expect(Alexandria::Library.valid_upc?('97803454319212356')).to be_falsey
+      expect(described_class.valid_upc?("97803454319412356")).to be_falsey
+      expect(described_class.valid_upc?("97803454319212356")).to be_falsey
     end
   end
 
-  describe '#canonicalise_isbn' do
-    it 'returns the correct value for several examples' do
-      expect(Alexandria::Library.canonicalise_isbn('014143984X')).to eq '014143984X'
-      expect(Alexandria::Library.canonicalise_isbn('0-345-43192-8')).to eq '0345431928'
-      expect(Alexandria::Library.canonicalise_isbn('3522105907')).to eq '3522105907'
+  describe "#canonicalise_isbn" do
+    it "returns the correct value for several examples" do
+      expect(described_class.canonicalise_isbn("014143984X")).to eq "014143984X"
+      expect(described_class.canonicalise_isbn("0-345-43192-8")).to eq "0345431928"
+      expect(described_class.canonicalise_isbn("3522105907")).to eq "3522105907"
       # EAN number
-      expect(Alexandria::Library.canonicalise_isbn('9780345431929')).to eq '0345431928'
+      expect(described_class.canonicalise_isbn("9780345431929")).to eq "0345431928"
     end
   end
 
-  context 'with an empty library' do
-    let(:my_library) { loader.load_library('Empty') }
+  context "with an empty library" do
+    let(:my_library) { loader.load_library("Empty") }
 
-    before(:each) do
+    before do
       FileUtils.mkdir(TESTDIR) unless File.exist? TESTDIR
     end
 
-    it 'disallows multiple deletion of the same copy of a book' do
+    it "disallows multiple deletion of the same copy of a book" do
       first_copy = an_artist_of_the_floating_world
       my_library << first_copy
       my_library.delete(first_copy)
       expect { my_library.delete(first_copy) }.to raise_error ArgumentError
     end
 
-    it 'allows multiple copies of a book to be added and deleted in turn' do
+    it "allows multiple copies of a book to be added and deleted in turn" do
       first_copy = an_artist_of_the_floating_world
       my_library << first_copy
       my_library.delete(first_copy)
@@ -97,125 +97,137 @@ describe Alexandria::Library do
 
       expect { my_library.delete(second_copy) }.not_to raise_error
     end
-
-    after(:each) do
-      FileUtils.rm_rf(TESTDIR)
-    end
   end
 
-  describe '.import_as_isbn_list' do
-    def __test_fake_import_isbns
+  describe ".import_as_isbn_list" do
+    before do
       libraries = Alexandria::LibraryCollection.instance
-      library = Alexandria::Library.new('Test Library')
+      library = described_class.new("Test Library")
       libraries.add_library(library)
-      [library, libraries]
+
+      allow(Alexandria::BookProviders)
+        .to receive(:isbn_search)
+        .and_raise Alexandria::BookProviders::SearchEmptyError
+      allow(Alexandria::BookProviders)
+        .to receive(:isbn_search).with("0595371086")
+        .and_return(an_artist_of_the_floating_world)
     end
 
-    it "doesn't work quite yet" do
-      skip
-      # Doesn't work quite yet.
-      on_iterate_cb = proc {}
-      on_error_cb = proc {}
-      library, _libraries = __test_fake_import_isbns
-      test_file = 'data/isbns.txt'
-      library.import_as_isbn_list('Test Library', test_file, on_iterate_cb, on_error_cb)
+    it "imports books with correct isbn and search result" do
+      library, bad_isbns, failed_lookup_isbns =
+        described_class.import_as_isbn_list("Test Library", "spec/data/isbns.txt",
+                                            proc {}, proc {})
+
+      aggregate_failures do
+        expect(library.to_a).to eq [an_artist_of_the_floating_world]
+        expect(bad_isbns).to eq ["0911826449"]
+        expect(failed_lookup_isbns).to eq ["0740704923"]
+      end
     end
   end
 
-  context 'imported from 0.6.1 data files' do
-    before(:each) do
-      lib_version = File.join(LIBDIR, '0.6.1')
+  context "when importing from 0.6.1 data files" do
+    let(:libs) { loader.load_all_libraries }
+    let(:my_library) { libs[0] }
+
+    before do
+      lib_version = File.join(LIBDIR, "0.6.1")
       FileUtils.cp_r(lib_version, TESTDIR)
     end
 
-    it 'imports cleanly from version 0.6.1 data format' do
-      libs = loader.load_all_libraries
+    it "can be loaded" do
       expect(libs.size).to eq(1)
-      my_library = libs[0]
       expect(my_library.size).to eq(3)
+    end
+
+    it "imports cleanly from version 0.6.1 data format" do
       # Malory
-      malory_book = my_library.select { |b| b.isbn == '9780192812179' }[0]
-      expect(malory_book.publisher).to eq('Oxford University Press')
-      expect(malory_book.authors.include?('Vinaver')).to be_truthy
+      malory_book = my_library.find { |b| b.isbn == "9780192812179" }
+      expect(malory_book.publisher).to eq("Oxford University Press")
+      expect(malory_book.authors.include?("Vinaver")).to be_truthy
       expect(malory_book.version).to eq(Alexandria::DATA_VERSION)
 
       # Guide to LaTeX
-      latex_book = my_library.select { |b| b.title.include? 'Latex' }[0]
-      expect(latex_book.isbn).to eq('9780201398250')
-      expect(latex_book.publisher).to eq('Addison Wesley') # note, no Ruby-Amazon cruft
-    end
-
-    after(:each) do
-      FileUtils.rm_rf(TESTDIR)
+      latex_book = my_library.find { |b| b.title.include? "Latex" }
+      expect(latex_book.isbn).to eq("9780201398250")
+      expect(latex_book.publisher).to eq("Addison Wesley") # note, no Ruby-Amazon cruft
     end
   end
 
-  context 'imported from 0.6.1 with books without an ISBN' do
-    before(:each) do
-      lib_version = File.join(LIBDIR, '0.6.1-noisbn')
+  context "when importing from 0.6.1 with books without an ISBN" do
+    let(:libs) { loader.load_all_libraries }
+    let(:my_library) { libs[0] }
+
+    before do
+      lib_version = File.join(LIBDIR, "0.6.1-noisbn")
       FileUtils.cp_r(lib_version, TESTDIR)
     end
 
-    it 'allows books to have no ISBN' do
-      libs = loader.load_all_libraries
+    after do
+      FileUtils.rm_rf(TESTDIR)
+    end
+
+    it "can be loaded" do
       expect(libs.size).to eq(1)
-      my_library = libs[0]
       expect(my_library.size).to eq(2)
+    end
 
+    it "loads a book with ISBN" do
       # Guide to LaTeX
-      latex_book = my_library.select { |b| b.title.include? 'Latex' }[0]
-      expect(latex_book.isbn).to eq('9780201398250')
-      expect(latex_book.publisher).to eq('Addison Wesley') # note, no Ruby-Amazon cruft
+      latex_book = my_library.find { |b| b.title.include? "Latex" }
+      expect(latex_book.isbn).to eq("9780201398250")
+      expect(latex_book.publisher).to eq("Addison Wesley") # note, no Ruby-Amazon cruft
       expect(latex_book.version).to eq(Alexandria::DATA_VERSION)
+    end
 
+    it "loads a book without ISBN" do
       # Lex and Yacc
-      lex_and_yacc_book = my_library.select { |b| b.title.include? 'Lex' }[0]
+      lex_and_yacc_book = my_library.find { |b| b.title.include? "Lex" }
       expect(lex_and_yacc_book.publisher).to eq("O'Reilley")
+    end
 
-      my_library.each do |book|
-        my_library.save(book, true)
-      end
-
-      libraries_reloaded = loader.load_all_libraries
-      my_library_reloaded = libraries_reloaded[0]
-
+    it "saves loaded books properly" do
+      my_library.each { |book| my_library.save(book, true) }
+      my_library_reloaded = loader.load_all_libraries[0]
       expect(my_library_reloaded.size).to eq(2)
 
-      latex_book = my_library_reloaded.select { |b| b.title.include? 'Latex' }[0]
-      expect(latex_book).not_to be_nil
-      expect(latex_book.publisher).to eq('Addison Wesley')
+      latex_book = my_library_reloaded.find { |b| b.title.include? "Latex" }
+      expect(latex_book.publisher).to eq("Addison Wesley")
 
-      lex_and_yacc_book = my_library_reloaded.select { |b| b.title.include? 'Lex' }[0]
-      expect(lex_and_yacc_book).not_to be_nil
+      lex_and_yacc_book = my_library_reloaded.find { |b| b.title.include? "Lex" }
       expect(lex_and_yacc_book.publisher).to eq("O'Reilley")
     end
-
-    after(:each) do
-      FileUtils.rm_rf(TESTDIR)
-    end
   end
 
-  describe '.move' do
-    before(:each) do
-      lib_version = File.join(LIBDIR, '0.6.2')
+  describe ".move" do
+    let(:source) { loader.load_library("My Library") }
+    let(:target) { loader.load_library("Target") }
+    let(:book) { source.first }
+
+    before do
+      lib_version = File.join(LIBDIR, "0.6.2")
       FileUtils.cp_r(lib_version, TESTDIR)
     end
 
-    it 'moves the given book from source to target' do
-      source = loader.load_library('My Library')
+    it "changes the number of books in the source and target libraries" do
       count = source.count
-      book = source.first
-      target = loader.load_library('Target')
 
-      described_class.move(source, target, source.first)
+      described_class.move(source, target, book)
 
       aggregate_failures do
         expect(source.count).to eq count - 1
         expect(target.count).to eq 1
-        expect(File.exist? source.yaml(book)).to be_falsey
-        expect(File.exist? source.cover(book)).to be_falsey
-        expect(File.exist? target.yaml(book)).to be_truthy
-        expect(File.exist? target.cover(book)).to be_truthy
+      end
+    end
+
+    it "moves the book files from source to target" do
+      described_class.move(source, target, book)
+
+      aggregate_failures do
+        expect(File.exist?(source.yaml(book))).to be_falsey
+        expect(File.exist?(source.cover(book))).to be_falsey
+        expect(File.exist?(target.yaml(book))).to be_truthy
+        expect(File.exist?(target.cover(book))).to be_truthy
       end
     end
   end

data/spec/alexandria/library_store_spec.rb

@@ -4,27 +4,27 @@
 #
 # See the file README.md for authorship and licensing information.
 
-require 'spec_helper'
+require "spec_helper"
 
 RSpec.describe Alexandria::LibraryStore do
   let(:loader) { described_class.new(TESTDIR) }
 
-  describe '#load_all_smart_libraries' do
-    context 'when none exist' do
-      it 'creates and saves some' do
+  describe "#load_all_smart_libraries" do
+    context "when none exist" do
+      it "creates and saves some" do
         smart_libs = loader.load_all_smart_libraries
         aggregate_failures do
           expect(smart_libs.size).to eq 5
           smart_libs.each do |lib|
-            expect(File.exist? lib.yaml).to be_truthy
+            expect(File.exist?(lib.yaml)).to be_truthy
           end
         end
       end
     end
 
-    context 'when one exists' do
-      it 'returns the existing smart library' do
-        existing = Alexandria::SmartLibrary.new('Hi', [], :all, loader)
+    context "when one exists" do
+      it "returns the existing smart library" do
+        existing = Alexandria::SmartLibrary.new("Hi", [], :all, loader)
         existing.save
         smart_libs = loader.load_all_smart_libraries
         aggregate_failures do

data/spec/alexandria/preferences_spec.rb

@@ -1,24 +1,51 @@
 # frozen_string_literal: true
 
-# Copyright (C) 2007 Joseph Method
+# This file is part of Alexandria.
 #
-# 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 File.dirname(__FILE__) + '/../spec_helper'
+require_relative "../spec_helper"
 
 describe Alexandria::Preferences do
-  it 'should work'
+  let(:instance) { described_class.instance }
+
+  describe "#get_variable" do
+    it "returns nil fetching unknown setting" do
+      expect(instance.get_variable("does_not_exist")).to eq nil
+    end
+
+    it "allows fetching by string" do
+      instance.toolbar_visible = false
+      expect(instance.get_variable("toolbar_visible")).to eq false
+    end
+
+    it "allows fetching by symbol" do
+      instance.toolbar_visible = true
+      expect(instance.get_variable(:toolbar_visible)).to eq true
+    end
+  end
+
+  describe "#set_variable" do
+    it "allows setting by string" do
+      instance.toolbar_visible = false
+      instance.set_variable("toolbar_visible", true)
+      expect(instance.toolbar_visible).to eq true
+    end
+
+    it "allows setting by symbol" do
+      instance.toolbar_visible = false
+      instance.set_variable(:toolbar_visible, true)
+      expect(instance.toolbar_visible).to eq true
+    end
+  end
+
+  it "allows setting known setting to false" do
+    instance.toolbar_visible = false
+    expect(instance.toolbar_visible).to eq false
+  end
+
+  it "resets known setting by setting to nil" do
+    instance.toolbar_visible = nil
+    expect(instance.toolbar_visible).to eq true
+  end
 end

data/spec/alexandria/scanners/cue_cat_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# This file is part of Alexandria.
+#
+# See the file README.md for authorship and licensing information.
+
+require_relative "../../spec_helper"
+
+describe Alexandria::Scanners::CueCat do
+  let(:cuecat) { described_class.new }
+  let(:partials) do
+    [".",
+     ".C3nZC3nZC3n2ChnWENz7DxnY",
+     ".C3nZC3nZC3n2ChnWENz7DxnY.",
+     ".C3nZC3nZC3n2ChnWENz7DxnY.cGen",
+     ".C3nZC3nZC3n2ChnWENz7DxnY.cGen.",
+     ".C3nZC3nZC3n2ChnWENz7DxnY.cGen.ENr7C3z0CNj3Dhj1EW"]
+  end
+  let(:scans) do
+    {
+      isbn: ".C3nZC3nZC3n2ChnWENz7DxnY.cGen.ENr7C3z0CNj3Dhj1EW.",
+      ib5: ".C3nZC3nZC3n2ChnWENz7DxnY.cGf2.ENr7C3z0DNn0ENnWE3nZDhP6."
+    }
+  end
+
+  it "is called CueCat" do
+    expect(cuecat.name).to match(/CueCat/i)
+  end
+
+  it "detects a complete scan only" do
+    partials.each { |scan| expect(cuecat.match?(scan)).not_to be_truthy }
+    expect(cuecat.match?(scans[:isbn])).to be_truthy
+    expect(cuecat.match?(scans[:ib5])).to be_truthy
+  end
+
+  it "decodes ISBN barcodes" do
+    expect(cuecat.decode(scans[:isbn])).to eq("9780571147168")
+  end
+
+  it "decodes ISBN+5 barcodes" do
+    expect(cuecat.decode(scans[:ib5])).to eq("9780575079038") # 00799
+    # TODO are we supposed to keep the +5 bit?
+  end
+
+  it "decodes ISSN barcodes" do
+    skip "Test scan ISSN"
+  end
+
+  it "decodes UPC barcodes" do
+    skip "Test scan UPC"
+  end
+end