linkage 0.0.2 → 0.0.3

data/test/unit/test_dataset.rb

@@ -2,336 +2,36 @@ require 'helper'
 
 class UnitTests::TestDataset < Test::Unit::TestCase
   def setup
-    @database = stub("database")
-    Sequel.stubs(:connect).yields(@database)
+    super
     @schema = [
       [:id, {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil}],
       [:first_name, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"varchar(255)", :type=>:string, :ruby_default=>nil}],
       [:last_name, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"varchar(255)", :type=>:string, :ruby_default=>nil}]
     ]
-    @database.stubs(:schema).returns(@schema)
-    @dataset = stub("dataset")
-    @database.stubs(:[]).returns(@dataset)
-
-    @id_field = stub("id field", :dataset= => nil, :name => :id)
-    Linkage::Field.stubs(:new).with(:id, kind_of(Hash)).returns(@id_field)
-    @first_name_field = stub("first_name field", :dataset= => nil, :name => :first_name, :to_expr => :first_name)
-    Linkage::Field.stubs(:new).with(:first_name, kind_of(Hash)).returns(@first_name_field)
-    @last_name_field = stub("last_name field", :dataset= => nil, :name => :last_name, :to_expr => :last_name)
-    Linkage::Field.stubs(:new).with(:last_name, kind_of(Hash)).returns(@last_name_field)
-  end
-
-  def expr(&block)
-    Sequel.virtual_row(&block)
+    @dataset = stub('Sequel dataset')
+    @database = stub('database', :schema => @schema, :[] => @dataset)
+    Sequel.stubs(:connect).returns(@database)
+    @field_set = stub("field set")
+    Linkage::FieldSet.stubs(:new).returns(@field_set)
   end
 
   test "initialize with uri and table name" do
-    Sequel.expects(:connect).with("foo:/bar", {}).yields(@database)
-    @database.expects(:schema).with(:baz).returns(@schema)
-    primary_key_field = mock(:dataset= => nil)
-    Linkage::Field.expects(:new).with(*@schema[0]).returns(primary_key_field)
-    Linkage::Field.expects(:new).with(*@schema[1]).returns(mock(:dataset= => nil))
-    Linkage::Field.expects(:new).with(*@schema[2]).returns(mock(:dataset= => nil))
-
-    ds = Linkage::Dataset.new("foo:/bar", "baz")
-    assert_equal primary_key_field, ds.primary_key
-  end
-
-  test "initialize with sequel options" do
-    Sequel.expects(:connect).with("foo:/bar", :junk => 123).yields(@database)
-    ds = Linkage::Dataset.new("foo:/bar", "baz", :junk => 123)
-  end
-
-  test "dataset id increments" do
-    dataset_1 = Linkage::Dataset.new("foo:/bar", "baz")
-    assert_kind_of Fixnum, dataset_1.id
-    dataset_2 = Linkage::Dataset.new("foo:/qux", "corge")
-    assert_equal dataset_1.id + 1, dataset_2.id
-  end
-
-  test "== compares uri and table name" do
-    dataset_1 = Linkage::Dataset.new("foo:/bar", "baz")
-    dataset_2 = Linkage::Dataset.new("foo:/bar", "baz")
-    dataset_3 = Linkage::Dataset.new("foo:/qux", "corge")
-    assert_equal dataset_1, dataset_2
-    assert_not_equal dataset_1, dataset_3
-  end
-
-  test "dup" do
-    dataset_1 = Linkage::Dataset.new("foo:/bar", "baz")
-
-    ds = stub('new dataset')
-    Linkage::Dataset.expects(:new).with('foo:/bar', :baz).returns(ds)
-    dataset_2 = dataset_1.dup
-    assert_equal ds, dataset_2
-  end
-
-  test "clone doesn't shallow copy fields" do
-    field_1 = stub('field 1', :name => :id, :dataset= => nil)
-    Linkage::Field.expects(:new).with(*@schema[0]).returns(field_1)
-    field_2 = stub('field 2', :dataset= => nil)
-    Linkage::Field.expects(:new).with(*@schema[1]).returns(field_2)
-    field_3 = stub('field 3', :dataset= => nil)
-    Linkage::Field.expects(:new).with(*@schema[2]).returns(field_3)
-    dataset_1 = Linkage::Dataset.new("foo:/bar", "baz")
-
-    field_1.expects(:clone).returns(mock('field 1 clone', :dataset= => nil))
-    field_2.expects(:clone).returns(mock('field 2 clone', :dataset= => nil))
-    field_3.expects(:clone).returns(mock('field 3 clone', :dataset= => nil))
-    dataset_2 = dataset_1.clone
-    dataset_2.fields.each_pair do |name, field|
-      assert !field.equal?(dataset_1.fields[name])
-    end
-    assert !dataset_2.primary_key.equal?(dataset_1.primary_key)
-    assert_equal dataset_1.id, dataset_2.id
-  end
-
-  test "clone doesn't shallow copy @order" do
-    dataset_1 = Linkage::Dataset.new("foo:/bar", "baz")
-    dataset_2 = dataset_1.clone
-    dataset_1.add_order(@first_name_field)
-    assert_empty dataset_2.instance_variable_get(:@order)
-  end
-
-  test "clone doesn't shallow copy @select" do
-    dataset_1 = Linkage::Dataset.new("foo:/bar", "baz")
-    dataset_2 = dataset_1.clone
-    dataset_1.add_select(@first_name_field)
-    assert_empty dataset_2.instance_variable_get(:@select)
-  end
-
-  test "clone doesn't shallow copy @filter" do
-    dataset_1 = Linkage::Dataset.new("foo:/bar", "baz")
-    dataset_2 = dataset_1.clone
-    dataset_1.add_filter(@first_name_field, :==, "foo")
-    assert_empty dataset_2.instance_variable_get(:@filter)
-  end
-
-  test "add_order with field, then each" do
-    field = stub_field('field', :name => :last_name, :to_expr => :last_name)
-    ds = Linkage::Dataset.new("foo:/bar", "baz")
-    ds.add_order(field)
-    @dataset.expects(:order).with(:last_name).returns(@dataset)
-    row = {:id => 123, :last_name => 'foo'}
-    @dataset.expects(:each).yields(row)
-
-    ran = false
-    ds.each do |yielded_row|
-      ran = true
-      assert_equal({:pk => 123, :values => {:last_name => 'foo'}}, yielded_row)
-    end
-    assert ran
-  end
-
-  test "add_order with function, then each" do
-    expr = stub('expression')
-    func = stub_function('func', :name => :trim_stuff, :to_expr => expr)
-    ds = Linkage::Dataset.new("foo:/bar", "baz")
-    ds.add_order(func)
-    @dataset.expects(:order).with(expr).returns(@dataset)
-    row = {:id => 123, :trim_stuff => 'foo'}
-    @dataset.expects(:each).yields(row)
-
-    ran = false
-    ds.each do |yielded_row|
-      ran = true
-      assert_equal({:pk => 123, :values => {:trim_stuff => 'foo'}}, yielded_row)
-    end
-    assert ran
-  end
-
-  test "add_order descending, then each" do
-    field = stub_field('field', :name => :last_name, :to_expr => :last_name)
-    ds = Linkage::Dataset.new("foo:/bar", "baz")
-    ds.add_order(field, :desc)
-    @dataset.expects(:order).with(:last_name.desc).returns(@dataset)
-    row = {:id => 123, :last_name => 'foo'}
-    @dataset.expects(:each).yields(row)
-
-    ran = false
-    ds.each do |yielded_row|
-      ran = true
-      assert_equal({:pk => 123, :values => {:last_name => 'foo'}}, yielded_row)
-    end
-    assert ran
-  end
-
-  test "add_order weeds out field duplicates" do
-    field = stub_field('field', :name => :last_name, :to_expr => :last_name)
-    ds = Linkage::Dataset.new("foo:/bar", "baz")
-    ds.add_order(field)
-    ds.add_order(field)
-    @dataset.expects(:order).with(:last_name).returns(@dataset)
-    @dataset.expects(:each)
-    ds.each { }
-  end
-
-  test "add_order weeds out function duplicates" do
-    expr = stub('expression')
-    func = stub_function('func', :name => :trim_stuff, :to_expr => expr)
-    ds = Linkage::Dataset.new("foo:/bar", "baz")
-    ds.add_order(func)
-    ds.add_order(func)
-    @dataset.expects(:order).with(expr).returns(@dataset)
-    @dataset.expects(:each)
-    ds.each { }
-  end
-
-  test "add_select with field, then each" do
-    field = stub_field('field', :name => :last_name, :to_expr => :last_name)
-    ds = Linkage::Dataset.new("foo:/bar", "baz")
-    ds.add_select(field)
-    @dataset.expects(:select).with(:id, :last_name).returns(@dataset)
-    row = {:id => 123, :last_name => 'foo'}
-    @dataset.expects(:each).yields(row)
-
-    ran = false
-    ds.each do |yielded_row|
-      ran = true
-      assert_equal({:pk => 123, :values => {:last_name => 'foo'}}, yielded_row)
-    end
-    assert ran
-  end
-
-  test "add_select with an alias, then each" do
-    field = stub_field('field', :name => :last_name, :to_expr => :last_name)
-    ds = Linkage::Dataset.new("foo:/bar", "baz")
-    ds.add_select(field, :junk)
-    @dataset.expects(:select).with(:id, :last_name.as(:junk)).returns(@dataset)
-    row = {:id => 123, :junk => 'foo'}
-    @dataset.expects(:each).yields(row)
-
-    ran = false
-    ds.each do |yielded_row|
-      ran = true
-      assert_equal({:pk => 123, :values => {:junk => 'foo'}}, yielded_row)
-    end
-    assert ran
-  end
-
-  test "add_select with function, then each" do
-    expr = stub('expression')
-    func = stub_function('func', :name => :trim_stuff, :to_expr => expr)
-    ds = Linkage::Dataset.new("foo:/bar", "baz")
-    ds.add_select(func)
-    @dataset.expects(:select).with(:id, expr).returns(@dataset)
-    row = {:id => 123, :trim_stuff => 'foo'}
-    @dataset.expects(:each).yields(row)
-
-    ran = false
-    ds.each do |yielded_row|
-      ran = true
-      assert_equal({:pk => 123, :values => {:trim_stuff => 'foo'}}, yielded_row)
-    end
-    assert ran
-  end
-
-  test "add_select weeds out duplicates" do
-    field = stub_field('field', :name => :last_name, :to_expr => :last_name)
-    ds = Linkage::Dataset.new("foo:/bar", "baz")
-    ds.add_select(field)
-    ds.add_select(field)
-    @dataset.expects(:select).with(:id, :last_name).returns(@dataset)
-    @dataset.expects(:each)
-    ds.each { }
-  end
-
-  test "add_filter with :== between field and static value, then each" do
-    field = stub('field', :name => :age, :to_expr => :age)
-    ds = Linkage::Dataset.new("foo:/bar", "baz")
-    ds.add_filter(field, :==, 30)
-    @dataset.expects(:filter).with(:age => 30).returns(@dataset)
-    row = {:id => 123, :junk => 'foo'}
-    @dataset.expects(:each).yields(row)
-
-    ran = false
-    ds.each do |yielded_row|
-      ran = true
-      assert_equal({:pk => 123, :values => {:junk => 'foo'}}, yielded_row)
-    end
-    assert ran
-  end
-
-  test "add_filter with :== between field and static function, then each" do
-    field = stub_field('field', :name => :age, :to_expr => :age)
-    expr = stub('expression')
-    func = stub_function('func', :name => :func, :to_expr => expr)
-    ds = Linkage::Dataset.new("foo:/bar", "baz")
-    ds.add_filter(field, :==, func)
-    @dataset.expects(:filter).with(:age => expr).returns(@dataset)
-    row = {:id => 123, :junk => 'foo'}
-    @dataset.expects(:each).yields(row)
-
-    ran = false
-    ds.each do |yielded_row|
-      ran = true
-      assert_equal({:pk => 123, :values => {:junk => 'foo'}}, yielded_row)
-    end
-    assert ran
-  end
-
-  test "add_filter with :== between two fields, then each" do
-    field_1 = stub_field('field 1', :name => :foo, :to_expr => :foo)
-    field_2 = stub_field('field 2', :name => :bar, :to_expr => :bar)
-    ds = Linkage::Dataset.new("foo:/bar", "baz")
-    ds.add_filter(field_1, :==, field_2)
-    @dataset.expects(:filter).with(:foo => :bar).returns(@dataset)
-    @dataset.expects(:each)
-    ds.each { }
-  end
-
-  test "add_filter with :>, then each" do
-    field = stub('field', :name => :age, :to_expr => :age)
-    ds = Linkage::Dataset.new("foo:/bar", "baz")
-    ds.add_filter(field, :>, 30)
-    @dataset.expects(:filter).with(expr{age > 30}).returns(@dataset)
-    @dataset.expects(:each)
-    ds.each { }
-  end
-
-  test "add_filter with :<, then each" do
-    field = stub_field('field', :name => :age, :to_expr => :age)
-    ds = Linkage::Dataset.new("foo:/bar", "baz")
-    ds.add_filter(field, :<, 30)
-    @dataset.expects(:filter).with(expr{age < 30}).returns(@dataset)
-    @dataset.expects(:each)
-    ds.each { }
-  end
-
-  test "add_filter with :>=, then each" do
-    field = stub_field('field', :name => :age, :to_expr => :age)
-    ds = Linkage::Dataset.new("foo:/bar", "baz")
-    ds.add_filter(field, :>=, 30)
-    @dataset.expects(:filter).with(expr{age >= 30}).returns(@dataset)
-    @dataset.expects(:each)
-    ds.each { }
-  end
-
-  test "add_filter with :<=, then each" do
-    field = stub('field', :name => :age, :to_expr => :age)
-    ds = Linkage::Dataset.new("foo:/bar", "baz")
-    ds.add_filter(field, :<=, 30)
-    @dataset.expects(:filter).with(expr{age <= 30}).returns(@dataset)
-    @dataset.expects(:each)
-    ds.each { }
+    Sequel.expects(:connect).with('foo:/bar', {:foo => 'bar'}).returns(@database)
+    @database.expects(:schema).with(:foo).returns(@schema)
+    @database.expects(:[]).with(:foo).returns(@dataset)
+    Linkage::FieldSet.expects(:new).with(@schema).returns(@field_set)
+    ds = Linkage::Dataset.new('foo:/bar', "foo", {:foo => 'bar'})
   end
 
-  test "add_filter with :!=, then each" do
-    field = stub_field('field', :name => :age, :to_expr => :age)
-    ds = Linkage::Dataset.new("foo:/bar", "baz")
-    ds.add_filter(field, :'!=', 30)
-    @dataset.expects(:filter).with(~{:age => 30}).returns(@dataset)
-    @dataset.expects(:each)
-    ds.each { }
+  test "table_name" do
+    ds = Linkage::Dataset.new('foo:/bar', "foo", {:foo => 'bar'})
+    assert_equal :foo, ds.table_name
   end
 
-  test "add_filter with :> field, then each" do
-    field_1 = stub_field('field 1', :name => :age, :to_expr => :age)
-    field_2 = stub_field('field 2', :name => :age_2, :to_expr => :age_2)
-    ds = Linkage::Dataset.new("foo:/bar", "baz")
-    ds.add_filter(field_1, :>, field_2)
-    @dataset.expects(:filter).with(expr{age > age_2}).returns(@dataset)
-    @dataset.expects(:each)
-    ds.each { }
+  test "adapter_scheme" do
+    ds = Linkage::Dataset.new('foo:/bar', "foo", {:foo => 'bar'})
+    @dataset.stubs(:db).returns(@database)
+    @database.expects(:adapter_scheme).returns(:foo)
+    assert_equal :foo, ds.adapter_scheme
   end
 end

data/test/unit/test_field.rb

@@ -1,12 +1,6 @@
 require 'helper'
 
 class UnitTests::TestField < Test::Unit::TestCase
-  def new_field(name, schema, ruby_type, dataset = nil)
-    f = Linkage::Field.new(name, schema, ruby_type)
-    f.dataset = dataset || stub('dataset')
-    f
-  end
-
   test "subclass of data" do
     assert_equal Linkage::Data, Linkage::Field.superclass
   end

data/test/unit/test_field_set.rb

@@ -0,0 +1,31 @@
+require 'helper'
+
+class UnitTests::TestFieldSet < Test::Unit::TestCase
+  def setup
+    super
+    @schema = {
+      :id => {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil},
+      :first_name => {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"varchar(255)", :type=>:string, :ruby_default=>nil},
+      :last_name => {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"varchar(255)", :type=>:string, :ruby_default=>nil}
+    }
+  end
+
+  test "subclass of Hash" do
+    assert_equal Hash, Linkage::FieldSet.superclass
+  end
+
+  test "creates fields on initialization" do
+    field_1 = stub('id field')
+    field_2 = stub('first_name field')
+    field_3 = stub('last_name field')
+    Linkage::Field.expects(:new).with(:id, @schema[:id]).returns(field_1)
+    Linkage::Field.expects(:new).with(:first_name, @schema[:first_name]).returns(field_2)
+    Linkage::Field.expects(:new).with(:last_name, @schema[:last_name]).returns(field_3)
+
+    fs = Linkage::FieldSet.new(@schema)
+    assert_equal field_1, fs.primary_key
+    assert_equal field_1, fs[:id]
+    assert_equal field_2, fs[:first_name]
+    assert_equal field_3, fs[:last_name]
+  end
+end

data/test/unit/test_function.rb

@@ -55,38 +55,32 @@ class UnitTests::TestFunction < Test::Unit::TestCase
 
   test "function with field" do
     klass = new_function('foo', {:type => String})
-    dataset = stub('dataset')
-    field = stub_field('field', :name => :bar, :ruby_type => {:type => String}, :dataset => dataset)
+    field = stub_field('field', :name => :bar, :ruby_type => {:type => String})
     f = klass.new(field)
     assert_equal :foo_bar, f.name
     assert_equal :foo.sql_function(:bar), f.to_expr
     assert !f.static?
-    assert_equal dataset, f.dataset
   end
 
   test "function with dynamic function" do
     klass_1 = new_function('foo', {:type => String})
     klass_2 = new_function('bar', {:type => String})
 
-    dataset = stub('dataset')
-    field = stub_field('field', :name => :baz, :ruby_type => {:type => String}, :dataset => dataset)
+    field = stub_field('field', :name => :baz, :ruby_type => {:type => String})
     func_1 = klass_1.new(field)
     assert_equal :foo_baz, func_1.name
     assert !func_1.static?
-    assert_equal dataset, func_1.dataset
 
     func_2 = klass_2.new(func_1)
     assert_equal :bar_foo_baz, func_2.name
     assert !func_2.static?
     assert_equal :bar.sql_function(:foo.sql_function(:baz)), func_2.to_expr
-    assert_equal dataset, func_2.dataset
   end
 
   test "function with static function" do
     klass_1 = new_function('foo', {:type => String})
     klass_2 = new_function('bar', {:type => String})
 
-    dataset = stub('dataset')
     func_1 = klass_1.new(123)
     assert_equal :foo_123, func_1.name
     assert func_1.static?
@@ -106,25 +100,21 @@ class UnitTests::TestFunction < Test::Unit::TestCase
     assert_equal :foo_123, func_1.name
     assert func_1.static?
 
-    dataset = stub('dataset')
-    field = stub_field('field', :name => :quux, :ruby_type => {:type => String}, :dataset => dataset)
+    field = stub_field('field', :name => :quux, :ruby_type => {:type => String})
     func_2 = klass_2.new(field)
     assert_equal :bar_quux, func_2.name
     assert !func_2.static?
-    assert_equal dataset, func_2.dataset
 
     func_3 = klass_3.new(func_2, func_1)
     assert_equal :baz_bar_quux_foo_123, func_3.name
     assert !func_3.static?
-    assert_equal dataset, func_3.dataset
     assert_equal :baz.sql_function(:bar.sql_function(:quux), :foo.sql_function(123)), func_3.to_expr
   end
 
   test "function with multiple fields" do
     klass = new_function('foo', {:type => String})
-    dataset = stub('dataset')
-    field_1 = stub_field('field', :name => :bar, :ruby_type => {:type => String}, :dataset => dataset)
-    field_2 = stub_field('field', :name => :baz, :ruby_type => {:type => String}, :dataset => dataset)
+    field_1 = stub_field('field', :name => :bar, :ruby_type => {:type => String})
+    field_2 = stub_field('field', :name => :baz, :ruby_type => {:type => String})
     func = klass.new(field_1, field_2)
     assert_equal :foo_bar_baz, func.name
     assert_equal :foo.sql_function(:bar, :baz), func.to_expr
@@ -133,24 +123,10 @@ class UnitTests::TestFunction < Test::Unit::TestCase
 
   test "function with multiple mixed arguments" do
     klass = new_function('foo', {:type => String})
-    dataset = stub('dataset')
-    field = stub_field('field', :name => :bar, :ruby_type => {:type => String}, :dataset => dataset)
+    field = stub_field('field', :name => :bar, :ruby_type => {:type => String})
     f = klass.new(field, 123, 'abc')
     assert_equal :foo_bar_123_abc, f.name
     assert_equal :foo.sql_function(:bar, 123, 'abc'), f.to_expr
-    assert_equal dataset, f.dataset
-  end
-
-  test "illegal function with fields from more than one dataset" do
-    klass = new_function('foo', {:type => String})
-    dataset_1 = stub('dataset 1')
-    dataset_2 = stub('dataset 2')
-    field_1 = stub_field('field', :name => :bar, :ruby_type => {:type => String}, :dataset => dataset_1)
-    field_2 = stub_field('field', :name => :baz, :ruby_type => {:type => String}, :dataset => dataset_2)
-
-    assert_raises(ArgumentError) do
-      func = klass.new(field_1, field_2)
-    end
   end
 
   test "fetching registered function" do

data/test/unit/test_result_set.rb

@@ -0,0 +1,18 @@
+require 'helper'
+
+class TestResultSet < Test::Unit::TestCase
+  def setup
+    @config = stub('configuration', {
+      :results_uri => 'foo://bar',
+      :results_uri_options => {:blah => 'junk'}
+    })
+  end
+
+  test "creating a result set with a configuration" do
+    result_set = Linkage::ResultSet.new(@config)
+  end
+
+  test "records?" do
+    pend
+  end
+end

data/test/unit/test_runner.rb

@@ -1,14 +1,29 @@
 require 'helper'
 
 class UnitTests::TestRunner < Test::Unit::TestCase
-  test "initialization" do
-    conf = stub("configuration")
-    runner = Linkage::Runner.new(conf, "foo:/results")
+  def setup
+    @result_set = stub("result set")
+    @config = stub("configuration", :result_set => @result_set)
+  end
+
+  test "initialization creates a result set" do
+    runner = Linkage::Runner.new(@config)
+  end
+
+  test "initialization with deprecated uri and options" do
+    @config.expects(:save_results_in).with("foo:/results", {:foo => 'bar'})
+    Linkage::Runner.any_instance.expects(:warn)
+    runner = Linkage::Runner.new(@config, "foo:/results", {:foo => 'bar'})
   end
 
   test "execute raises error" do
-    conf = stub("configuration")
-    runner = Linkage::Runner.new(conf, "foo:/results")
+    runner = Linkage::Runner.new(@config)
     assert_raise_kind_of(NotImplementedError) { runner.execute }
   end
+
+  test "result_set gets ResultSet from config" do
+    runner = Linkage::Runner.new(@config)
+    @config.expects(:result_set).returns(@result_set)
+    assert_equal @result_set, runner.result_set
+  end
 end