oai_talia 0.0.13

data/test/client/tc_list_identifiers.rb

@@ -0,0 +1,52 @@
+require 'test_helper'
+
+class ListIdentifiersTest < Test::Unit::TestCase
+
+  def test_list_with_resumption_token
+    client = OAI::Client.new 'http://localhost:3333/oai' 
+
+    # get a list of identifier headers
+    response = client.list_identifiers :metadata_prefix => 'oai_dc' 
+    assert_kind_of OAI::ListIdentifiersResponse, response
+    assert_kind_of OAI::Response, response
+    assert response.entries.size > 0
+
+    # make sure header is put together reasonably
+    header = response.entries[0]
+    assert_kind_of OAI::Header, header
+    assert header.identifier
+    assert header.datestamp
+    assert header.set_spec
+
+    # exercise a resumption token and make sure first identifier is different
+    first_identifier = response.entries[0].identifier
+    token = response.resumption_token
+    assert_not_nil token
+    response = client.list_identifiers :resumption_token => token
+    assert response.entries.size > 0
+    assert_not_equal response.entries[0].identifier, first_identifier
+  end
+
+  def test_list_with_date_range
+    client = OAI::Client.new 'http://localhost:3333/oai'
+    from_date = Date.new(1998,1,1)
+    until_date  = Date.new(2002,1,1)
+    response = client.list_identifiers :from => from_date, :until => until_date
+    assert response.entries.size > 0
+  end
+
+  def test_list_with_datetime_range
+    # xtcat should support higher granularity
+    client = OAI::Client.new 'http://localhost:3333/oai'
+    from_date = DateTime.new(2001,1,1)
+    until_date = DateTime.now
+    response = client.list_identifiers :from => from_date, :until => until_date
+    assert response.entries.size > 0
+  end
+
+  def test_invalid_argument
+    client = OAI::Client.new 'http://localhost:3333/oai'
+    assert_raise(OAI::ArgumentException) {client.list_identifiers :foo => 'bar'}
+  end
+  
+end

data/test/client/tc_list_metadata_formats.rb

@@ -0,0 +1,18 @@
+require 'test_helper'
+
+class ListMetadataFormatsTest < Test::Unit::TestCase
+  def test_list
+    client = OAI::Client.new 'http://localhost:3333/oai' 
+    response = client.list_metadata_formats
+    assert_kind_of OAI::ListMetadataFormatsResponse, response
+    assert response.entries.size > 0
+
+    format = response.entries[0]
+    assert_kind_of OAI::MetadataFormat, format
+    assert_equal 'oai_dc', format.prefix
+    assert_equal 'http://www.openarchives.org/OAI/2.0/oai_dc.xsd', format.schema
+    assert_equal 'http://www.openarchives.org/OAI/2.0/oai_dc/', format.namespace
+  end
+  
+end
+

data/test/client/tc_list_records.rb

@@ -0,0 +1,13 @@
+require 'test_helper'
+
+class GetRecordsTest < Test::Unit::TestCase
+
+  def test_get_records
+    client = OAI::Client.new 'http://localhost:3333/oai'
+    response = client.list_records 
+    assert_kind_of OAI::ListRecordsResponse, response
+    assert response.entries.size > 0
+    assert_kind_of OAI::Record,  response.entries[0]
+  end
+  
+end

data/test/client/tc_list_sets.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+
+class ListSetsTest < Test::Unit::TestCase
+
+  def test_list
+    client = OAI::Client.new 'http://localhost:3333/oai'
+    response = client.list_sets
+    assert_kind_of OAI::ListSetsResponse, response
+    assert response.entries.size > 0
+    assert_kind_of OAI::Set,  response.entries[0]
+  
+    # test iterator
+    for set in response
+      assert_kind_of OAI::Set, set
+    end
+  end
+  
+end
+

data/test/client/tc_low_resolution_dates.rb

@@ -0,0 +1,14 @@
+require 'test_helper'
+
+class LowResolutionDatesTest < Test::Unit::TestCase
+
+  def test_low_res_date_parsing
+    client = OAI::Client.new 'http://caltechcstr.library.caltech.edu/perl/oai2' 
+
+    date = Date.new 2003, 1, 1
+    
+    # get a list of identifier headers
+    assert_nothing_raised { client.list_identifiers :from => date } 
+  end
+  
+end

data/test/client/tc_utf8_escaping.rb

@@ -0,0 +1,11 @@
+require 'test_helper'
+
+class UTF8Test < Test::Unit::TestCase
+  
+  def test_escaping_invalid_utf_8_characters
+    client = OAI::Client.new 'http://localhost:3333/oai' #, :parser => 'libxml'
+    invalid_utf_8 = [2, 3, 4, 104, 5, 101, 6, 108, 66897, 108, 66535, 111, 1114112, 33, 55234123, 33].pack("U*")
+    assert_equal("hello!!", client.send(:strip_invalid_utf_8_chars, invalid_utf_8).gsub(/\?/, ''))
+  end
+
+end

data/test/client/tc_xpath.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+
+class XpathTest < Test::Unit::TestCase
+  include OAI::XPath
+
+  def test_rexml
+    require 'rexml/document'
+    doc = REXML::Document.new(File.new('test/test.xml'))
+    assert_equal xpath(doc, './/responseDate'), '2006-09-11T14:33:15Z'
+    assert_equal xpath(doc, './/foobar'), nil
+  end
+
+  def test_libxml
+    begin 
+      require 'xml/libxml'
+    rescue LoadError
+      # libxml not available so nothing to test!
+      return
+    end
+
+    doc = LibXML::XML::Document.file('test/test.xml')
+    assert_equal xpath(doc, './/responseDate'), '2006-09-11T14:33:15Z'
+    assert_equal xpath(doc, './/foobar'), nil
+  end
+
+end

data/test/client/test_helper.rb

@@ -0,0 +1,5 @@
+require 'oai'
+require 'test/unit'
+
+require File.dirname(__FILE__) + '/helpers/provider'
+require File.dirname(__FILE__) + '/helpers/test_wrapper'

data/test/provider/models.rb

@@ -0,0 +1,234 @@
+class Record
+  attr_accessor :id, :titles, :creator, :tags, :sets, :updated_at, :deleted
+  
+  def initialize(id, 
+      titles = 'title', 
+      creator = 'creator', 
+      tags = 'tag', 
+      sets = nil, 
+      deleted = false,
+      updated_at = Time.now.utc.xmlschema)
+      
+    @id = id
+    @titles = titles
+    @creator = creator
+    @tags = tags
+    @sets = sets
+    @deleted = deleted
+    @updated_at = updated_at
+  end
+  
+  # Override Object.id
+  def id
+    @id
+  end
+  
+  def in_set(spec)
+    if @sets.respond_to?(:each)
+      @sets.each { |set| return true if set.spec == spec }
+    else
+      return true if @sets.spec == spec
+    end
+    false
+  end
+end
+
+class TestModel < OAI::Provider::Model
+  include OAI::Provider
+  
+  def initialize(limit = nil)
+    super(limit)
+    @records = []
+    @sets = []
+    @earliest = Time.now.utc.xmlschema
+  end
+  
+  def earliest
+    (@records.min {|a,b| a.updated_at <=> b.updated_at }).updated_at.utc.xmlschema
+  end
+  
+  def latest
+    @records.max {|a,b| a.updated_at <=> b.updated_at }.updated_at.utc.xmlschema
+  end
+
+  def sets
+    @sets
+  end
+  
+  def find(selector, opts={})
+    return nil unless selector
+
+    case selector
+    when :all
+      if opts[:resumption_token]
+        raise OAI::ResumptionTokenException.new unless @limit
+        begin
+          token = ResumptionToken.parse(opts[:resumption_token])
+
+          if token.last < @groups.size - 1
+            PartialResult.new(@groups[token.last], token.next(token.last + 1))
+          else
+            @groups[token.last]
+          end
+        rescue
+          raise OAI::ResumptionTokenException.new
+        end
+      else
+        records = @records.select do |rec|
+             ((opts[:set].nil? || rec.in_set(opts[:set])) &&
+	      (opts[:from].nil? || rec.updated_at >= opts[:from]) &&
+	      (opts[:until].nil? || rec.updated_at <= opts[:until]))
+           #else
+           #  ((opts[:set].nil? || rec.in_set(opts[:set])) && 
+           #   (opts[:from].nil? || rec.updated_at >= opts[:from]) &&
+           #   (opts[:until].nil? || rec.updated_at <= opts[:until]))
+           #end
+        end
+
+        if @limit && records.size > @limit
+          @groups = generate_chunks(records, @limit)
+          return PartialResult.new(@groups[0], 
+            ResumptionToken.new(opts.merge({:last => 1})))
+        end
+        return records
+      end
+    else
+      begin
+        @records.each do |record|
+          return record if record.id.to_s == selector
+        end
+      rescue
+      end
+      nil
+    end
+  end
+  
+  def generate_chunks(records, limit)
+    groups = []
+    records.each_slice(limit) do |group|
+      groups << group
+    end
+    groups
+  end
+      
+  def generate_records(number, timestamp = Time.now.utc.xmlschema, sets = [], deleted = false)
+    @earliest = timestamp.dup if @earliest.nil? || timestamp.to_s < @earliest
+    
+    # Add any sets we don't already have
+    sets = [sets] unless sets.respond_to?(:each)
+    sets.each do |set|
+      @sets << set unless @sets.include?(set)
+    end 
+    
+    # Generate some records
+    number.times do |id|
+      rec = Record.new(@records.size, "title_#{id}", "creator_#{id}", "tag_#{id}")
+      rec.updated_at = timestamp.utc
+      rec.sets = sets
+      rec.deleted = deleted
+      @records << rec
+    end
+  end
+    
+end
+
+class SimpleModel < TestModel
+  
+  def initialize
+    super
+    # Create a couple of sets
+    set_one = OAI::Set.new()
+    set_one.name = "Test Set One"
+    set_one.spec = "A"
+    set_one.description = "This is test set one."
+
+    set_two = OAI::Set.new()
+    set_two.name = "Test Set Two"
+    set_two.spec = "A:B"
+    set_two.description = "This is test set two."
+
+    generate_records(5, Time.parse("2002-10-5"), set_one)
+    generate_records(1, Time.parse("2002-11-5"), [set_two], true)
+    generate_records(4, Time.parse("2002-11-5"), [set_two])
+  end
+
+end
+
+class BigModel < TestModel
+  
+  def initialize(limit = nil)
+    super(limit)
+    generate_records(100, Time.parse("October 2 2000"))
+    generate_records(100, Time.parse("November 2 2000"))
+    generate_records(100, Time.parse("December 2 2000"))
+    generate_records(100, Time.parse("January 2 2001"))
+    generate_records(100, Time.parse("February 2 2001"))
+  end
+  
+end
+
+class MappedModel < TestModel
+
+  def initialize
+    super
+    set_one = OAI::Set.new()
+    set_one.name = "Test Set One"
+    set_one.spec = "A"
+    set_one.description = "This is test set one."
+
+    generate_records(5, Time.parse("dec 1 2006"), set_one)
+  end
+  
+  def map_oai_dc
+    {:title => :creator, :creator => :titles, :subject => :tags}
+  end
+
+end
+
+class ComplexModel < TestModel
+  
+  def initialize(limit = nil)
+    super(limit)
+    # Create a couple of sets
+    set_one = OAI::Set.new
+    set_one.name = "Set One"
+    set_one.spec = "One"
+    set_one.description = "This is test set one."
+
+    set_two = OAI::Set.new
+    set_two.name = "Set Two"
+    set_two.spec = "Two"
+    set_two.description = "This is test set two."
+
+    set_three = OAI::Set.new
+    set_three.name = "Set Three"
+    set_three.spec = "Three"
+    set_three.description = "This is test set three."
+
+    set_four = OAI::Set.new
+    set_four.name = "Set Four"
+    set_four.spec = "Four"
+    set_four.description = "This is test set four."
+
+    set_one_two = OAI::Set.new
+    set_one_two.name = "Set One and Two"
+    set_one_two.spec = "One:Two"
+    set_one_two.description = "This is combination set of One and Two."
+
+    set_three_four = OAI::Set.new
+    set_three_four.name = "Set Three and Four"
+    set_three_four.spec = "Three:Four"
+    set_three_four.description = "This is combination set of Three and Four."
+
+    generate_records(250, Time.parse("May 2 1998"), [set_one, set_one_two])
+    generate_records(50, Time.parse("June 2 1998"), [set_one, set_one_two], true)
+    generate_records(50, Time.parse("October 10 1998"), [set_three, set_three_four], true)
+    generate_records(250, Time.parse("July 2 2002"), [set_two, set_one_two])
+    
+    generate_records(250, Time.parse("September 15 2004"), [set_three, set_three_four])
+    generate_records(50, Time.parse("October 10 2004"), [set_three, set_three_four], true)
+    generate_records(250, Time.parse("December 25 2005"), [set_four, set_three_four])
+  end
+  
+end
+

data/test/provider/tc_exceptions.rb

@@ -0,0 +1,96 @@
+require 'test_helper'
+
+class ProviderExceptions < Test::Unit::TestCase
+  include Singleton
+  
+  def setup
+    @provider = ComplexProvider.new
+  end
+
+  def test_resumption_token_exception
+    assert_raise(OAI::ResumptionTokenException) do
+      @provider.list_records(:resumption_token => 'aaadddd:1000')
+    end
+    assert_raise(OAI::ResumptionTokenException) do
+      @provider.list_records(:resumption_token => 'oai_dc:1000')
+    end
+    assert_raise(OAI::ResumptionTokenException) do
+      @provider.list_identifiers(:resumption_token => '..::!:.:!:')
+    end
+    assert_raise(OAI::ResumptionTokenException) do
+      @provider.list_identifiers(:resumption_token => '\:\\:\/$%^&*!@#!:1')
+    end
+  end
+  
+  def test_bad_verb_raises_exception
+    assert @provider.process_request(:verb => 'BadVerb') =~ /badVerb/
+    assert @provider.process_request(:verb => '\a$#^%!@') =~ /badVerb/
+    assert @provider.process_request(:verb => 'identity') =~ /badVerb/
+    assert @provider.process_request(:verb => '!!\\$\$\.+') =~ /badVerb/
+  end
+  
+  def test_bad_format_raises_exception
+    assert_raise(OAI::FormatException) do
+      @provider.get_record(:identifier => 'oai:test/1', :metadataPrefix => 'html')
+    end
+    assert_raise(OAI::FormatException) do
+      @provider.list_identifiers(:metadataPrefix => 'fjdsklfj')
+  end
+  end
+  
+  def test_bad_id_raises_exception
+    assert_raise(OAI::IdException) do
+      @provider.get_record(:identifier => 'oai:test/5000', :metadataPrefix => 'oai_dc')
+    end
+    assert_raise(OAI::IdException) do
+      @provider.get_record(:identifier => 'oai:test/-1', :metadataPrefix => 'oai_dc')
+    end
+    assert_raise(OAI::IdException) do
+      @provider.get_record(:identifier => 'oai:test/one', :metadataPrefix => 'oai_dc')
+    end
+    assert_raise(OAI::IdException) do
+      @provider.get_record(:identifier => 'oai:test/\\$1\1!', :metadataPrefix => 'oai_dc')
+    end
+  end
+  
+  def test_no_records_match_dates_that_are_out_of_range
+    assert_raise(OAI::NoMatchException) do
+      @provider.list_records(:from => Time.parse("November 2 2000"), 
+                             :until => Time.parse("November 1 2000"),
+							 :metadataPrefix => 'oai_dc')
+    end
+  end
+  
+  def test_bad_datespecs_raise_exception
+    assert_raise(OAI::ArgumentException) do
+      @provider.list_records( :from => "iamnotadate",
+                              :until => "2005-06-05T12:20:40Z",
+                              :metadataPrefix => 'oai_dc' )
+    end
+    assert_raise(OAI::ArgumentException) do
+      @provider.list_records( :from => "2005-06-05T12:20:40Z",
+                              :until => "iamnotadate",
+                              :metadataPrefix => 'oai_dc' )
+    end    
+  end
+  
+  def test_extra_parameter_for_identify_raises_correct_exception
+    assert_raise(OAI::ArgumentException) do
+      @provider.identify( :metadataPrefix => 'oai_dc' )
+    end
+  end
+  
+  def test_different_granularities_raises_exception
+    assert_raise(OAI::ArgumentException) do
+      @provider.list_records( :from => "2000-01-01", 
+                              :until => "2007-06-05T12:00:00Z",
+                              :metadataPrefix => 'oai_dc'
+                              )
+    end
+  end
+  
+  def test_no_records_match_bad_set
+    assert_raise(OAI::NoMatchException) { @provider.list_records(:set => 'unknown', :metadataPrefix => 'oai_dc') }
+  end
+  
+end

data/test/provider/tc_functional_tokens.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+class ResumptionTokenFunctionalTest < Test::Unit::TestCase
+  include REXML
+  
+  def setup
+    @provider = ComplexProvider.new
+  end
+
+  def test_resumption_tokens
+    assert_nothing_raised { Document.new(@provider.list_records(:metadataPrefix => 'oai_dc')) }
+    doc = Document.new(@provider.list_records(:metadataPrefix => 'oai_dc'))
+    assert_not_nil doc.elements["/OAI-PMH/ListRecords/resumptionToken"]
+    assert_equal 101, doc.elements["/OAI-PMH/ListRecords"].to_a.size
+    token = doc.elements["/OAI-PMH/ListRecords/resumptionToken"].text
+    doc = Document.new(@provider.list_records(:resumption_token => token))
+    assert_not_nil doc.elements["/OAI-PMH/ListRecords/resumptionToken"]
+    assert_equal 101, doc.elements["/OAI-PMH/ListRecords"].to_a.size
+  end
+
+  def test_from_and_until_with_resumption_tokens
+    # Should return 300 records broken into 3 groups of 100.
+    assert_nothing_raised { Document.new(@provider.list_records(:metadataPrefix => 'oai_dc')) }
+    doc = Document.new(
+      @provider.list_records(
+        :from => Time.parse("September 1 2004"),
+        :until => Time.parse("November 30 2004"),
+		    :metadataPrefix => 'oai_dc')
+      )
+    assert_equal 101, doc.elements["/OAI-PMH/ListRecords"].to_a.size
+    token = doc.elements["/OAI-PMH/ListRecords/resumptionToken"].text
+  
+    doc = Document.new(@provider.list_records(:resumption_token => token))
+    assert_not_nil doc.elements["/OAI-PMH/ListRecords/resumptionToken"]
+    assert_equal 101, doc.elements["/OAI-PMH/ListRecords"].to_a.size
+    token = doc.elements["/OAI-PMH/ListRecords/resumptionToken"].text
+
+    doc = Document.new(@provider.list_records(:resumption_token => token))
+    assert_nil doc.elements["/OAI-PMH/ListRecords/resumptionToken"]
+    assert_equal 100, doc.elements["/OAI-PMH/ListRecords"].to_a.size
+  end
+    
+end

data/test/provider/tc_provider.rb

@@ -0,0 +1,71 @@
+require 'test_helper'
+
+class OaiTest < Test::Unit::TestCase
+
+  def setup
+    @mapped_provider = MappedProvider.new
+    @big_provider = BigProvider.new
+  end
+  
+  def test_list_identifiers_for_correct_xml
+    doc = REXML::Document.new(@mapped_provider.list_identifiers(:metadataPrefix => 'oai_dc'))
+    assert_not_nil doc.elements['OAI-PMH/ListIdentifiers']
+    assert_not_nil doc.elements['OAI-PMH/ListIdentifiers/header']
+    assert_not_nil doc.elements['OAI-PMH/ListIdentifiers/header/identifier']
+    assert_not_nil doc.elements['OAI-PMH/ListIdentifiers/header/datestamp']
+    assert_not_nil doc.elements['OAI-PMH/ListIdentifiers/header/setSpec']
+  end
+  
+  def test_list_records_for_correct_xml
+    doc = REXML::Document.new(@mapped_provider.list_records(:metadataPrefix => 'oai_dc'))
+    assert_not_nil doc.elements['OAI-PMH/ListRecords/record/header']
+    assert_not_nil doc.elements['OAI-PMH/ListRecords/record/metadata']
+  end
+  
+  def test_mapped_source
+    assert_nothing_raised { REXML::Document.new(@mapped_provider.list_records(:metadataPrefix => 'oai_dc')) }
+    doc = REXML::Document.new(@mapped_provider.list_records(:metadataPrefix => 'oai_dc'))
+    assert_equal "title_0", doc.elements['OAI-PMH/ListRecords/record/metadata/oai_dc:dc/dc:creator'].text
+    assert_equal "creator_0", doc.elements['OAI-PMH/ListRecords/record/metadata/oai_dc:dc/dc:title'].text
+    assert_equal "tag_0", doc.elements['OAI-PMH/ListRecords/record/metadata/oai_dc:dc/dc:subject'].text
+  end
+  
+  def test_from
+    assert_nothing_raised { REXML::Document.new(@big_provider.list_records(:metadataPrefix => 'oai_dc')) }
+    doc = REXML::Document.new(
+      @big_provider.list_records(:from => Time.parse("February 1 2001"), :metadataPrefix => 'oai_dc')
+      )
+    assert_equal 100, doc.elements['OAI-PMH/ListRecords'].to_a.size
+
+    doc = REXML::Document.new(
+      @big_provider.list_records(:from => Time.parse("January 1 2001"), :metadataPrefix => 'oai_dc')
+      )
+    assert_equal 200, doc.elements['OAI-PMH/ListRecords'].to_a.size
+  end
+  
+  def test_until
+    assert_nothing_raised { REXML::Document.new(@big_provider.list_records(:metadataPrefix => 'oai_dc')) }
+    doc = REXML::Document.new(
+      @big_provider.list_records(:until => Time.parse("November 1 2000"), :metadataPrefix => 'oai_dc')
+      )
+    assert_equal 100, doc.elements['OAI-PMH/ListRecords'].to_a.size
+  end
+  
+  def test_from_and_until
+    assert_nothing_raised { REXML::Document.new(@big_provider.list_records(:metadataPrefix => 'oai_dc')) }
+    doc = REXML::Document.new(
+      @big_provider.list_records(:from => Time.parse("November 1 2000"),
+        :until => Time.parse("November 30 2000"),
+        :metadataPrefix => 'oai_dc')
+      )
+    assert_equal 100, doc.elements['OAI-PMH/ListRecords'].to_a.size
+
+    doc = REXML::Document.new(
+      @big_provider.list_records(:from => Time.parse("December 1 2000"),
+      :until => Time.parse("December 31 2000"),
+      :metadataPrefix => 'oai_dc')
+      )
+    assert_equal 100, doc.elements['OAI-PMH/ListRecords'].to_a.size
+  end
+        
+end

data/test/provider/tc_resumption_tokens.rb

@@ -0,0 +1,46 @@
+require 'test_helper'
+
+class ResumptionTokenTest < Test::Unit::TestCase
+  include REXML
+  include OAI::Provider
+  
+  def setup
+    @token = ResumptionToken.new(
+      :from => Time.utc(2005,"jan",1,17,0,0),
+      :until => Time.utc(2005,"jan",31,17,0,0),
+      :set => "A",
+      :metadata_prefix => "oai_dc", 
+      :last => 1
+    )
+  end
+
+  def test_resumption_token_options_encoding
+    assert_equal "oai_dc.s(A).f(2005-01-01T17:00:00Z).u(2005-01-31T17:00:00Z)",
+      @token.to_s
+  end
+  
+  def test_resumption_token_next_method
+    assert_equal 100, @token.next(100).last
+  end
+  
+  def test_resumption_token_to_condition_hash
+    hash = @token.to_conditions_hash
+    assert_equal @token.from, hash[:from]
+    assert_equal @token.until, hash[:until]
+    assert_equal @token.set, hash[:set]
+    assert_equal @token.prefix, hash[:metadata_prefix]
+  end
+
+  def test_resumption_token_parsing
+    new_token = ResumptionToken.parse(
+      "oai_dc.s(A).f(2005-01-01T17:00:00Z).u(2005-01-31T17:00:00Z):1"
+    )
+    assert_equal @token, new_token
+  end
+  
+  def test_resumption_token_to_xml
+    doc = REXML::Document.new(@token.to_xml)
+    assert_equal "#{@token.to_s}:#{@token.last}", doc.elements['/resumptionToken'].text
+  end
+    
+end