alexandria-book-collection-manager 0.7.9 → 0.7.11

data/spec/alexandria/export_library_spec.rb

@@ -11,12 +11,11 @@ RSpec.describe Alexandria::ExportLibrary do
     loader = Alexandria::LibraryStore.new(TESTDIR)
     loader.load_library("My Library")
   end
-  let(:format) { Alexandria::ExportFormat.all.find { |it| it.message == message } }
+  let(:format) { Alexandria::ExportFormat.all.find { _1.message == message } }
   let(:outfile) do
     outfile_base = format.ext ? "my-library.#{format.ext}" : "my-library"
-    File.join(Dir.tmpdir, outfile_base)
+    File.join(Dir.mktmpdir, outfile_base)
   end
-  let(:unsorted) { Alexandria::LibrarySortOrder::Unsorted.new }
 
   before do
     test_library = File.join(LIBDIR, "0.6.2")
@@ -24,7 +23,7 @@ RSpec.describe Alexandria::ExportLibrary do
   end
 
   after do
-    FileUtils.rm_rf(outfile) if File.exist? outfile
+    FileUtils.rm_rf(outfile)
   end
 
   describe "#export_as_csv_list" do
@@ -38,7 +37,7 @@ RSpec.describe Alexandria::ExportLibrary do
       sort_by_title = Alexandria::LibrarySortOrder.new(:title)
       format.invoke(my_library, sort_by_title, outfile)
       rows = load_rows_from_csv
-      titles = rows.map { |it| it["Title"] }
+      titles = rows.map { _1["Title"] }
       expect(titles).to eq titles.sort
     end
 
@@ -46,7 +45,7 @@ RSpec.describe Alexandria::ExportLibrary do
       sort_by_date_desc = Alexandria::LibrarySortOrder.new(:publishing_year, false)
       format.invoke(my_library, sort_by_date_desc, outfile)
       rows = load_rows_from_csv
-      dates = rows.map { |it| it["Year Published"] }
+      dates = rows.map { _1["Year Published"] }
       expect(dates).to eq dates.sort.reverse
     end
   end
@@ -55,12 +54,13 @@ RSpec.describe Alexandria::ExportLibrary do
     let(:message) { :export_as_html }
 
     it "can export unsorted" do
-      format.invoke(my_library, unsorted, outfile, Alexandria::WebTheme.all.first)
+      format.invoke(my_library, Alexandria::LibrarySortOrder::Unsorted.new,
+                    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
+        expect(outfile).to be_an_existing_file
+        expect(index).to be_an_existing_file
         expect(File.size(index)).to be_nonzero
       end
     end
@@ -70,9 +70,9 @@ RSpec.describe Alexandria::ExportLibrary do
     let(:message) { :export_as_onix_xml_archive }
 
     it "can export unsorted" do
-      format.invoke(my_library, unsorted, outfile)
+      format.invoke(my_library, Alexandria::LibrarySortOrder::Unsorted.new, outfile)
       aggregate_failures do
-        expect(File.exist?(outfile)).to be_truthy
+        expect(outfile).to be_an_existing_file
         expect(File.size(outfile)).to be_nonzero
       end
     end
@@ -82,9 +82,9 @@ RSpec.describe Alexandria::ExportLibrary do
     let(:message) { :export_as_tellico_xml_archive }
 
     it "can export unsorted" do
-      format.invoke(my_library, unsorted, outfile)
+      format.invoke(my_library, Alexandria::LibrarySortOrder::Unsorted.new, outfile)
       aggregate_failures do
-        expect(File.exist?(outfile)).to be_truthy
+        expect(outfile).to be_an_existing_file
         expect(File.size(outfile)).to be_nonzero
       end
     end
@@ -92,12 +92,58 @@ RSpec.describe Alexandria::ExportLibrary do
 
   describe "#export_as_bibtex" do
     let(:message) { :export_as_bibtex }
+    let(:expected_content) do
+      <<~BIBTEX
+        %Generated on #{Date.today} by: Alexandria #{Alexandria::DISPLAY_VERSION}
+        %
+
+        @BOOK{William1,
+        author = "William Gibson",
+        title = "Pattern Recognition",
+        publisher = "Penguin Books Ltd",
+        year = 2004
+        }
+
+        @BOOK{Francoise1,
+        author = "Francoise Sagan and Irene Ash",
+        title = "Bonjour Tristesse",
+        publisher = "Penguin Books Ltd",
+        OPTnote = "Essential penguin",
+        year = 1998
+        }
+
+        @BOOK{Kazuo1,
+        author = "Kazuo Ishiguro",
+        title = "An Artist of the Floating World",
+        publisher = "Faber and Faber",
+        year = 1999
+        }
+
+        @BOOK{Ursula1,
+        author = "Ursula Le Guin",
+        title = "The Dispossessed",
+        publisher = "Gollancz",
+        OPTnote = "Gollancz S.F.",
+        year = 2006
+        }
+
+        @BOOK{Neil1,
+        author = "Neil Gaiman",
+        title = "Neverwhere",
+        publisher = "Headline Review",
+        OPTnote = "The Author's Preferred Text",
+        year = 2005
+        }
+
+      BIBTEX
+    end
 
     it "can export unsorted" do
-      format.invoke(my_library, unsorted, outfile)
+      format.invoke(my_library, Alexandria::LibrarySortOrder::Unsorted.new, outfile)
       aggregate_failures do
-        expect(File.exist?(outfile)).to be_truthy
+        expect(outfile).to be_an_existing_file
         expect(File.size(outfile)).to be_nonzero
+        expect(File.read(outfile)).to eq expected_content
       end
     end
   end
@@ -106,9 +152,9 @@ RSpec.describe Alexandria::ExportLibrary do
     let(:message) { :export_as_isbn_list }
 
     it "can export unsorted" do
-      format.invoke(my_library, unsorted, outfile)
+      format.invoke(my_library, Alexandria::LibrarySortOrder::Unsorted.new, outfile)
       aggregate_failures do
-        expect(File.exist?(outfile)).to be_truthy
+        expect(outfile).to be_an_existing_file
         expect(File.size(outfile)).to be_nonzero
       end
     end
@@ -118,11 +164,11 @@ RSpec.describe Alexandria::ExportLibrary do
     let(:message) { :export_as_ipod_notes }
 
     it "can export unsorted" do
-      format.invoke(my_library, unsorted, outfile, nil)
+      format.invoke(my_library, Alexandria::LibrarySortOrder::Unsorted.new, outfile, nil)
       index = File.join(outfile, "index.linx")
 
       aggregate_failures do
-        expect(File.exist?(outfile)).to be_truthy
+        expect(outfile).to be_an_existing_file
         expect(File.size(index)).to be_nonzero
       end
     end

data/spec/alexandria/library_collection_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# This file is part of Alexandria.
+#
+# See the file README.md for authorship and licensing information.
+
+require "spec_helper"
+
+RSpec.describe Alexandria::LibraryCollection do
+  describe "#ruined_books" do
+    before do
+      test_library = File.join(LIBDIR, "0.6.2")
+      FileUtils.cp_r(test_library, TESTDIR)
+    end
+
+    it "lists ISBNs of empty files with their libraries" do
+      FileUtils.touch File.join(TESTDIR, "My Library", "0740704923.yaml")
+      collection = described_class.instance
+      collection.reload
+      library = collection.all_libraries.first
+      expect(collection.ruined_books).to eq [[nil, "0740704923", library]]
+    end
+  end
+end

data/spec/alexandria/library_spec.rb

@@ -12,62 +12,71 @@ describe Alexandria::Library 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
+      aggregate_failures do
+        expect(extensions[:book]).not_to be_nil
+        expect(extensions[:cover]).not_to be_nil
+      end
     end
   end
 
   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
+        expect(described_class.valid_isbn?(x)).to be true
       end
     end
   end
 
   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
+      aggregate_failures do
+        expect(described_class.valid_ean?("9780345431929")).to be true
+        expect(described_class.valid_ean?("978034543192912345")).to be true
 
-      # Regression test: this EAN has a checksum of 10, which should be
-      # treated like a checksum of 0.
-      expect(described_class.valid_ean?("9784047041790")).to be_truthy
+        # Regression test: this EAN has a checksum of 10, which should be
+        # treated like a checksum of 0.
+        expect(described_class.valid_ean?("9784047041790")).to be true
+      end
     end
 
     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
+      invalid_eans = ["780345431929", "97803454319290", "97803454319291234",
+                      "9780345431929123456", "9780345431928", "9780345431929A",
+                      "9784047041791"]
 
-      expect(described_class.valid_ean?("9784047041791")).to be_falsey
+      aggregate_failures do
+        invalid_eans.each do |ean|
+          expect(described_class.valid_ean?(ean)).to be false
+        end
+      end
     end
   end
 
   describe "#valid_upc?" do
     it "returns a true value for valid UPCs" do
-      expect(described_class.valid_upc?("97803454319312356")).to be_truthy
+      expect(described_class.valid_upc?("97803454319312356")).to be true
     end
 
     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
+      aggregate_failures do
+        expect(described_class.valid_upc?("978034543193123567")).to be false
+        expect(described_class.valid_upc?("9780345431931235")).to be false
 
-      expect(described_class.valid_upc?("97803454319412356")).to be_falsey
-      expect(described_class.valid_upc?("97803454319212356")).to be_falsey
+        expect(described_class.valid_upc?("97803454319412356")).to be false
+        expect(described_class.valid_upc?("97803454319212356")).to be false
+      end
     end
   end
 
   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(described_class.canonicalise_isbn("9780345431929")).to eq "0345431928"
+      aggregate_failures 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(described_class.canonicalise_isbn("9780345431929")).to eq "0345431928"
+      end
     end
   end
 
@@ -75,7 +84,7 @@ describe Alexandria::Library do
     let(:my_library) { loader.load_library("Empty") }
 
     before do
-      FileUtils.mkdir(TESTDIR) unless File.exist? TESTDIR
+      FileUtils.mkdir_p(TESTDIR)
     end
 
     it "disallows multiple deletion of the same copy of a book" do
@@ -136,21 +145,27 @@ describe Alexandria::Library do
     end
 
     it "can be loaded" do
-      expect(libs.size).to eq(1)
-      expect(my_library.size).to eq(3)
+      aggregate_failures do
+        expect(libs.size).to eq(1)
+        expect(my_library.size).to eq(3)
+      end
     end
 
-    it "imports cleanly from version 0.6.1 data format" do
-      # Malory
+    it "imports Malory book cleanly from version 0.6.1 data format" do
       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)
+      aggregate_failures do
+        expect(malory_book.publisher).to eq("Oxford University Press")
+        expect(malory_book.authors).to include "Vinaver"
+        expect(malory_book.version).to eq(Alexandria::DATA_VERSION)
+      end
+    end
 
-      # Guide to LaTeX
+    it "imports Guide to LaTeX cleanly from version 0.6.1 data format" do
       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")
+      aggregate_failures do
+        expect(latex_book.isbn).to eq("9780201398250")
+        expect(latex_book.publisher).to eq("Addison Wesley")
+      end
     end
   end
 
@@ -168,16 +183,20 @@ describe Alexandria::Library do
     end
 
     it "can be loaded" do
-      expect(libs.size).to eq(1)
-      expect(my_library.size).to eq(2)
+      aggregate_failures do
+        expect(libs.size).to eq(1)
+        expect(my_library.size).to eq(2)
+      end
     end
 
     it "loads a book with ISBN" do
       # Guide to LaTeX
       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")
-      expect(latex_book.version).to eq(Alexandria::DATA_VERSION)
+      aggregate_failures do
+        expect(latex_book.isbn).to eq("9780201398250")
+        expect(latex_book.publisher).to eq("Addison Wesley")
+        expect(latex_book.version).to eq(Alexandria::DATA_VERSION)
+      end
     end
 
     it "loads a book without ISBN" do
@@ -189,13 +208,9 @@ describe Alexandria::Library do
     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.find { |b| b.title.include? "Latex" }
-      expect(latex_book.publisher).to eq("Addison Wesley")
 
-      lex_and_yacc_book = my_library_reloaded.find { |b| b.title.include? "Lex" }
-      expect(lex_and_yacc_book.publisher).to eq("O'Reilley")
+      expect(my_library_reloaded.map(&:publisher))
+        .to contain_exactly("O'Reilley", "Addison Wesley")
     end
   end
 
@@ -224,10 +239,10 @@ describe Alexandria::Library 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
+        expect(source.yaml(book)).not_to be_an_existing_file
+        expect(source.cover(book)).not_to be_an_existing_file
+        expect(target.yaml(book)).to be_an_existing_file
+        expect(target.cover(book)).to be_an_existing_file
       end
     end
   end
@@ -236,7 +251,7 @@ describe Alexandria::Library do
     let(:my_library) { loader.load_library("Empty") }
 
     before do
-      FileUtils.mkdir(TESTDIR) unless File.exist? TESTDIR
+      FileUtils.mkdir_p(TESTDIR)
     end
 
     it "changes the library's name" do
@@ -246,7 +261,7 @@ describe Alexandria::Library do
 
     it "moves the library's directory" do
       my_library.name = "Really Empty"
-      expect(File.exist?(File.join(TESTDIR, "Really Empty"))).to be_truthy
+      expect(File.join(TESTDIR, "Really Empty")).to be_an_existing_file
     end
   end
 end

data/spec/alexandria/library_store_spec.rb

@@ -16,7 +16,7 @@ RSpec.describe Alexandria::LibraryStore do
         aggregate_failures do
           expect(smart_libs.size).to eq 5
           smart_libs.each do |lib|
-            expect(File.exist?(lib.yaml)).to be_truthy
+            expect(lib.yaml).to be_an_existing_file
           end
         end
       end
@@ -34,4 +34,36 @@ RSpec.describe Alexandria::LibraryStore do
       end
     end
   end
+
+  describe "#load_all_libraries" do
+    before do
+      test_library = File.join(LIBDIR, "0.6.2")
+      FileUtils.cp_r(test_library, TESTDIR)
+    end
+
+    it "loads the libraries in the target directory" do
+      result = loader.load_all_libraries
+      aggregate_failures do
+        expect(result.count).to eq 1
+        expect(result.first.map(&:title))
+          .to contain_exactly("Pattern Recognition", "Bonjour Tristesse",
+                              "An Artist of the Floating World", "The Dispossessed",
+                              "Neverwhere")
+      end
+    end
+
+    it "lists ISBNs of empty files in ruined books" do
+      FileUtils.touch File.join(TESTDIR, "My Library", "0740704923.yaml")
+      result = loader.load_all_libraries
+      library = result.first
+      expect(library.ruined_books).to eq ["0740704923"]
+    end
+
+    it "skips empty files with names that are not valid ISBNs" do
+      FileUtils.touch File.join(TESTDIR, "My Library", "12345.yaml")
+      result = loader.load_all_libraries
+      library = result.first
+      expect(library.ruined_books).to be_empty
+    end
+  end
 end

data/spec/alexandria/preferences_spec.rb

@@ -11,17 +11,17 @@ describe Alexandria::Preferences do
 
   describe "#get_variable" do
     it "returns nil fetching unknown setting" do
-      expect(instance.get_variable("does_not_exist")).to eq nil
+      expect(instance.get_variable("does_not_exist")).to be_nil
     end
 
     it "allows fetching by string" do
       instance.toolbar_visible = false
-      expect(instance.get_variable("toolbar_visible")).to eq false
+      expect(instance.get_variable("toolbar_visible")).to be false
     end
 
     it "allows fetching by symbol" do
       instance.toolbar_visible = true
-      expect(instance.get_variable(:toolbar_visible)).to eq true
+      expect(instance.get_variable(:toolbar_visible)).to be true
     end
   end
 
@@ -29,23 +29,23 @@ describe Alexandria::Preferences do
     it "allows setting by string" do
       instance.toolbar_visible = false
       instance.set_variable("toolbar_visible", true)
-      expect(instance.toolbar_visible).to eq true
+      expect(instance.toolbar_visible).to be 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
+      expect(instance.toolbar_visible).to be true
     end
   end
 
   it "allows setting known setting to false" do
     instance.toolbar_visible = false
-    expect(instance.toolbar_visible).to eq false
+    expect(instance.toolbar_visible).to be false
   end
 
   it "resets known setting by setting to nil" do
     instance.toolbar_visible = nil
-    expect(instance.toolbar_visible).to eq true
+    expect(instance.toolbar_visible).to be true
   end
 end

data/spec/alexandria/pseudo_marc_parser_spec.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2022 Matijs van Zuijlen
+#
+# 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.
+
+require "spec_helper"
+
+RSpec.describe Alexandria::PseudoMarcParser do
+  describe ".marc_text_to_book" do
+    let(:marc_text) do
+      <<~MARC
+        00991pam  2200289 a 4500
+        001 426456
+        005 19820209000000.0
+        008 811005s1981    maua     b    001 0 eng#{'  '}
+        035    $9 (DLC)   81017108
+        906    $a 7 $b cbc $c orignew $d 1 $e ocip $f 19 $g y-gencatlg
+        010    $a    81017108#{' '}
+        020    $a 0805335587
+        020    $a 0805335579 (pbk.)
+        040    $a DLC $c DLC $d DLC
+        050 00 $a QA612 $b .G7
+        082 00 $a 514/.2 $2 19
+        100 1  $a Greenberg, Marvin J.
+        245 10 $a Algebraic topology : $b a first course / $c Marvin J. Greenberg, John R. Harper.
+        260    $a Reading, Mass. : $b Benjamin/Cummings Pub. Co., $c 1981.
+        300    $a xi, 311 p. : $b ill. ; $c 24 cm.
+        440  0 $a Mathematics lecture note series ; $v 58
+        500    $a "A revision of the first author's Lectures on algebraic topology"--P.
+        504    $a Bibliography: p. 303-307.
+        500    $a Includes index.
+        650  0 $a Algebraic topology.
+        700 1  $a Harper, John R., $d 1941-
+        991    $b c-GenColl $h QA612 $i .G7 $p 00035736761 $t Copy 1 $w BOOKS
+      MARC
+    end
+
+    it "returns a book with the correct attributes" do
+      result = described_class.marc_text_to_book(marc_text,
+                                                 described_class::USMARC_MAPPINGS)
+      aggregate_failures do
+        expect(result.title).to eq "Algebraic topology: a first course"
+        expect(result.authors).to eq ["Greenberg, Marvin J."]
+      end
+    end
+
+    it "returns nil when passed a blank string" do
+      result = described_class.marc_text_to_book("", described_class::USMARC_MAPPINGS)
+      expect(result).to be_nil
+    end
+
+    it "returns nil when passed nil" do
+      result = described_class.marc_text_to_book(nil, described_class::USMARC_MAPPINGS)
+      expect(result).to be_nil
+    end
+  end
+end

data/spec/alexandria/scanners/cue_cat_spec.rb

@@ -27,10 +27,17 @@ describe Alexandria::Scanners::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
+  it "refuses to detect incomplete scans" do
+    aggregate_failures do
+      partials.each { |scan| expect(cuecat.match?(scan)).to be false }
+    end
+  end
+
+  it "detects complete scans" do
+    aggregate_failures do
+      expect(cuecat.match?(scans[:isbn])).to be true
+      expect(cuecat.match?(scans[:ib5])).to be true
+    end
   end
 
   it "decodes ISBN barcodes" do

data/spec/alexandria/scanners/keyboard_wedge_spec.rb

@@ -0,0 +1,47 @@
+# 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::KeyboardWedge do
+  let(:scanner) { described_class.new }
+  let(:partials) do
+    ["9",
+     "978057507",
+     "97805711471"]
+  end
+  let(:scans) do
+    {
+      isbn: "978 05711 47168",
+      ib5: "978057 5079038 007 99"
+    }
+  end
+
+  it "is called KeyboardWedge" do
+    expect(scanner.name).to match(/KeyboardWedge/i)
+  end
+
+  it "refuses to detect incomplete scans" do
+    aggregate_failures do
+      partials.each { |scan| expect(scanner.match?(scan)).to be false }
+    end
+  end
+
+  it "detects complete scans" do
+    aggregate_failures do
+      expect(scanner.match?(scans[:isbn])).to be true
+      expect(scanner.match?(scans[:ib5])).to be true
+    end
+  end
+
+  it "decodes ISBN barcodes" do
+    expect(scanner.decode(scans[:isbn])).to eq("9780571147168")
+  end
+
+  it "decodes ISBN+5 barcodes" do
+    expect(scanner.decode(scans[:ib5])).to eq("9780575079038") # 00799
+  end
+end