linkage 0.0.0

data/test/unit/test_dataset.rb

@@ -0,0 +1,274 @@
+require 'helper'
+
+class UnitTests::TestDataset < Test::Unit::TestCase
+  def setup
+    @database = stub("database")
+    Sequel.stubs(:connect).yields(@database)
+    @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)
+    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)
+    Linkage::Field.stubs(:new).with(:last_name, kind_of(Hash)).returns(@last_name_field)
+  end
+
+  def expr(&block)
+    Sequel.virtual_row(&block)
+  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, then each" do
+    field = stub('field', :name => :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 descending, then each" do
+    field = stub('field', :name => :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 duplicates" do
+    field = stub('field', :name => :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_select, then each" do
+    field = stub('field', :name => :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', :name => :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 weeds out duplicates" do
+    field = stub('field', :name => :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 :==, then each" do
+    field = stub('field', :name => :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 two fields, then each" do
+    field_1 = stub_field('field 1', :name => :foo)
+    field_2 = stub_field('field 2', :name => :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)
+    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)
+    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)
+    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)
+    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)
+    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 { }
+  end
+
+  test "add_filter with :> field, then each" do
+    field_1 = stub_field('field 1', :name => :age)
+    field_2 = stub_field('field 2', :name => :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 { }
+  end
+end

data/test/unit/test_expectation.rb

@@ -0,0 +1,294 @@
+require 'helper'
+
+class UnitTests::TestExpectation < Test::Unit::TestCase
+  test "new must expectation with two fields" do
+    Linkage::MustExpectation.new(:==, stub_field('field 1'), stub_field('field 2'))
+  end
+
+  test "get" do
+    assert_equal Linkage::MustExpectation, Linkage::Expectation.get(:must)
+  end
+
+  test "kind when two fields from different datasets" do
+    dataset_1 = mock('dataset 1')
+    dataset_2 = mock('dataset 2')
+    field_1 = stub_field('field 1', :dataset => dataset_1)
+    field_2 = stub_field('field 2', :dataset => dataset_2)
+    field_1.expects(:==).with(field_2).returns(false)
+    dataset_1.expects(:==).with(dataset_2).returns(false)
+    exp = Linkage::MustExpectation.new(:==, field_1, field_2)
+    assert_equal :dual, exp.kind
+  end
+
+  test "kind when two identical fields from the same dataset" do
+    field_1 = stub_field('field 1')
+    field_2 = stub_field('field 2')
+    field_1.expects(:==).with(field_2).returns(true)
+    exp = Linkage::MustExpectation.new(:==, field_1, field_2)
+    assert_equal :self, exp.kind
+  end
+
+  test "kind when two different fields from the same dataset" do
+    dataset_1 = mock('dataset 1')
+    dataset_2 = mock('dataset 2')
+    field_1 = stub_field('field 1', :dataset => dataset_1)
+    field_2 = stub_field('field 2', :dataset => dataset_2)
+    field_1.expects(:==).with(field_2).returns(false)
+    dataset_1.expects(:==).with(dataset_2).returns(true)
+    exp = Linkage::MustExpectation.new(:==, field_1, field_2)
+    assert_equal :cross, exp.kind
+  end
+
+  test "manually set kind with two different fields from the same dataset" do
+    dataset = mock('dataset 1')
+    field_1 = stub_field('field 1', :dataset => dataset)
+    field_2 = stub_field('field 2', :dataset => dataset)
+    exp = Linkage::MustExpectation.new(:==, field_1, field_2, :filter)
+    assert_equal :filter, exp.kind
+  end
+
+  test "apply a two-field dual expectation to two datasets" do
+    dataset_1 = stub('dataset 1')
+    dataset_2 = stub('dataset 2')
+    field_1 = stub_field('field 1', :name => :foo, :dataset => dataset_1) do
+      stubs(:belongs_to?).with(dataset_1).returns(true)
+      stubs(:belongs_to?).with(dataset_2).returns(false)
+    end
+    field_2 = stub_field('field 2', :name => :foo, :dataset => dataset_2) do
+      stubs(:belongs_to?).with(dataset_2).returns(true)
+      stubs(:belongs_to?).with(dataset_1).returns(false)
+    end
+    merged_field = stub_field('merged field', :name => :foo)
+    field_1.stubs(:merge).with(field_2).returns(merged_field)
+    exp = Linkage::MustExpectation.new(:==, field_1, field_2)
+
+    dataset_1.expects(:add_order).with(field_1)
+    dataset_1.expects(:add_select).with(field_1, nil)
+    exp.apply_to(dataset_1)
+
+    dataset_2.expects(:add_order).with(field_2)
+    dataset_2.expects(:add_select).with(field_2, nil)
+    exp.apply_to(dataset_2)
+  end
+
+  test "apply a two-field dual expectation to two datasets with an alias" do
+    dataset_1 = stub('dataset 1')
+    dataset_2 = stub('dataset 2')
+    field_1 = stub_field('field 1', :name => :foo, :dataset => dataset_1) do
+      stubs(:belongs_to?).with(dataset_1).returns(true)
+      stubs(:belongs_to?).with(dataset_2).returns(false)
+    end
+    field_2 = stub_field('field 2', :name => :bar, :dataset => dataset_2) do
+      stubs(:belongs_to?).with(dataset_2).returns(true)
+      stubs(:belongs_to?).with(dataset_1).returns(false)
+    end
+    merged_field = stub_field('merged field', :name => :foo_bar)
+    field_1.stubs(:merge).with(field_2).returns(merged_field)
+    exp = Linkage::MustExpectation.new(:==, field_1, field_2)
+
+    dataset_1.expects(:add_order).with(field_1)
+    dataset_1.expects(:add_select).with(field_1, :foo_bar)
+    exp.apply_to(dataset_1)
+
+    dataset_2.expects(:add_order).with(field_2)
+    dataset_2.expects(:add_select).with(field_2, :foo_bar)
+    exp.apply_to(dataset_2)
+  end
+
+  test "apply a two-field cross expectation" do
+    dataset_1 = stub('dataset 1')
+    dataset_2 = stub('dataset 2')
+    dataset_1.stubs(:==).with(dataset_2).returns(true)
+    field_1 = stub_field('field 1', :name => :foo, :dataset => dataset_1) do
+      expects(:belongs_to?).with do |*args|
+        args[0].equal?(dataset_1)
+      end.returns(true)
+      expects(:belongs_to?).with do |*args|
+        args[0].equal?(dataset_2)
+      end.returns(false)
+    end
+    field_2 = stub_field('field 2', :name => :bar, :dataset => dataset_1) do
+      expects(:belongs_to?).with do |*args|
+        args[0].equal?(dataset_2)
+      end.returns(true)
+      expects(:belongs_to?).with do |*args|
+        args[0].equal?(dataset_1)
+      end.returns(false)
+    end
+    merged_field = stub_field('merged field', :name => :foo_bar)
+    field_1.stubs(:merge).with(field_2).returns(merged_field)
+    exp = Linkage::MustExpectation.new(:==, field_1, field_2)
+
+    dataset_1.expects(:add_order).with(field_1)
+    dataset_1.expects(:add_select).with(field_1, :foo_bar)
+    exp.apply_to(dataset_1)
+
+    dataset_2.expects(:add_order).with(field_2)
+    dataset_2.expects(:add_select).with(field_2, :foo_bar)
+    exp.apply_to(dataset_2)
+  end
+
+  test "apply a two-field self expectation" do
+    dataset = stub('dataset')
+    field = stub_field('field 1', :name => :foo, :dataset => dataset) do
+      expects(:belongs_to?).with(dataset).twice.returns(true)
+    end
+    exp = Linkage::MustExpectation.new(:==, field, field)
+
+    # Twice is okay, since add_order/add_select will take care of
+    # duplicates.
+    dataset.expects(:add_order).twice.with(field, nil)
+    dataset.expects(:add_select).twice.with(field, nil)
+    exp.apply_to(dataset)
+  end
+
+  test "apply a two-field self expectation like a cross" do
+    dataset_1 = stub('dataset 1')
+    dataset_2 = stub('dataset 2')
+    field_1 = stub_field('field 1', :name => :foo, :dataset => dataset_1) do
+      expects(:belongs_to?).with(dataset_1).returns(true)
+      expects(:belongs_to?).with(dataset_2).returns(false)
+    end
+    field_2 = stub_field('field 2', :name => :foo, :dataset => dataset_2) do
+      expects(:belongs_to?).with(dataset_2).returns(true)
+      expects(:belongs_to?).with(dataset_1).returns(false)
+    end
+    exp = Linkage::MustExpectation.new(:==, field_1, field_2, :self)
+
+    dataset_1.expects(:add_order).once.with(field_1, nil)
+    dataset_1.expects(:add_select).once.with(field_1, nil)
+    exp.apply_to(dataset_1)
+
+    dataset_2.expects(:add_order).once.with(field_2, nil)
+    dataset_2.expects(:add_select).once.with(field_2, nil)
+    exp.apply_to(dataset_2)
+  end
+
+  test "expectation name for join types" do
+    field_1 = stub_field('field 1')
+    field_2 = stub_field('field 2')
+    merged_field = stub_field('merged field', :name => :foo_bar)
+    field_1.stubs(:merge).with(field_2).returns(merged_field)
+
+    exp = Linkage::MustExpectation.new(:==, field_1, field_2)
+    assert_equal :foo_bar, exp.name
+  end
+
+  test "expectation with static value" do
+    field = stub_field('field')
+    exp = Linkage::MustExpectation.new(:==, field, 123)
+    assert_equal :filter, exp.kind
+  end
+
+  test "apply filter expectation" do
+    dataset_1 = stub('dataset 1')
+    dataset_2 = stub('dataset 2')
+    field = stub_field('field', :dataset => dataset_1)
+    exp = Linkage::MustExpectation.new(:==, field, 123)
+
+    dataset_1.expects(:add_filter).with(field, :==, 123)
+    field.expects(:belongs_to?).with(dataset_1).returns(true)
+    exp.apply_to(dataset_1)
+    field.expects(:belongs_to?).with(dataset_2).returns(false)
+    exp.apply_to(dataset_2)
+  end
+
+  test "apply filter expectation, static value first" do
+    dataset_1 = stub('dataset 1')
+    dataset_2 = stub('dataset 2')
+    field = stub_field('field', :dataset => dataset_1)
+    exp = Linkage::MustExpectation.new(:==, 123, field)
+
+    dataset_1.expects(:add_filter).with(field, :==, 123)
+    field.expects(:belongs_to?).with(dataset_1).returns(true)
+    exp.apply_to(dataset_1)
+    field.expects(:belongs_to?).with(dataset_2).returns(false)
+    exp.apply_to(dataset_2)
+  end
+
+  test "apply two-field filter expectation" do
+    dataset = stub('dataset')
+    field_1 = stub_field('field 1', :dataset => dataset)
+    field_2 = stub_field('field 2', :dataset => dataset)
+    exp = Linkage::MustExpectation.new(:==, field_1, field_2, :filter)
+
+    dataset.expects(:add_filter).with(field_1, :==, field_2)
+    field_1.expects(:belongs_to?).with(dataset).returns(true)
+    exp.apply_to(dataset)
+  end
+
+  test "creating expectation with two non-fields raises ArgumentError" do
+    assert_raises(ArgumentError) do
+      exp = Linkage::MustExpectation.new(:==, 123, 456)
+    end
+  end
+
+  test "raise error if operator is not supported" do
+    field = stub_field('field')
+    assert_raises(ArgumentError) do
+      exp = Linkage::MustExpectation.new(:foo, field, 456)
+    end
+  end
+
+  [:>, :<, :>=, :<=, :'!='].each do |operator|
+    test "#{operator} filter expectation" do
+      dataset_1 = stub('dataset 1')
+      dataset_2 = stub('dataset 2')
+      field = stub_field('field', :dataset => dataset_1)
+      exp = Linkage::MustExpectation.new(operator, field, 123)
+
+      dataset_1.expects(:add_filter).with(field, operator, 123)
+      field.expects(:belongs_to?).with(dataset_1).returns(true)
+      exp.apply_to(dataset_1)
+      field.expects(:belongs_to?).with(dataset_2).returns(false)
+      exp.apply_to(dataset_2)
+    end
+  end
+
+  test "only allows :== for non-filter expectations between two fields" do
+    field_1 = stub_field('field 1')
+    field_2 = stub_field('field 2')
+    assert_raises(ArgumentError) do
+      Linkage::MustExpectation.new(:>, field_1, field_2)
+    end
+  end
+
+  test "applies_to? with filter expectation" do
+    dataset = stub('dataset')
+    field = stub_field('field')
+    exp = Linkage::MustExpectation.new(:==, field, 123)
+    assert_equal :filter, exp.kind
+
+    field.expects(:belongs_to?).with(dataset).returns(true)
+    assert exp.applies_to?(dataset)
+  end
+
+  test "applies_to? with non-filter expectation" do
+    dataset_1 = stub('dataset 1')
+    field_1 = stub_field('field 1')
+    dataset_2 = stub('dataset 2')
+    field_2 = stub_field('field 2')
+    exp = Linkage::MustExpectation.new(:==, field_1, field_2)
+    assert_not_equal :filter, exp.kind
+
+    field_1.expects(:belongs_to?).with(dataset_1).returns(true)
+    assert exp.applies_to?(dataset_1)
+
+    field_1.expects(:belongs_to?).with(dataset_2).returns(false)
+    field_2.expects(:belongs_to?).with(dataset_2).returns(true)
+    assert exp.applies_to?(dataset_2)
+  end
+
+  test "MustNotExpectation negates operator" do
+    dataset_1 = stub('dataset 1')
+    dataset_2 = stub('dataset 2')
+    field = stub_field('field', :dataset => dataset_1)
+    exp = Linkage::MustNotExpectation.new(:==, field, 123)
+
+    dataset_1.expects(:add_filter).with(field, :'!=', 123)
+    field.expects(:belongs_to?).with(dataset_1).returns(true)
+    exp.apply_to(dataset_1)
+    field.expects(:belongs_to?).with(dataset_2).returns(false)
+    exp.apply_to(dataset_2)
+  end
+end