oai 0.0.1 → 1.3.0

data/test/harvester/tc_harvest.rb

@@ -0,0 +1,42 @@
+require 'test_helper_harvester'
+
+class HarvestTest < Test::Unit::TestCase
+  ONE_HOUR = 3600
+  EARLIEST_FIXTURE = "1998-05-02T04:00:00Z"
+  LATEST_FIXTURE = "2005-12-25T05:00:00Z"
+  def test_harvest
+    until_value = Time.now.utc - ONE_HOUR
+    config = OpenStruct.new(sites: { 'test' => { 'url' => 'http://localhost:3333/oai' }})
+    OAI::Harvester::Harvest.new(config).start
+    last = config.sites.dig('test', 'last')
+    assert_kind_of Time, last
+    assert last >= (until_value + ONE_HOUR), "#{last} < #{(until_value + ONE_HOUR)}"
+  end
+
+  def test_harvest_from_last
+    from_value = Time.parse(LATEST_FIXTURE).utc
+    now = Time.now.utc
+    config = OpenStruct.new(sites: { 'test' => { 'url' => 'http://localhost:3333/oai' }})
+    OAI::Harvester::Harvest.new(config, nil, from_value).start
+    last = config.sites.dig('test', 'last')
+    assert last >= now, "#{last} < #{now}"
+  end
+
+  def test_harvest_after_last
+    from_value = Time.parse(LATEST_FIXTURE).utc + 1
+    config = OpenStruct.new(sites: { 'test' => { 'url' => 'http://localhost:3333/oai' }})
+    OAI::Harvester::Harvest.new(config, nil, from_value).start
+    last = config.sites.dig('test', 'last')
+    assert_kind_of NilClass, last
+  end
+
+  def test_harvest_with_until
+    until_value = Time.parse(EARLIEST_FIXTURE).utc + ONE_HOUR
+    config = OpenStruct.new(sites: { 'test' => { 'url' => 'http://localhost:3333/oai' }})
+    OAI::Harvester::Harvest.new(config, nil, nil, until_value).start
+    last = config.sites.dig('test', 'last')
+    assert_kind_of Time, last
+    assert_equal last, until_value
+  end
+end
+

data/test/harvester/test_helper_harvester.rb

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

data/test/provider/models.rb

@@ -0,0 +1,246 @@
+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
+            PartialResult.new(@groups[token.last], token.next(nil))
+          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].to_time) &&
+	      (opts[:until].nil? || rec.updated_at <= opts[:until].to_time))
+           #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.to_s
+    @earliest = timestamp.dup if @earliest.nil?
+
+    # 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
+
+  def about record
+    xml = <<-eos
+    <oai_dc:dc
+          xmlns:oai_dc="http://www.openarchives.org/OAI/2.0/oai_dc/"
+          xmlns:dc="http://purl.org/dc/elements/1.1/">
+          <dc:publisher>Ruby OAI test data</dc:publisher>
+    </oai_dc:dc>
+    eos
+    # Removes new-lines and formatting, which is a problem with Ruby 1.8.x
+    xml.gsub(/\s+/, ' ')
+  end
+end
+

data/test/provider/tc_exceptions.rb

@@ -0,0 +1,81 @@
+require 'test_helper_provider'
+
+class ProviderExceptions < Test::Unit::TestCase
+
+  def setup
+    @provider = ComplexProvider.new
+  end
+
+  def test_argument_exception
+    assert_raise(OAI::ArgumentException) do
+      @provider.identify(:identifier => 'invalid_arg')
+    end
+  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', :metadata_prefix => 'html')
+    end
+  end
+
+  def test_missing_format_raises_exception
+    assert_raise(OAI::ArgumentException) do
+      @provider.list_records()
+    end
+    assert_raise(OAI::ArgumentException) do
+      @provider.get_record(:identifier => 'oai:test:1')
+    end
+  end
+
+  def test_bad_id_raises_exception
+    badIdentifiers = [
+      'oai:test:5000',
+      'oai:test:-1',
+      'oai:test:one',
+      'oai:test/one',
+      'oai:test/1',
+      'oai:test:\\$1\1!']
+    badIdentifiers.each do |id|
+      assert_raise(OAI::IdException) do
+        @provider.get_record(:identifier => id, :metadata_prefix => 'oai_dc')
+      end
+    end
+  end
+
+  def test_no_records_match_dates_that_are_out_of_range
+    assert_raise(OAI::NoMatchException) do
+      @provider.list_records(:metadata_prefix => 'oai_dc',
+                             :from => Time.parse("November 2 2000"),
+                             :until => Time.parse("November 1 2000"))
+    end
+  end
+
+  def test_no_records_match_bad_set
+    assert_raise(OAI::NoMatchException) do
+      @provider.list_records(:metadata_prefix => 'oai_dc', :set => 'unknown')
+    end
+  end
+
+end

data/test/provider/tc_functional_tokens.rb

@@ -0,0 +1,53 @@
+require 'test_helper_provider'
+
+class ResumptionTokenFunctionalTest < Test::Unit::TestCase
+  include REXML
+
+  def setup
+    @provider = ComplexProvider.new
+  end
+
+  def test_resumption_tokens
+    assert_nothing_raised do
+      Document.new(@provider.list_records(:metadata_prefix => 'oai_dc'))
+    end
+    doc = Document.new(@provider.list_records(:metadata_prefix => 'oai_dc'))
+    assert_not_nil doc.elements["/OAI-PMH/ListRecords/resumptionToken"]
+    assert_equal (@provider.model.limit + 1), 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 (@provider.model.limit + 1), doc.elements["/OAI-PMH/ListRecords"].to_a.size
+  end
+
+  def test_from_and_until_with_resumption_tokens
+    # Should return 550 records broken into 5 groups of 100, and a final group of 50.
+    # checked elements under ListRecords are limit + 1, accounting for the resumptionToken element
+    assert_nothing_raised do
+      Document.new(@provider.list_records(:metadata_prefix => 'oai_dc'))
+    end
+    doc = Document.new(
+      @provider.list_records(
+        :metadata_prefix => 'oai_dc',
+        :from => Time.parse("September 1 2004"),
+        :until => Time.parse("December 25 2005"))
+      )
+    assert_equal (@provider.model.limit + 1), doc.elements["/OAI-PMH/ListRecords"].to_a.size
+    assert_not_nil doc.elements["/OAI-PMH/ListRecords/resumptionToken"]
+    token = doc.elements["/OAI-PMH/ListRecords/resumptionToken"].text
+
+    4.times do
+      doc = Document.new(@provider.list_records(:resumption_token => token))
+      assert_not_nil doc.elements["/OAI-PMH/ListRecords/resumptionToken"]
+      assert_equal (@provider.model.limit + 1), doc.elements["/OAI-PMH/ListRecords"].to_a.size
+      token = doc.elements["/OAI-PMH/ListRecords/resumptionToken"].text
+    end
+
+    doc = Document.new(@provider.list_records(:resumption_token => token))
+    # assert that ListRecords includes remaining records and an empty resumption token
+    assert_equal (551 % @provider.model.limit), doc.elements["/OAI-PMH/ListRecords"].to_a.size
+    assert_not_nil doc.elements["/OAI-PMH/ListRecords/resumptionToken"]
+    assert_nil doc.elements["/OAI-PMH/ListRecords/resumptionToken"].text
+  end
+
+end

data/test/provider/tc_instance_provider.rb

@@ -0,0 +1,41 @@
+require 'test_helper_provider'
+
+class TestInstanceProvider < Test::Unit::TestCase
+
+  # Prior to the commit introducing this code, the InstanceProvider#identify
+  # method would instantiate a Response::Identify object, passing the
+  # InstanceProvider class as the provider for the Response::Identify
+  # instance. With the commit introducing this test, the
+  # InstanceProvider#identify now passes the instance of InstanceProvider
+  # to the instantiation of Response::Identify.
+  #
+  # Thus we can override, on an instance by instance basis, the behavior of a
+  # response object.
+  def test_instance_used_in_responses
+    @url_path = "/stringy-mc-string-face"
+    @instance_provider = InstanceProvider.new({ :provider_context => :instance_based, :url_path => @url_path })
+
+    xml = @instance_provider.identify
+    doc =  REXML::Document.new(xml)
+    assert_equal "http://localhost#{@url_path}", doc.elements["OAI-PMH/Identify/baseURL"].text
+  end
+
+  def test_class_used_in_responses
+    @url_path = "/stringy-mc-string-face"
+    @instance_provider = InstanceProvider.new({ :provider_context => :class_based, :url_path => @url_path })
+
+    xml = @instance_provider.identify
+    doc =  REXML::Document.new(xml)
+    assert_equal "http://localhost", doc.elements["OAI-PMH/Identify/baseURL"].text
+  end
+
+  def test_by_default_class_used_in_responses
+    @url_path = "/stringy-mc-string-face"
+    @instance_provider = InstanceProvider.new({ :url_path => @url_path })
+
+    xml = @instance_provider.identify
+    doc =  REXML::Document.new(xml)
+    assert_equal "http://localhost", doc.elements["OAI-PMH/Identify/baseURL"].text
+  end
+
+end

data/test/provider/tc_provider.rb

@@ -0,0 +1,136 @@
+require 'test_helper_provider'
+
+class OaiTest < Test::Unit::TestCase
+
+  def setup
+    @mapped_provider = MappedProvider.new
+    @big_provider = BigProvider.new
+    @described_provider = DescribedProvider.new
+  end
+
+  def test_additional_description
+    doc = REXML::Document.new(@described_provider.identify)
+    assert_equal "oai:test:13900", doc.elements['OAI-PMH/Identify/description/oai-identifier/sampleIdentifier'].text
+    assert_not_nil doc.elements['OAI-PMH/Identify/my_custom_xml']
+  end
+
+  def test_list_identifiers_for_correct_xml
+    doc = REXML::Document.new(@mapped_provider.list_identifiers)
+    assert_not_nil doc.elements['OAI-PMH/request']
+    assert_not_nil doc.elements['OAI-PMH/request/@verb']
+    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(:metadata_prefix => 'oai_dc'))
+    assert_not_nil doc.elements['OAI-PMH/request']
+    assert_not_nil doc.elements['OAI-PMH/request/@verb']
+    assert_not_nil doc.elements['OAI-PMH/request/@metadata_prefix']
+    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 do
+      REXML::Document.new(
+        @mapped_provider.list_records(:metadata_prefix => 'oai_dc'))
+    end
+    doc = REXML::Document.new(
+      @mapped_provider.list_records(:metadata_prefix => '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 do
+      REXML::Document.new(
+        @big_provider.list_records(:metadata_prefix => 'oai_dc'))
+    end
+    doc = REXML::Document.new(
+      @big_provider.list_records(
+        :metadata_prefix => 'oai_dc',
+        :from => Time.parse("February 1 2001"))
+    )
+    assert_equal 100, doc.elements['OAI-PMH/ListRecords'].to_a.size
+
+    doc = REXML::Document.new(
+      @big_provider.list_records(
+        :metadata_prefix => 'oai_dc',
+        :from => Time.parse("January 1 2001"))
+    )
+    assert_equal 200, doc.elements['OAI-PMH/ListRecords'].to_a.size
+  end
+
+  def test_until
+    assert_nothing_raised do
+      REXML::Document.new(
+        @big_provider.list_records(:metadata_prefix => 'oai_dc'))
+    end
+    doc = REXML::Document.new(
+      @big_provider.list_records(
+        :metadata_prefix => 'oai_dc', :until => Time.parse("November 1 2000"))
+    )
+    assert_equal 100, doc.elements['OAI-PMH/ListRecords'].to_a.size
+  end
+  
+  def test_from_and_until_match
+    assert_nothing_raised do
+      @big_provider.list_records(
+        :metadata_prefix => 'oai_dc',
+        :from => "2000-11-01T05:00:00Z",
+        :until =>  "2000-11-30T05:00:00Z"
+      )
+    end
+    
+    assert_nothing_raised do
+      @big_provider.list_records(
+        :metadata_prefix => 'oai_dc',
+        :from => "2000-11-01",
+        :until =>  "2000-11-30"
+      )
+    end
+    
+    assert_raise(OAI::ArgumentException) do
+      @big_provider.list_records(
+        :metadata_prefix => 'oai_dc',
+        :from => "2000-11-01T05:00:00Z",
+        :until =>  "2000-11-30"
+      )
+    end
+  end
+
+  def test_from_and_until
+    assert_nothing_raised do
+      REXML::Document.new(
+        @big_provider.list_records(:metadata_prefix => 'oai_dc'))
+    end
+    doc = REXML::Document.new(
+      @big_provider.list_records(
+        :metadata_prefix => 'oai_dc',
+        :from => Time.parse("November 1 2000"),
+        :until => Time.parse("November 30 2000"))
+    )
+
+    assert_not_nil doc.elements['OAI-PMH/request']
+    assert_not_nil doc.elements['OAI-PMH/request/@verb']
+    assert_not_nil doc.elements['OAI-PMH/request/@from']
+    assert_not_nil doc.elements['OAI-PMH/request/@until']
+
+    assert_equal 100, doc.elements['OAI-PMH/ListRecords'].to_a.size
+
+    doc = REXML::Document.new(
+      @big_provider.list_records(
+        :metadata_prefix => 'oai_dc',
+        :from => Time.parse("December 1 2000"),
+        :until => Time.parse("December 31 2000"))
+    )
+    assert_equal 100, doc.elements['OAI-PMH/ListRecords'].to_a.size
+  end
+
+end

data/test/provider/tc_resumption_tokens.rb

@@ -0,0 +1,52 @@
+require 'test_helper_provider'
+
+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
+
+  def test_resumption_token_id_does_not_need_to_be_numeric
+    serialized = "oai_dc.s(A).f(2005-01-01T17:00:00Z).u(2005-01-31T17:00:00Z):FA129C"
+
+    token = ResumptionToken.parse(serialized)
+    assert_equal serialized, token.send(:encode_conditions)
+  end
+end