linkage 0.1.0.pre → 0.1.0

data/test/unit/match_sets/test_csv.rb

@@ -2,50 +2,79 @@ require File.expand_path("../../test_match_sets", __FILE__)
 
 class UnitTests::TestMatchSets::TestCSV < Test::Unit::TestCase
   test "open_for_writing" do
-    match_set = Linkage::MatchSets::CSV.new('foo.csv')
+    match_set = Linkage::MatchSets::CSV.new(:filename => 'foo.csv')
+    expected_filename = File.expand_path('foo.csv')
+    File.expects(:exist?).with(expected_filename).returns(false)
     csv = stub('csv')
-    CSV.expects(:open).with('foo.csv', 'wb').returns(csv)
+    CSV.expects(:open).with(expected_filename, 'wb').returns(csv)
+    csv.expects(:<<).with(%w{id_1 id_2 score})
+    match_set.open_for_writing
+  end
+
+  test "open_for_writing with default options" do
+    match_set = Linkage::MatchSets::CSV.new
+    expected_filename = File.expand_path('matches.csv')
+    File.expects(:exist?).with(expected_filename).returns(false)
+    csv = stub('csv')
+    CSV.expects(:open).with(expected_filename, 'wb').returns(csv)
+    csv.expects(:<<).with(%w{id_1 id_2 score})
+    match_set.open_for_writing
+  end
+
+  test "open_for_writing with directory option" do
+    match_set = Linkage::MatchSets::CSV.new(:dir => 'foo')
+
+    expected_dir = File.expand_path('foo')
+    FileUtils.expects(:mkdir_p).with(expected_dir)
+    expected_filename = File.join(expected_dir, 'matches.csv')
+    File.expects(:exist?).with(expected_filename).returns(false)
+    csv = stub('csv')
+    CSV.expects(:open).with(expected_filename, 'wb').returns(csv)
     csv.expects(:<<).with(%w{id_1 id_2 score})
     match_set.open_for_writing
   end
 
   test "open_for_writing when already open" do
-    match_set = Linkage::MatchSets::CSV.new('foo.csv')
+    match_set = Linkage::MatchSets::CSV.new(:filename => 'foo.csv')
+    expected_filename = File.expand_path('foo.csv')
+    File.expects(:exist?).once.with(expected_filename).returns(false)
     csv = stub('csv')
-    CSV.expects(:open).once.with('foo.csv', 'wb').returns(csv)
+    CSV.expects(:open).once.with(expected_filename, 'wb').returns(csv)
     csv.expects(:<<).once.with(%w{id_1 id_2 score})
     match_set.open_for_writing
     match_set.open_for_writing
   end
 
   test "open_for_writing when file exists" do
-    match_set = Linkage::MatchSets::CSV.new('foo.csv')
-    File.expects(:exist?).with('foo.csv').returns(true)
+    match_set = Linkage::MatchSets::CSV.new(:filename => 'foo.csv')
+    expected_filename = File.expand_path('foo.csv')
+    File.expects(:exist?).with(expected_filename).returns(true)
     assert_raises(Linkage::ExistsError) do
       match_set.open_for_writing
     end
   end
 
   test "open_for_writing when file exists and forcing overwrite" do
-    match_set = Linkage::MatchSets::CSV.new('foo.csv', :overwrite => true)
-    File.stubs(:exist?).with('foo.csv').returns(true)
+    match_set = Linkage::MatchSets::CSV.new(:filename => 'foo.csv', :overwrite => true)
+    expected_filename = File.expand_path('foo.csv')
+    File.stubs(:exist?).with(expected_filename).returns(true)
     assert_nothing_raised do
       csv = stub('csv')
-      CSV.expects(:open).with('foo.csv', 'wb').returns(csv)
+      CSV.expects(:open).with(expected_filename, 'wb').returns(csv)
       csv.expects(:<<).with(%w{id_1 id_2 score})
       match_set.open_for_writing
     end
   end
 
   test "add_match when unopened raises exception" do
-    match_set = Linkage::MatchSets::CSV.new('foo.csv')
+    match_set = Linkage::MatchSets::CSV.new(:filename => 'foo.csv')
     assert_raises { match_set.add_match(1, 2, 1) }
   end
 
   test "add_match" do
     tempfile = Tempfile.new('linkage')
     tempfile.close
-    match_set = Linkage::MatchSets::CSV.new(tempfile.path, :overwrite => true)
+    match_set = Linkage::MatchSets::CSV.new(:filename => tempfile.path, :overwrite => true)
     match_set.open_for_writing
     match_set.add_match(1, 2, 1)
     match_set.close
@@ -55,9 +84,11 @@ class UnitTests::TestMatchSets::TestCSV < Test::Unit::TestCase
   end
 
   test "add_match removes extra decimals" do
-    match_set = Linkage::MatchSets::CSV.new('foo.csv')
+    match_set = Linkage::MatchSets::CSV.new(:filename => 'foo.csv')
+    expected_filename = File.expand_path('foo.csv')
+    File.expects(:exist?).with(expected_filename).returns(false)
     csv = stub('csv')
-    CSV.stubs(:open).with('foo.csv', 'wb').returns(csv)
+    CSV.stubs(:open).with(expected_filename, 'wb').returns(csv)
     csv.stubs(:<<).with(%w{id_1 id_2 score})
     match_set.open_for_writing
 

data/test/unit/match_sets/test_database.rb

@@ -4,6 +4,47 @@ class UnitTests::TestMatchSets::TestDatabase < Test::Unit::TestCase
   def setup
     @dataset = stub('dataset')
     @database = stub('database', :[] => @dataset)
+    Sequel::Database.stubs(:===).with(@database).returns(true)
+  end
+
+  test "open_for_writing with uri string" do
+    Sequel.expects(:connect).with('foo://bar').returns(@database)
+    match_set = Linkage::MatchSets::Database.new('foo://bar')
+    @database.stubs(:table_exists?).with(:matches).returns(false)
+    @database.expects(:create_table).with(:matches)
+    @database.expects(:[]).with(:matches).returns(@dataset)
+    match_set.open_for_writing
+  end
+
+  test "open_for_writing with filename option" do
+    Sequel.expects(:connect).with(:adapter => :sqlite, :database => 'foo.db').returns(@database)
+    match_set = Linkage::MatchSets::Database.new(:filename => 'foo.db')
+    @database.stubs(:table_exists?).with(:matches).returns(false)
+    @database.expects(:create_table).with(:matches)
+    @database.expects(:[]).with(:matches).returns(@dataset)
+    match_set.open_for_writing
+  end
+
+  test "open_for_writing with default options" do
+    Sequel.expects(:connect).with(:adapter => :sqlite, :database => 'matches.db').returns(@database)
+    match_set = Linkage::MatchSets::Database.new
+    @database.stubs(:table_exists?).with(:matches).returns(false)
+    @database.expects(:create_table).with(:matches)
+    @database.expects(:[]).with(:matches).returns(@dataset)
+    match_set.open_for_writing
+  end
+
+  test "open_for_writing with directory option" do
+    expected_directory = File.expand_path('foo')
+    FileUtils.expects(:mkdir_p).with(expected_directory)
+    expected_filename = File.join(expected_directory, 'matches.db')
+    Sequel.expects(:connect).with(:adapter => :sqlite, :database => expected_filename).returns(@database)
+
+    match_set = Linkage::MatchSets::Database.new(:dir => 'foo')
+    @database.stubs(:table_exists?).with(:matches).returns(false)
+    @database.expects(:create_table).with(:matches)
+    @database.expects(:[]).with(:matches).returns(@dataset)
+    match_set.open_for_writing
   end
 
   test "open_for_writing for database with no matches table" do
@@ -33,7 +74,7 @@ class UnitTests::TestMatchSets::TestDatabase < Test::Unit::TestCase
   end
 
   test "open_for_writing when matches table already exists and in overwrite mode" do
-    match_set = Linkage::MatchSets::Database.new(@database, :overwrite => true)
+    match_set = Linkage::MatchSets::Database.new(@database, {:overwrite => true})
     @database.expects(:drop_table?).with(:matches)
     @database.expects(:create_table).with(:matches)
     @database.expects(:[]).with(:matches).returns(@dataset)

data/test/unit/result_sets/test_csv.rb

@@ -9,99 +9,39 @@ class UnitTests::TestResultSets::TestCSV < Test::Unit::TestCase
     FileUtils.remove_entry_secure(@tmpdir)
   end
 
-  test "no directory option uses current directory" do
+  test "default options" do
     result_set = Linkage::ResultSets::CSV.new
 
-    expected_score_file = './scores.csv'
     score_set = stub('score set')
-    Linkage::ScoreSets::CSV.expects(:new).with(expected_score_file, {}).returns(score_set)
+    Linkage::ScoreSets::CSV.expects(:new).with({}).returns(score_set)
     assert_same score_set, result_set.score_set
 
-    expected_match_file = './matches.csv'
     match_set = stub('match set')
-    Linkage::MatchSets::CSV.expects(:new).with(expected_match_file, {}).returns(match_set)
+    Linkage::MatchSets::CSV.expects(:new).with({}).returns(match_set)
     assert_same match_set, result_set.match_set
   end
 
   test "directory option" do
-    opts = {
-      :dir => File.join(@tmpdir, 'foo')
-    }
-    result_set = Linkage::ResultSets::CSV.new(opts)
-    assert Dir.exist?(opts[:dir])
+    result_set = Linkage::ResultSets::CSV.new(:dir => 'foo')
 
-    expected_score_file = File.join(@tmpdir, 'foo', 'scores.csv')
     score_set = stub('score set')
-    Linkage::ScoreSets::CSV.expects(:new).with(expected_score_file, {}).returns(score_set)
+    Linkage::ScoreSets::CSV.expects(:new).with({:dir => 'foo'}).returns(score_set)
     assert_same score_set, result_set.score_set
 
-    expected_match_file = File.join(@tmpdir, 'foo', 'matches.csv')
     match_set = stub('match set')
-    Linkage::MatchSets::CSV.expects(:new).with(expected_match_file, {}).returns(match_set)
+    Linkage::MatchSets::CSV.expects(:new).with({:dir => 'foo'}).returns(match_set)
     assert_same match_set, result_set.match_set
   end
 
   test "directory argument" do
-    dir = File.join(@tmpdir, 'foo')
-    result_set = Linkage::ResultSets::CSV.new(dir)
-    assert Dir.exist?(dir)
+    result_set = Linkage::ResultSets::CSV.new('foo')
 
-    expected_score_file = File.join(@tmpdir, 'foo', 'scores.csv')
     score_set = stub('score set')
-    Linkage::ScoreSets::CSV.expects(:new).with(expected_score_file, {}).returns(score_set)
+    Linkage::ScoreSets::CSV.expects(:new).with({:dir => 'foo'}).returns(score_set)
     assert_same score_set, result_set.score_set
 
-    expected_match_file = File.join(@tmpdir, 'foo', 'matches.csv')
     match_set = stub('match set')
-    Linkage::MatchSets::CSV.expects(:new).with(expected_match_file, {}).returns(match_set)
-    assert_same match_set, result_set.match_set
-  end
-
-  test "directory path is expanded" do
-    opts = {
-      :dir => "~/foo"
-    }
-    FileUtils.expects(:mkdir_p).with(File.expand_path("~/foo"))
-    result_set = Linkage::ResultSets::CSV.new(opts)
-  end
-
-  test "custom filenames" do
-    opts = {
-      :dir => File.join(@tmpdir, 'foo'),
-      :scores => {:filename => 'foo-scores.csv'},
-      :matches => {:filename => 'foo-matches.csv'}
-    }
-    result_set = Linkage::ResultSets::CSV.new(opts)
-    assert Dir.exist?(opts[:dir])
-
-    expected_score_file = File.join(@tmpdir, 'foo', 'foo-scores.csv')
-    score_set = stub('score set')
-    Linkage::ScoreSets::CSV.expects(:new).with(expected_score_file, {}).returns(score_set)
-    assert_same score_set, result_set.score_set
-
-    expected_match_file = File.join(@tmpdir, 'foo', 'foo-matches.csv')
-    match_set = stub('match set')
-    Linkage::MatchSets::CSV.expects(:new).with(expected_match_file, {}).returns(match_set)
-    assert_same match_set, result_set.match_set
-  end
-
-  test "miscellaneous options" do
-    opts = {
-      :dir => File.join(@tmpdir, 'foo'),
-      :scores => {:foo => 'bar'},
-      :matches => {:baz => 'qux'}
-    }
-    result_set = Linkage::ResultSets::CSV.new(opts)
-    assert Dir.exist?(opts[:dir])
-
-    expected_score_file = File.join(@tmpdir, 'foo', 'scores.csv')
-    score_set = stub('score set')
-    Linkage::ScoreSets::CSV.expects(:new).with(expected_score_file, :foo => 'bar').returns(score_set)
-    assert_same score_set, result_set.score_set
-
-    expected_match_file = File.join(@tmpdir, 'foo', 'matches.csv')
-    match_set = stub('match set')
-    Linkage::MatchSets::CSV.expects(:new).with(expected_match_file, :baz => 'qux').returns(match_set)
+    Linkage::MatchSets::CSV.expects(:new).with({:dir => 'foo'}).returns(match_set)
     assert_same match_set, result_set.match_set
   end
 

data/test/unit/result_sets/test_database.rb

@@ -1,10 +1,24 @@
 require File.expand_path("../../test_result_sets", __FILE__)
 
 class UnitTests::TestResultSets::TestDatabase < Test::Unit::TestCase
+  test "with default options" do
+    database = stub('database')
+    Sequel.expects(:connect).with(:adapter => :sqlite, :database => 'results.db').returns(database)
+    result_set = Linkage::ResultSets::Database.new
+
+    score_set = stub('score set')
+    Linkage::ScoreSets::Database.expects(:new).with(database, {}).returns(score_set)
+    assert_same score_set, result_set.score_set
+
+    match_set = stub('match set')
+    Linkage::MatchSets::Database.expects(:new).with(database, {}).returns(match_set)
+    assert_same match_set, result_set.match_set
+  end
+
   test "with database object" do
     database = stub('database')
-    database.stubs(:kind_of?).with(Sequel::Database).returns(true)
-    result_set = Linkage::ResultSets::Database.new(database)
+    Sequel::Database.stubs(:===).with(database).returns(true)
+    result_set = Linkage::ResultSets::Database.new(database, {})
 
     score_set = stub('score set')
     Linkage::ScoreSets::Database.expects(:new).with(database, {}).returns(score_set)
@@ -43,22 +57,17 @@ class UnitTests::TestResultSets::TestDatabase < Test::Unit::TestCase
     assert_same match_set, result_set.match_set
   end
 
-  test "with database options and scores/matches options" do
-    opts = {
-      :foo => 'bar',
-      :scores => {:baz => 'qux'},
-      :matches => {:corge => 'grault'}
-    }
+  test "with overwrite option" do
     database = stub('database')
     Sequel.expects(:connect).with(:foo => 'bar').returns(database)
-    result_set = Linkage::ResultSets::Database.new(opts)
+    result_set = Linkage::ResultSets::Database.new({:foo => 'bar'}, {:overwrite => true})
 
     score_set = stub('score set')
-    Linkage::ScoreSets::Database.expects(:new).with(database, opts[:scores]).returns(score_set)
+    Linkage::ScoreSets::Database.expects(:new).with(database, {:overwrite => true}).returns(score_set)
     assert_same score_set, result_set.score_set
 
     match_set = stub('match set')
-    Linkage::MatchSets::Database.expects(:new).with(database, opts[:matches]).returns(match_set)
+    Linkage::MatchSets::Database.expects(:new).with(database, {:overwrite => true}).returns(match_set)
     assert_same match_set, result_set.match_set
   end
 

data/test/unit/score_sets/test_csv.rb

@@ -2,69 +2,101 @@ require File.expand_path("../../test_score_sets", __FILE__)
 
 class UnitTests::TestScoreSets::TestCSV < Test::Unit::TestCase
   test "open_for_writing" do
-    score_set = Linkage::ScoreSets::CSV.new('foo.csv')
+    score_set = Linkage::ScoreSets::CSV.new(:filename => 'foo.csv')
+    expected_filename = File.expand_path('foo.csv')
+    File.expects(:exist?).with(expected_filename).returns(false)
     csv = stub('csv')
-    CSV.expects(:open).with('foo.csv', 'wb').returns(csv)
+    CSV.expects(:open).with(expected_filename, 'wb').returns(csv)
+    csv.expects(:<<).with(%w{comparator_id id_1 id_2 score})
+    score_set.open_for_writing
+  end
+
+  test "open_for_writing with default options" do
+    score_set = Linkage::ScoreSets::CSV.new
+    expected_filename = File.expand_path('scores.csv')
+    File.expects(:exist?).with(expected_filename).returns(false)
+    csv = stub('csv')
+    CSV.expects(:open).with(expected_filename, 'wb').returns(csv)
+    csv.expects(:<<).with(%w{comparator_id id_1 id_2 score})
+    score_set.open_for_writing
+  end
+
+  test "open_for_writing with directory option" do
+    score_set = Linkage::ScoreSets::CSV.new(:dir => 'foo')
+
+    expected_dir = File.expand_path('foo')
+    FileUtils.expects(:mkdir_p).with(expected_dir)
+    expected_filename = File.join(expected_dir, 'scores.csv')
+    csv = stub('csv')
+    CSV.expects(:open).with(expected_filename, 'wb').returns(csv)
     csv.expects(:<<).with(%w{comparator_id id_1 id_2 score})
     score_set.open_for_writing
   end
 
   test "open_for_writing when already open" do
-    score_set = Linkage::ScoreSets::CSV.new('foo.csv')
+    score_set = Linkage::ScoreSets::CSV.new(:filename => 'foo.csv')
+    expected_filename = File.expand_path('foo.csv')
+    File.expects(:exist?).with(expected_filename).returns(false)
     csv = stub('csv')
-    CSV.expects(:open).once.with('foo.csv', 'wb').returns(csv)
+    CSV.expects(:open).once.with(expected_filename, 'wb').returns(csv)
     csv.expects(:<<).once.with(%w{comparator_id id_1 id_2 score})
     score_set.open_for_writing
     score_set.open_for_writing
   end
 
   test "open_for_writing when file exists" do
-    score_set = Linkage::ScoreSets::CSV.new('foo.csv')
-    File.expects(:exist?).with('foo.csv').returns(true)
+    score_set = Linkage::ScoreSets::CSV.new(:filename => 'foo.csv')
+    expected_filename = File.expand_path('foo.csv')
+    File.expects(:exist?).with(expected_filename).returns(true)
     assert_raises(Linkage::ExistsError) do
       score_set.open_for_writing
     end
   end
 
   test "open_for_writing when file exists and forcing overwrite" do
-    score_set = Linkage::ScoreSets::CSV.new('foo.csv', :overwrite => true)
-    File.stubs(:exist?).with('foo.csv').returns(true)
+    score_set = Linkage::ScoreSets::CSV.new(:filename => 'foo.csv', :overwrite => true)
+    expected_filename = File.expand_path('foo.csv')
+    File.stubs(:exist?).with(expected_filename).returns(true)
     assert_nothing_raised do
       csv = stub('csv')
-      CSV.expects(:open).with('foo.csv', 'wb').returns(csv)
+      CSV.expects(:open).with(expected_filename, 'wb').returns(csv)
       csv.expects(:<<).with(%w{comparator_id id_1 id_2 score})
       score_set.open_for_writing
     end
   end
 
   test "open_for_reading" do
-    score_set = Linkage::ScoreSets::CSV.new('foo.csv')
-    File.stubs(:exist?).with('foo.csv').returns(true)
+    score_set = Linkage::ScoreSets::CSV.new(:filename => 'foo.csv')
+    expected_filename = File.expand_path('foo.csv')
+    File.stubs(:exist?).with(expected_filename).returns(true)
     csv = stub('csv')
-    CSV.expects(:open).with('foo.csv', 'rb', {:headers => true}).returns(csv)
+    CSV.expects(:open).with(expected_filename, 'rb', {:headers => true}).returns(csv)
     score_set.open_for_reading
   end
 
   test "open_for_reading when already open" do
-    score_set = Linkage::ScoreSets::CSV.new('foo.csv')
-    File.stubs(:exist?).with('foo.csv').returns(true)
+    score_set = Linkage::ScoreSets::CSV.new(:filename => 'foo.csv')
+    expected_filename = File.expand_path('foo.csv')
+    File.stubs(:exist?).with(expected_filename).returns(true)
     csv = stub('csv')
-    CSV.expects(:open).once.with('foo.csv', 'rb', {:headers => true}).returns(csv)
+    CSV.expects(:open).once.with(expected_filename, 'rb', {:headers => true}).returns(csv)
     score_set.open_for_reading
     score_set.open_for_reading
   end
 
   test "open_for_reading when file doesn't exist" do
-    score_set = Linkage::ScoreSets::CSV.new('foo.csv')
-    File.expects(:exist?).with('foo.csv').returns(false)
+    score_set = Linkage::ScoreSets::CSV.new(:filename => 'foo.csv')
+    expected_filename = File.expand_path('foo.csv')
+    File.expects(:exist?).with(expected_filename).returns(false)
     assert_raises(Linkage::MissingError) do
       score_set.open_for_reading
     end
   end
 
   test "open_for_writing when in read mode raises exception" do
-    score_set = Linkage::ScoreSets::CSV.new('foo.csv')
-    File.stubs(:exist?).with('foo.csv').returns(true)
+    score_set = Linkage::ScoreSets::CSV.new(:filename => 'foo.csv')
+    expected_filename = File.expand_path('foo.csv')
+    File.stubs(:exist?).with(expected_filename).returns(true)
     csv = stub('csv')
     CSV.stubs(:open).returns(csv)
     score_set.open_for_reading
@@ -72,7 +104,7 @@ class UnitTests::TestScoreSets::TestCSV < Test::Unit::TestCase
   end
 
   test "open_for_reading when in write mode raises exception" do
-    score_set = Linkage::ScoreSets::CSV.new('foo.csv')
+    score_set = Linkage::ScoreSets::CSV.new(:filename => 'foo.csv')
     csv = stub('csv', :<< => nil)
     CSV.stubs(:open).returns(csv)
     score_set.open_for_writing
@@ -80,13 +112,14 @@ class UnitTests::TestScoreSets::TestCSV < Test::Unit::TestCase
   end
 
   test "add_score when unopened raises exception" do
-    score_set = Linkage::ScoreSets::CSV.new('foo.csv')
+    score_set = Linkage::ScoreSets::CSV.new(:filename => 'foo.csv')
     assert_raises { score_set.add_score(1, 1, 2, 1) }
   end
 
   test "add_score when in read mode raises exception" do
-    score_set = Linkage::ScoreSets::CSV.new('foo.csv')
-    File.stubs(:exist?).with('foo.csv').returns(true)
+    score_set = Linkage::ScoreSets::CSV.new(:filename => 'foo.csv')
+    expected_filename = File.expand_path('foo.csv')
+    File.stubs(:exist?).with(expected_filename).returns(true)
     csv = stub('csv')
     CSV.stubs(:open).returns(csv)
     score_set.open_for_reading
@@ -96,7 +129,7 @@ class UnitTests::TestScoreSets::TestCSV < Test::Unit::TestCase
   test "add_score" do
     tempfile = Tempfile.new('linkage')
     tempfile.close
-    score_set = Linkage::ScoreSets::CSV.new(tempfile.path, :overwrite => true)
+    score_set = Linkage::ScoreSets::CSV.new(:filename => tempfile.path, :overwrite => true)
     score_set.open_for_writing
     score_set.add_score(1, 1, 2, 1)
     score_set.close
@@ -118,10 +151,13 @@ class UnitTests::TestScoreSets::TestCSV < Test::Unit::TestCase
       3,4,5,0
     EOF
     tempfile.close
-    score_set = Linkage::ScoreSets::CSV.new(tempfile.path)
+    score_set = Linkage::ScoreSets::CSV.new(:filename => tempfile.path)
 
     pairs = []
+    score_set.open_for_reading
     score_set.each_pair { |*args| pairs << args }
+    score_set.close
+
     assert_equal 4, pairs.length
 
     pair_1 = pairs.detect { |pair| pair[0] == "1" && pair[1] == "2" }
@@ -145,6 +181,13 @@ class UnitTests::TestScoreSets::TestCSV < Test::Unit::TestCase
     assert_equal expected_4, pair_4[2]
   end
 
+  test "each_pair when not open for reading" do
+    score_set = Linkage::ScoreSets::CSV.new(:filename => "/foo/bar.csv")
+    assert_raise_message("not in read mode") do
+      score_set.each_pair { |*args| }
+    end
+  end
+
   test "registers itself" do
     assert_equal Linkage::ScoreSets::CSV, Linkage::ScoreSet['csv']
   end