rbook 0.4.3 → 0.5

data/test/unit/bisac/po_line_item_test.rb

@@ -1,38 +0,0 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../../lib')
-
-require 'test/unit'
-require 'rbook/bisac'
-
-class POLineItemTest < Test::Unit::TestCase
-
-  def setup
-    @row = "4000003 14976       Y000000000102978513220000100000000000000000000550000000"
-  end
-
-  # ensure the load_from_string method works as expected
-  def test_load_from_string
-    item = RBook::Bisac::POLineItem.load_from_string(@row)
-    assert_kind_of RBook::Bisac::POLineItem, item
-
-    assert_equal item.sequence_number, 3
-    assert_equal item.po_number, "14976"
-    assert_equal item.line_item_number, "0000000001"
-    assert_equal item.isbn, "0297851322"
-    assert_equal item.qty, 1
-    assert_equal item.catalogue_code, "0"
-    assert_equal item.price, 0
-  end
-
-  # ensure the load_from_file method throws the correct exceptions
-  # when it encounters a problem
-  def test_product_validation
-    
-    #assert_raise(RVista::InvalidLineItemError) {
-    #  item = RVista::LineItem.load_from_array(%w[D blah])
-    #}
-
-  end
-
-end
-
-

data/test/unit/bisac/po_test.rb

@@ -1,82 +0,0 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../../lib')
-
-require 'test/unit'
-require 'rbook/bisac'
-
-class POTest < Test::Unit::TestCase
-
-  VALID = File.dirname(__FILE__) + "/../../data/bisac_po.txt"
-  #INVALID_MISSING_HEADER = File.dirname(__FILE__) + "/../data/invalid_missing_header.txt"
-  #INVALID_MISSING_FOOTER = File.dirname(__FILE__) + "/../data/invalid_missing_footer.txt"
-  #INVALID_LINE = File.dirname(__FILE__) + "/../data/invalid_line.txt"
-  #INVALID_DOESNT_EXIST = File.dirname(__FILE__) + "/../data/blah.txt"
-
-  # ensure the load_from_file method works as expected
-  def test_load_from_file
-    msg = RBook::Bisac::PO.load_from_file(VALID)
-    assert_kind_of RBook::Bisac::PO, msg
-    assert_equal msg.items.size, 36
-
-    validate_msg(msg)
-  end
-
-  # ensure the load_from_file method works as expected
-  def test_load_from_string
-    msg = RBook::Bisac::PO.load_from_string(File.read(VALID))
-    assert_kind_of RBook::Bisac::PO, msg
-    assert_equal msg.items.size, 36
-    
-    assert_equal "Finding Sanctuary :Monastic St", msg.items.first.title
-    assert_equal "JAMISON ABBOT CHRISTOPH", msg.items.first.author
-
-    validate_msg(msg)
-  end
-
-  # ensure the load_from_file method throws the correct exceptions
-  # when it encounters a problem
-  def test_product_validation
-    
-    #assert_raise(RVista::InvalidFileError) {
-    #  msg = RVista::Message.load_from_file(INVALID_MISSING_HEADER)
-    #}
-
-    #assert_raise(RVista::InvalidFileError) {
-    #  msg = RVista::Message.load_from_file(INVALID_MISSING_FOOTER)
-    #}
-    
-    #assert_raise(RVista::InvalidLineItemError) {
-    #  msg = RVista::Message.load_from_file(INVALID_LINE)
-    #}
-
-    #assert_raise(RVista::InvalidFileError) {
-    #  msg = RVista::Message.load_from_file(INVALID_DOESNT_EXIST)
-    #}
-
-  end
-
-  private
-
-  # ensures the properties of the supplied RVista::Message object
-  # match the properties specified in the VALID file
-  def validate_msg(msg)
-    assert_equal msg.source_san, "9013725"
-    assert_equal msg.source_suffix, ""
-    assert_equal msg.source_name, "Rainbow Book"
-    assert_equal msg.date, "061112"
-    assert_equal msg.filename, "INTERNET.BSC"
-    assert_equal msg.format_version, "F03"
-    assert_equal msg.destination_san, "9021000"
-    assert_equal msg.destination_suffix, ""
-    assert_equal msg.po_number, "14976"
-    assert_equal msg.cancellation_date, "000000"
-    assert_equal msg.backorder, true
-    assert_equal msg.do_not_exceed_action, ""
-    assert_equal msg.do_not_exceed_amount, "0000000"
-    assert_equal msg.invoice_copies, "01"
-    assert_equal msg.special_instructions, false
-    assert_equal msg.do_not_ship_before, "000000"
-  end
-
-end
-
-

data/test/unit/isbn_test.rb

@@ -1,153 +0,0 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
-
-require 'test/unit'
-require 'rbook/isbn'
-
-class ISBNTest < Test::Unit::TestCase
-
-include RBook
-
-  def test_add_groups
-    assert_equal ISBN::add_groups('020161622X'), '0-20161-622-X'
-    assert_equal ISBN::add_groups('9780201616224'), '978-0-20161-622-4'
-    assert_equal ISBN::add_groups('invalId'), 'invalId'
-  end
-    
-  def test_add_groups_destructive
-    isbn = '020161622X'
-    new_isbn = ISBN::add_groups(isbn)
-    assert_equal( isbn, '020161622X')
-  
-    isbn = '978201616224'
-    new_isbn = ISBN::add_groups(isbn)
-    assert_equal( isbn, '978201616224')
-  end
-  
-  def test_add_boundaries
-    assert_equal ISBN::add_groups(''), ''
-    assert_equal ISBN::add_groups(nil), nil
-  end
-  
-  def test_valid_isbn10
-    assert_equal ISBN::valid_isbn10?('020161622X'), true
-    assert_equal ISBN::valid_isbn10?('020161622'), false
-    assert_equal ISBN::valid_isbn10?('023252565X'), true
-    assert_equal ISBN::valid_isbn10?('023252565x'), true
-    assert_equal ISBN::valid_isbn10?('020-161-622-X'), true
-    assert_equal ISBN::valid_isbn10?('9780764812200'), false
-    assert_equal ISBN::valid_isbn10?('12345'), false
-    assert_equal ISBN::valid_isbn10?('12345 7890'), false
-    assert_equal ISBN::valid_isbn10?('CD-DSE'), false
-  end
-
-  def test_valid_isbn10_boundaries
-    assert_equal ISBN::valid_isbn10?(''), false
-    assert_equal ISBN::valid_isbn10?('11278217391827398217391723918723918'), false
-    assert_equal ISBN::valid_isbn10?(nil), false
-    assert_equal ISBN::valid_isbn10?(1234567890), false
-  end
-
-  def test_valid_isbn13
-    assert_equal ISBN::valid_isbn13?('9780201616224'), true
-    assert_equal ISBN::valid_isbn13?('978020161622'), false
-    assert_equal ISBN::valid_isbn13?('9780764812200'), true
-    assert_equal ISBN::valid_isbn13?('978-02016-1622-4'), true
-    assert_equal ISBN::valid_isbn13?('978076481220'), false
-    assert_equal ISBN::valid_isbn13?('978 NCR  4611'), false
-    assert_equal ISBN::valid_isbn13?('12345'), false
-    assert_equal ISBN::valid_isbn13?('CD-DSE'), false
-    assert_equal ISBN::valid_isbn13?('020161622X'), false
-  end
-
-  def test_valid_isbn13_boundaries
-    assert_equal ISBN::valid_isbn13?(''), false
-    assert_equal ISBN::valid_isbn13?('11278217391827398217391723918723918'), false
-    assert_equal ISBN::valid_isbn13?(nil), false
-    assert_equal ISBN::valid_isbn13?(9781234567890), false
-  end
-
-  def test_calc_isbn10_check
-    assert_equal ISBN::calc_isbn10_check('020161622'), 'X'
-    assert_equal ISBN::calc_isbn10_check('055299777'), '3'
-  end
-
-  def test_calc_isbn10_check_boundaries
-    assert_equal ISBN::calc_isbn10_check(''), nil
-    assert_equal ISBN::calc_isbn10_check(nil), nil
-    assert_equal ISBN::calc_isbn10_check(978020161622), nil
-    assert_equal ISBN::calc_isbn10_check(' - '), nil
-  end
-
-  def test_calc_isbn13_check
-    assert_equal ISBN::calc_isbn13_check('978020161622'), '4'
-    assert_equal ISBN::calc_isbn13_check('978055299777'), '5'
-  end
-  
-  def test_calc_isbn13_boundaries
-    assert_equal ISBN::calc_isbn13_check(''), nil
-    assert_equal ISBN::calc_isbn13_check(nil), nil
-    assert_equal ISBN::calc_isbn13_check(978020161622), nil
-    assert_equal ISBN::calc_isbn13_check(' - '), nil
-  end
-  
-  def test_convert_to_isbn10
-    #some random titles
-    assert_equal ISBN::convert_to_isbn10('9780764812200'), '0764812203'
-    assert_equal ISBN::convert_to_isbn10('9781856075336'), '1856075338'
-    assert_equal ISBN::convert_to_isbn10('9780232525656'), '023252565X'
-    assert_equal ISBN::convert_to_isbn10('9781863951340'), '1863951342'
-    assert_equal ISBN::convert_to_isbn10('978 NCR  4611'), nil
-    
-    # a 979 ISBN13 that can't be converted to isbn10
-    assert_equal ISBN::convert_to_isbn10('9791863951340'), nil
-    
-    # already isbn10
-    assert_equal ISBN::convert_to_isbn10('1856075338'), '1856075338'
-
-    # valid isbn without a checkdigit
-    assert_equal ISBN::convert_to_isbn10('185607533'), nil
-
-    #non valid isbns
-    assert_equal ISBN::convert_to_isbn10('AAAAAAA'), nil
-
-  end
-
-  def test_convert_to_isbn10_boundaries
-    assert_equal ISBN::convert_to_isbn13('  '), nil
-    assert_equal ISBN::convert_to_isbn13(nil), nil
-    assert_equal ISBN::convert_to_isbn13(120234203), nil
-    assert_equal ISBN::convert_to_isbn13('18273987123987129387192873912820234203'), nil
-  end
-
-  def test_convert_to_isbn13
-    #some random titles
-    assert_equal ISBN::convert_to_isbn13('0764812203'), '9780764812200'
-    assert_equal ISBN::convert_to_isbn13('1856075338'), '9781856075336'
-    assert_equal ISBN::convert_to_isbn13('023252565X'), '9780232525656'
-    assert_equal ISBN::convert_to_isbn13('023252565x'), '9780232525656'
-    assert_equal ISBN::convert_to_isbn13('1863951342'), '9781863951340'
-    assert_equal ISBN::convert_to_isbn13('186-395-134-2'), '9781863951340'
-    
-    #already isbn13
-    assert_equal ISBN::convert_to_isbn13('9781856075336'), '9781856075336'
-    
-    # valid isbn without a check digit
-    assert_equal ISBN::convert_to_isbn13('978185607533'), nil
-    
-    #non valid isbns
-    assert_equal ISBN::convert_to_isbn13('651887010820'), nil
-    assert_equal ISBN::convert_to_isbn13('AAAAAAA'), nil
-    assert_equal ISBN::convert_to_isbn13('CX-188'), nil
-
-  end
-  
-  def test_convert_to_isbn13_boundaries
-    assert_equal ISBN::convert_to_isbn13('  '), nil
-    assert_equal ISBN::convert_to_isbn13(nil), nil
-    assert_equal ISBN::convert_to_isbn13(120234203), nil
-    assert_equal ISBN::convert_to_isbn13('18273987123987129387192873912820234203'), nil
-  end
-  
-end
-
-

data/test/unit/onix/contributor_test.rb

@@ -1,50 +0,0 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
-
-require 'test/unit'
-require 'rexml/document'
-require 'rbook/onix'
-
-class ContributorTest < Test::Unit::TestCase
-
-  def test_load_from_element
-    
-    file = File.open(File.dirname(__FILE__)+"/../../data/single_product.xml", "r")
-    doc = REXML::Document.new(file)
-    contributor = RBook::Onix::Contributor.load_from_element(REXML::XPath.first(doc, '/ONIXMessage/Product/Contributor'))
-    
-    file.close
-
-    assert_equal('0', contributor.sequence_number)
-    assert_equal('A01', contributor.role)
-    assert_equal('Healy, James', contributor.name_inverted)
-  end
-
-  def test_load_from_element_not_contributor
-
-    element = REXML::Element.new('NonContributor')
-    element.add_element('SequenceNumber').text = 'blah'
-
-    assert_raise(LoadError) {
-      product = RBook::Onix::Contributor.load_from_element(element)
-    }
-
-  end
-
-  # ensure product information is output to xml correctly
-  def test_to_element
-
-    contributor = RBook::Onix::Contributor.new
-    contributor.name_inverted = 'Healy, James'
-    contributor.sequence_number = '01'
-    contributor.role = 'A01'
-
-    doc = contributor.to_element
-    
-    assert_not_equal(nil,REXML::XPath.first(doc, '/PersonNameInverted'), 'Person Name Inverted must not be nil')
-    assert_equal("Healy, James", REXML::XPath.first(doc, '/PersonNameInverted').text)
-    assert_not_equal(nil,REXML::XPath.first(doc, '/ContributorRole'), 'Contributor Role must not be nil')
-    assert_equal("A01", REXML::XPath.first(doc, '/ContributorRole').text)
-
-  end
-
-end

data/test/unit/onix/message_test.rb

@@ -1,119 +0,0 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
-
-require 'test/unit'
-require 'rexml/document'
-require 'date'
-require 'rbook/onix'
-
-class MessageTest < Test::Unit::TestCase
-
-  # test loading a valid onix file. Make sure the correct number of products
-  # exist, but don't worry about the content. The product unit tests can check them
-  def test_load_from_xmldoc
-    
-    file = File.open(File.dirname(__FILE__)+"/../../data/single_product.xml", "r")
-    doc = REXML::Document.new(file) 
-    msg = RBook::Onix::Message.load_from_xmldoc(doc)
-    
-    file.close
-    
-    #check header elements
-    assert_equal('Chalice', msg.from_company)
-    assert_equal('James Healy', msg.from_person)
-    assert Date.civil(2006, 5, 21) === msg.sent_date
-    
-    #check product count
-    assert_equal(1, msg.products.size)
-  
-  end
-
-  # try loading an onix file with no products
-  def test_load_from_xmldoc_invalid_no_product
-    file = File.open(File.dirname(__FILE__)+"/../../data/invalid_no_product.xml", "r")
-    doc = REXML::Document.new(file)
-    
-    assert_raise(LoadError) {
-      msg = RBook::Onix::Message.load_from_xmldoc(doc)
-    }
-  end
-
-  # test loading an xml file that's not an onix file
-  def test_load_from_xmldoc_invalid_not_onix
-    file = File.open(File.dirname(__FILE__)+"/../../data/xml_not_onix.xml", "r")
-    doc = REXML::Document.new(file)
-    
-    assert_raise(LoadError) {
-      msg = RBook::Onix::Message.load_from_xmldoc(doc)
-    }
-  
-  end
-
-  # test loading a non XML file
-  def test_load_from_xmldoc_invalid_not_xml
-    file = File.open(File.dirname(__FILE__)+"/../../data/not_xml.csv", "r")
-    doc = REXML::Document.new(file)
-    
-    assert_raise(LoadError) {
-      msg = RBook::Onix::Message.load_from_xmldoc(doc)
-    }
-
-  end
-
-  # ensure header information is output to xml correctly and that a 
-  # product is created
-  def test_to_xml
-    msg = RBook::Onix::Message.new
-    msg.from_person = "James Healy"
-    msg.from_company = "Healy Inc."
-    msg.to_person = "Test::Unit"
-
-    product = RBook::Onix::Product.new
-    product.product_identifier = '0977616606'
-    msg.add_product(product)
-
-    doc = msg.to_xml
-
-    assert_not_equal(nil,REXML::XPath.first(doc, '/ONIXMessage/Header/FromPerson'))
-    assert_equal("James Healy", REXML::XPath.first(doc, '/ONIXMessage/Header/FromPerson').text)
-    assert_not_equal(nil,REXML::XPath.first(doc, '/ONIXMessage/Header/FromCompany'))
-    assert_equal("Healy Inc.", REXML::XPath.first(doc, '/ONIXMessage/Header/FromCompany').text)
-    assert_not_equal(nil,REXML::XPath.first(doc, '/ONIXMessage/Header/ToPerson'))
-    assert_equal("Test::Unit", REXML::XPath.first(doc, '/ONIXMessage/Header/ToPerson').text)
-    assert_not_equal(nil,REXML::XPath.first(doc, '/ONIXMessage/Product'))
-  end
-
-  # test for an exception when a onixmessage with no products is converted to an xml document
-  def test_to_xml_no_product
-    msg = RBook::Onix::Message.new
-    msg.from_person = "James Healy"
-    msg.from_company = "Healy Inc."
-    msg.to_person = "Test::Unit"
-
-    assert_raise(RuntimeError) {
-      doc = msg.to_xml
-    }
-  end
-
-  def test_to_s_valid_utf8_charset
-    msg = RBook::Onix::Message.new
-    msg.from_person = "James Healy\x11"
-    msg.from_company = "Healy Inc.\x11"
-    msg.from_email = "someone@example.com\x11"
-    msg.to_person = "Test::Unit\x11"
-    msg.to_company = "Sample Company\x11"
-    msg.message_note = "This is a sample ONIX message\x11"
-
-    product = RBook::Onix::Product.new
-    product.product_identifier = '0977616606'
-    product.title = 'Test Title'
-    msg.add_product(product)
-
-    doc = msg.to_s
-
-    doc.each_byte do |c|
-      n = XChar::CP1252[c] || c
-      n = nil unless XChar::VALID.find {|range| range.include? n}
-      assert_not_equal nil, n, "Non valid UTF8 char detected (code: #{n.to_s})"
-    end
-  end
-end

data/test/unit/onix/product_test.rb

@@ -1,101 +0,0 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
-
-require 'test/unit'
-require 'rexml/document'
-require 'date'
-require 'rbook/onix'
-
-class ProductTest < Test::Unit::TestCase
-
-  def test_load_from_element
-    
-    file = File.open(File.dirname(__FILE__)+"/../../data/single_product.xml", "r")
-    doc = REXML::Document.new(file) 
-    product = RBook::Onix::Product.load_from_element(REXML::XPath.first(doc, '/ONIXMessage/Product'))
-    
-    file.close
-    
-    #check header elements
-    assert_equal('03', product.notification_type)
-    assert_equal('0827200528', product.record_reference)
-    assert_equal('BA', product.form)
-    assert_equal('0', product.pages)    
-    assert_equal('YFH', product.bicmainsubject)
-    assert_equal('And Their Eyes Are Opened', product.title)
-    assert_equal('Story Sermons Embracing the World', product.subtitle)
-    assert_equal('Chalice', product.publisher)
-    assert Date.civil(2005, 3, 3) === product.publication_date
-
-    assert_equal(1, product.contributors.size, 'Product should contain 1 contributor')
-    assert_equal(1, product.supply_details.size, 'Product should contain 1 supply detail')
-
-  end
-
-  def test_load_from_element_not_product
-
-    element = REXML::Element.new('NonProduct')
-    element.add_element('NonContributor').text = 'blah'
-
-    assert_raise(LoadError) {
-      product = RBook::Onix::Product.load_from_element(element)
-    }
-
-  end
-
-  # ensure product information is output to xml correctly
-  # TODO: test more than just IDValue and TitleText
-  def test_to_element
-
-    product = RBook::Onix::Product.new
-    product.product_identifier = '0977616606'
-    product.title = 'This is a title'
-    product.publisher = 'Chalice'
-
-    contributor = RBook::Onix::Contributor.new
-    contributor.sequence_number = '0'
-    contributor.name_inverted = 'Healy, James'
-    contributor.role = 'A01'
-    product.add_contributor(contributor)
-
-    supply_detail = RBook::Onix::SupplyDetail.new
-    supply_detail.supplier_name = 'Walker'
-    supply_detail.availability_code = 'CS'
-    supply_detail.price = 29.95
-    product.add_supply_detail(supply_detail)
-
-    doc = product.to_element
-    
-    assert_not_equal(nil,REXML::XPath.first(doc, '/ProductIdentifier/IDValue'))
-    assert_equal("0977616606", REXML::XPath.first(doc, '/ProductIdentifier/IDValue').text)
-    assert_not_equal(nil,REXML::XPath.first(doc, '/Title/TitleText'), 'TitleText must not be nil')
-    assert_equal("This is a title", REXML::XPath.first(doc, '/Title/TitleText').text)
-    assert_not_equal(nil, REXML::XPath.first(doc, '/Contributor'), 'Expected product element to contain a contributor')
-    assert_not_equal(nil, REXML::XPath.first(doc, '/Publisher/PublisherName'), 'Expected publisher name element to contain a contributor')
-    assert_equal("Chalice", REXML::XPath.first(doc, '/Publisher/PublisherName').text)
-    assert_not_equal(nil, REXML::XPath.first(doc, '/SupplyDetail'), 'Expected product element to contain a supply detail')
-  end
-
-  def test_to_s_valid_utf8_charset
-
-    # create an Onix::Product fragment
-    product = RBook::Onix::Product.new
-    product.product_identifier = "0977616606"
-    product.title = "Test Title\x11"
-    product.subtitle = "Test Subtitle\x11"
-    product.website = "http://www.google.com\x11"
-    product.form = "BA\x11"
-    product.bicmainsubject = "FGD\x11"
-    product.description = "This is a sample description\x11"
-    product.publisher = "Publisher\x11"
-
-    fragment = product.to_s
-    
-    # loop over each byte in the product element and check it's
-    # a valid UTF-8 character
-    fragment.each_byte do |c|
-      n = XChar::CP1252[c] || c
-      n = nil unless XChar::VALID.find {|range| range.include? n}
-      assert_not_equal nil, n, "Non valid UTF8 char detected (code: #{n.to_s})"
-    end
-  end
-end