linkage 0.0.6 → 0.0.8

data/test/unit/test_configuration.rb

@@ -1,210 +1,172 @@
 require 'helper'
 
 class UnitTests::TestConfiguration < Test::Unit::TestCase
-  test "linkage_type is self when the two datasets are the same" do
-    dataset = stub('dataset')
-    c = Linkage::Configuration.new(dataset, dataset)
-    assert_equal :self, c.linkage_type
-  end
-
-  test "linkage_type is dual when the two datasets are different" do
+  test "result_set" do
     dataset_1 = stub('dataset')
     dataset_2 = stub('dataset')
     c = Linkage::Configuration.new(dataset_1, dataset_2)
-    assert_equal :dual, c.linkage_type
-  end
 
-  test "linkage_type is cross when there's a 'cross-join'" do
-    field_1 = stub('field_1', :to_expr => :foo)
-    field_2 = stub('field_2', :to_expr => :bar)
-    dataset = stub('dataset', :field_set => {:foo => field_1, :bar => :field_2})
-    c = Linkage::Configuration.new(dataset, dataset)
-    c.configure do
-      lhs[:foo].must == rhs[:bar]
-    end
-    assert_equal :cross, c.linkage_type
-  end
-
-  test "linkage_type is cross when there's different filters on both sides" do
-    field = stub('field', :to_expr => :foo)
-    dataset = stub('dataset')
-    dataset.stubs(:field_set).returns({:foo => field})
-    c = Linkage::Configuration.new(dataset, dataset)
-    c.configure do
-      lhs[:foo].must == 123
-      rhs[:foo].must == 456
-    end
-    assert_equal :cross, c.linkage_type
+    result_set = stub('result set')
+    Linkage::ResultSet.expects(:new).with(c).returns(result_set)
+    assert_equal result_set, c.result_set
   end
 
-  test "linkage_type is self when there's identical static filters on each side" do
-    field = stub('field', :to_expr => :foo)
-    dataset = stub('dataset')
-    dataset.stubs(:field_set).returns({:foo => field})
-    c = Linkage::Configuration.new(dataset, dataset)
-    exp_1 = stub('expectation', :kind => :filter)
-    c.configure do
-      lhs[:foo].must == 123
-      rhs[:foo].must == 123
-    end
-    assert_equal :self, c.linkage_type
+  test "groups_table_needed? is false if there are no simple expectations" do
+    dataset_1 = stub('dataset')
+    dataset_2 = stub('dataset')
+    conf = Linkage::Configuration.new(dataset_1, dataset_2)
+    assert !conf.groups_table_needed?
   end
 
-  test "linkage_type is self when there's a two-field filter on one side" do
-    field_1 = stub('field 1', :to_expr => :foo)
-    field_2 = stub('field 2', :to_expr => :bar)
-    dataset = stub('dataset')
-    dataset.stubs(:field_set).returns({:foo => field_1, :bar => field_2})
-    c = Linkage::Configuration.new(dataset, dataset)
-    c.configure do
-      lhs[:foo].must == lhs[:bar]
-      lhs[:foo].must == rhs[:foo]
-    end
-    assert_equal :self, c.linkage_type
+  test "groups_table_needed? is true if there are any simple expectations" do
+    dataset_1 = stub('dataset')
+    dataset_2 = stub('dataset')
+    conf = Linkage::Configuration.new(dataset_1, dataset_2)
+    exp = stub('simple expectation', :decollation_needed? => false)
+    conf.add_simple_expectation(exp)
+    assert conf.groups_table_needed?
   end
 
-  test "static expectation" do
+  test "scores_table_needed? is false if there are no exhaustive expectations" do
     dataset_1 = stub('dataset')
-    field = stub('field', :to_expr => :foo)
-    dataset_1.stubs(:field_set).returns({:foo => field})
     dataset_2 = stub('dataset')
-    c = Linkage::Configuration.new(dataset_1, dataset_2)
-    c.configure do
-      lhs[:foo].must == 123
-    end
-    dataset_1.expects(:filter).with({:foo => 123}).returns(dataset_1)
-    c.expectations[0].apply_to(dataset_1, :lhs)
+    conf = Linkage::Configuration.new(dataset_1, dataset_2)
+    assert !conf.scores_table_needed?
   end
 
-  test "complain if an invalid field is accessed" do
+  test "scores_table_needed? is true if there are any exhaustive expectations" do
     dataset_1 = stub('dataset')
-    field_1 = stub('field 1')
-    dataset_1.stubs(:field_set).returns({:foo => field_1})
-
     dataset_2 = stub('dataset')
-    field_2 = stub('field 2')
-    dataset_2.stubs(:field_set).returns({:bar => field_2})
-
-    c = Linkage::Configuration.new(dataset_1, dataset_2)
-    assert_raises(ArgumentError) do
-      c.configure do
-        lhs[:foo].must == rhs[:non_existant_field]
-      end
-    end
+    conf = Linkage::Configuration.new(dataset_1, dataset_2)
+    exp = stub('exhaustive expectation')
+    conf.add_exhaustive_expectation(exp)
+    assert conf.scores_table_needed?
   end
 
-  operators = [:>, :<, :>=, :<=]
-  operators.each do |operator|
-    test "DSL #{operator} filter operator" do
-      dataset_1 = stub('dataset 1')
-      field_1 = stub('field 1', :to_expr => :foo)
-      dataset_1.stubs(:field_set).returns({:foo => field_1})
-
-      dataset_2 = stub('dataset 2')
-
-      c = Linkage::Configuration.new(dataset_1, dataset_2)
-      block = eval("Proc.new { lhs[:foo].must #{operator} rhs[:bar] }")
-      c.configure do
-        lhs[:foo].must.send(operator, 123)
-      end
-      expr = Sequel::SQL::BooleanExpression.new(operator, Sequel::SQL::Identifier.new(:foo), 123)
-      dataset_1.expects(:filter).with(expr).returns(dataset_1)
-      c.expectations[0].apply_to(dataset_1, :lhs)
-    end
+  test "scores_table_schema" do
+    dataset_1 = stub('dataset 1', {
+      :field_set => stub('field set 1', {
+        :primary_key => stub('primary key 1', {
+          :ruby_type => {:type => Integer}
+        })
+      })
+    })
+    dataset_2 = stub('dataset 2', {
+      :field_set => stub('field set 2', {
+        :primary_key => stub('primary key 2', {
+          :ruby_type => {:type => String, :opts => {:size => 10}}
+        })
+      })
+    })
+    conf = Linkage::Configuration.new(dataset_1, dataset_2)
+    exp_1 = stub('exhaustive expectation 1')
+    exp_2 = stub('exhaustive expectation 2')
+    conf.add_exhaustive_expectation(exp_1)
+    conf.add_exhaustive_expectation(exp_2)
+
+    expected = [
+      [:id, Integer, {:primary_key => true}],
+      [:comparator_id, Integer, {}],
+      [:record_1_id, Integer, {}],
+      [:record_2_id, String, {:size => 10}],
+      [:score, Integer, {}],
+    ]
+    assert_equal expected, conf.scores_table_schema
   end
 
-  test "must_not expectation" do
-    dataset_1 = stub('dataset 1')
-    field_1 = stub('field 1', :to_expr => :foo)
-    dataset_1.stubs(:field_set).returns({:foo => field_1})
-    dataset_2 = stub('dataset 2')
-
-    c = Linkage::Configuration.new(dataset_1, dataset_2)
-    c.configure do
-      lhs[:foo].must_not == 123
-    end
-    dataset_1.expects(:filter).with(~{:foo => 123}).returns(dataset_1)
-    c.expectations[0].apply_to(dataset_1, :lhs)
+  test "datasets_with_applied_exhaustive_expectations" do
+    dataset_1 = stub('dataset 1', {
+      :field_set => stub('field set 1', {
+        :primary_key => stub('primary key 1', {
+          :to_expr => :foo_id
+        })
+      })
+    })
+    dataset_2 = stub('dataset 2', {
+      :field_set => stub('field set 2', {
+        :primary_key => stub('primary key 2', {
+          :to_expr => :bar_id
+        })
+      })
+    })
+    dataset_1a = stub('dataset 1a')
+    dataset_2a = stub('dataset 2a')
+    dataset_1b = stub('dataset 1b')
+    dataset_2b = stub('dataset 2b')
+    dataset_1c = stub('dataset 1c')
+    dataset_2c = stub('dataset 2c')
+    exp_1 = stub('exhaustive expectation 1')
+    exp_2 = stub('exhaustive expectation 2')
+
+    conf = Linkage::Configuration.new(dataset_1, dataset_2)
+    conf.add_exhaustive_expectation(exp_1)
+    conf.add_exhaustive_expectation(exp_2)
+
+    dataset_1.expects(:select).with(:foo_id).returns(dataset_1a)
+    dataset_2.expects(:select).with(:bar_id).returns(dataset_2a)
+    exp_1.expects(:apply_to).with(dataset_1a, :lhs).returns(dataset_1b)
+    exp_1.expects(:apply_to).with(dataset_2a, :rhs).returns(dataset_2b)
+    exp_2.expects(:apply_to).with(dataset_1b, :lhs).returns(dataset_1c)
+    exp_2.expects(:apply_to).with(dataset_2b, :rhs).returns(dataset_2c)
+
+    assert_equal [dataset_1c, dataset_2c], conf.datasets_with_applied_exhaustive_expectations
   end
 
-  test "dynamic database function" do
-    dataset_1 = stub('dataset', :adapter_scheme => :sqlite)
-    field_1 = stub('field 1')
-    dataset_1.stubs(:field_set).returns({:foo => field_1})
-    dataset_2 = stub('dataset', :adapter_scheme => :mysql2)
-    field_2 = stub('field 2', :to_expr => :foo)
-    dataset_2.stubs(:field_set).returns({:foo => field_2})
-
-    func_expr = stub('function expression')
-    func = stub('function', :static? => false, :to_expr => func_expr)
-    Linkage::Functions::Trim.expects(:new).with(field_1).returns(func)
-    merged_field = stub('merged field', :name => :trim_foo_foo)
-    func.expects(:merge).with(field_2).returns(merged_field)
-
-    c = Linkage::Configuration.new(dataset_1, dataset_2)
-    c.configure do
-      trim(lhs[:foo]).must == rhs[:foo]
-    end
-    dataset_1.expects(:match).with(func_expr, :trim_foo_foo).returns(dataset_1)
-    c.expectations[0].apply_to(dataset_1, :lhs)
-
-    dataset_2.expects(:match).with(:foo, :trim_foo_foo).returns(dataset_2)
-    c.expectations[0].apply_to(dataset_2, :rhs)
+  test "matches_table_schema" do
+    dataset_1 = stub('dataset 1', {
+      :field_set => stub('field set 1', {
+        :primary_key => stub('primary key 1', {
+          :ruby_type => {:type => Integer}
+        })
+      })
+    })
+    dataset_2 = stub('dataset 2', {
+      :field_set => stub('field set 2', {
+        :primary_key => stub('primary key 2', {
+          :ruby_type => {:type => String, :opts => {:size => 10}}
+        })
+      })
+    })
+    conf = Linkage::Configuration.new(dataset_1, dataset_2)
+
+    expected = [
+      [:id, Integer, {:primary_key => true}],
+      [:record_1_id, Integer, {}],
+      [:record_2_id, String, {:size => 10}],
+      [:total_score, Integer, {}],
+    ]
+    assert_equal expected, conf.matches_table_schema
   end
 
-  test "static database function" do
-    dataset_1 = stub('dataset', :adapter_scheme => :sqlite)
-    field_1 = stub('field 1', :to_expr => :foo)
-    dataset_1.stubs(:field_set).returns({:foo => field_1})
-    dataset_2 = stub('dataset', :adapter_scheme => :mysql)
-    field_2 = stub('field 2')
-    dataset_2.stubs(:field_set).returns({:foo => field_2})
-
-    func_expr = stub('function expression')
-    func = stub('function', :static? => true, :to_expr => func_expr)
-    Linkage::Functions::Trim.expects(:new).with("foo").returns(func)
-
-    c = Linkage::Configuration.new(dataset_1, dataset_2)
-    c.configure do
-      lhs[:foo].must == trim("foo")
-    end
-    dataset_1.expects(:filter).with({:foo => func_expr}).returns(dataset_1)
-    c.expectations[0].apply_to(dataset_1, :lhs)
+  test "change groups table name from default" do
+    dataset = stub('dataset')
+    conf = Linkage::Configuration.new(dataset, dataset)
+    assert_equal :groups, conf.groups_table_name
+    conf.groups_table_name = :foo_groups
+    assert_equal :foo_groups, conf.groups_table_name
   end
 
-  test "save_results_in" do
-    dataset_1 = stub('dataset')
-    dataset_2 = stub('dataset')
-    c = Linkage::Configuration.new(dataset_1, dataset_2)
-    c.configure do
-      save_results_in("mysql://localhost/results", {:foo => 'bar'})
-    end
-    assert_equal "mysql://localhost/results", c.results_uri
-    assert_equal({:foo => 'bar'}, c.results_uri_options)
+  test "change original groups table name from default" do
+    dataset = stub('dataset')
+    conf = Linkage::Configuration.new(dataset, dataset)
+    assert_equal :original_groups, conf.original_groups_table_name
+    conf.original_groups_table_name = :foo_original_groups
+    assert_equal :foo_original_groups, conf.original_groups_table_name
   end
 
-  test "result_set" do
-    dataset_1 = stub('dataset')
-    dataset_2 = stub('dataset')
-    c = Linkage::Configuration.new(dataset_1, dataset_2)
-
-    result_set = stub('result set')
-    Linkage::ResultSet.expects(:new).with(c).returns(result_set)
-    assert_equal result_set, c.result_set
+  test "change scores table name from default" do
+    dataset = stub('dataset')
+    conf = Linkage::Configuration.new(dataset, dataset)
+    assert_equal :scores, conf.scores_table_name
+    conf.scores_table_name = :foo_scores
+    assert_equal :foo_scores, conf.scores_table_name
   end
 
-  test "case insensitive field names" do
-    field_1 = stub('field_1', :to_expr => :foo)
-    field_2 = stub('field_2', :to_expr => :bar)
-    field_set = {:foo => field_1, :bar => :field_2}
-    field_set.expects(:has_key?).with(:Foo).returns(true)
-    field_set.expects(:has_key?).with(:baR).returns(true)
-    dataset = stub('dataset', :field_set => field_set)
-    c = Linkage::Configuration.new(dataset, dataset)
-    assert_nothing_raised do
-      c.configure do
-        lhs[:Foo].must == rhs[:baR]
-      end
-    end
+  test "change matches table name from default" do
+    dataset = stub('dataset')
+    conf = Linkage::Configuration.new(dataset, dataset)
+    assert_equal :matches, conf.matches_table_name
+    conf.matches_table_name = :foo_matches
+    assert_equal :foo_matches, conf.matches_table_name
   end
 end

data/test/unit/test_data.rb

@@ -24,6 +24,13 @@ class UnitTests::TestData < Test::Unit::TestCase
     assert_raises(NotImplementedError) { d.to_expr }
   end
 
+  test "database_type" do
+    dataset = mock('dataset')
+    data_1 = new_data(:foo, {}, dataset)
+    dataset.expects(:database_type).returns(:mysql)
+    assert_equal :mysql, data_1.database_type
+  end
+
   test "merge two identical fields" do
     data_1 = new_data(:id, {:type =>Integer})
     data_2 = new_data(:id, {:type =>Integer})
@@ -398,4 +405,41 @@ class UnitTests::TestData < Test::Unit::TestCase
     data_2 = new_data(:foo, {:type => Date})
     assert_raises { data_1.merge(data_2).ruby_type }
   end
+
+  test "merging two string fields with different collations strips the collation" do
+    dataset_1 = stub('dataset 1', :database_type => :mysql)
+    data_1 = new_data(:foo, {:type => String, :opts => {:collate => :foo}}, dataset_1)
+    dataset_2 = stub('dataset 2', :database_type => :mysql)
+    data_2 = new_data(:foo, {:type => String, :opts => {:collate => :bar}}, dataset_2)
+
+    result_data = data_1.merge(data_2)
+    result_opts = result_data.ruby_type[:opts] || {}
+    assert_nil result_opts[:collate]
+  end
+
+  test "merging two string fields with different database types strips the collation" do
+    dataset_1 = stub('dataset 1', :database_type => :mysql)
+    data_1 = new_data(:foo, {:type => String, :opts => {:collate => :foo}}, dataset_1)
+    dataset_2 = stub('dataset 2', :database_type => :sqlite)
+    data_2 = new_data(:foo, {:type => String, :opts => {:collate => :foo}}, dataset_2)
+
+    result_data = data_1.merge(data_2)
+    result_opts = result_data.ruby_type[:opts] || {}
+    assert_nil result_opts[:collate]
+  end
+
+  test "merged field has database type if they're the same" do
+    dataset_1 = stub('dataset 1', :database_type => :mysql)
+    data_1 = new_data(:foo, {:type => String}, dataset_1)
+    dataset_2 = stub('dataset 2', :database_type => :mysql)
+    data_2 = new_data(:foo, {:type => String}, dataset_2)
+    result_data = data_1.merge(data_2)
+    assert_equal :mysql, result_data.database_type
+  end
+
+  test "collation returns nil by default" do
+    dataset = stub('dataset')
+    data = new_data(:foo, {:type => String}, dataset)
+    assert_nil data.collation
+  end
 end

data/test/unit/test_dataset.rb

@@ -8,8 +8,9 @@ class UnitTests::TestDataset < Test::Unit::TestCase
       [: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}]
     ]
-    @dataset = stub('Sequel dataset')
-    @database = stub('database', :schema => @schema, :[] => @dataset)
+    @dataset = stub('Sequel dataset', :first_source_table => :foo)
+    @database = stub('database', :schema => @schema, :[] => @dataset, :extend => nil)
+    @dataset.stubs(:db).returns(@database)
     Sequel.stubs(:connect).returns(@database)
     @field_set = stub("field set")
     Linkage::FieldSet.stubs(:new).returns(@field_set)
@@ -17,48 +18,97 @@ class UnitTests::TestDataset < Test::Unit::TestCase
 
   test "initialize with uri and table name" do
     Sequel.expects(:connect).with('foo:/bar', {:foo => 'bar'}).returns(@database)
-    @database.expects(:schema).with(:foo).returns(@schema)
+    @database.expects(:extend).with(Sequel::Collation)
     @database.expects(:[]).with(:foo).returns(@dataset)
-    Linkage::FieldSet.expects(:new).with(@schema).returns(@field_set)
+    Linkage::FieldSet.expects(:new).with(kind_of(Linkage::Dataset)).returns(@field_set)
     ds = Linkage::Dataset.new('foo:/bar', "foo", {:foo => 'bar'})
   end
 
+  test "initialize with sequel dataset" do
+    Linkage::Dataset.new(@dataset)
+  end
+
+  test "extend Sequel::Collation when initializing with sequel dataset" do
+    @database.stubs(:kind_of?).with(Sequel::Collation).returns(false)
+    @database.expects(:extend).with(Sequel::Collation)
+    ds = Linkage::Dataset.new(@dataset)
+  end
+
+  test "don't extend already extended database" do
+    @database.stubs(:kind_of?).with(Sequel::Collation).returns(true)
+    @database.expects(:extend).with(Sequel::Collation).never
+    ds = Linkage::Dataset.new(@dataset)
+  end
+
   test "table_name" do
     ds = Linkage::Dataset.new('foo:/bar', "foo", {:foo => 'bar'})
     assert_equal :foo, ds.table_name
   end
 
-  test "adapter_scheme" do
+  test "table_name when initialized from sequel dataset" do
+    ds = Linkage::Dataset.new(@dataset)
+    assert_equal :foo, ds.table_name
+  end
+
+  test "schema" do
+    ds = Linkage::Dataset.new('foo:/bar', "foo", {:foo => 'bar'})
+    @database.expects(:schema).with(:foo).returns(@schema)
+    assert_equal @schema, ds.schema
+  end
+
+  test "schema when initialized from sequel dataset" do
+    ds = Linkage::Dataset.new(@dataset)
+    @database.expects(:schema).with(:foo).returns(@schema)
+    assert_equal @schema, ds.schema
+  end
+
+  test "database_type" 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
+    @database.expects(:database_type).returns(:foo)
+    assert_equal :foo, ds.database_type
   end
 
-  test "add match expression" do
+  test "set group_match" do
     ds_1 = Linkage::Dataset.new('foo:/bar', "foo", {:foo => 'bar'})
     @dataset.expects(:clone).returns(@dataset)
-    ds_2 = ds_1.match(:foo)
+    meta_object = stub_instance(Linkage::MetaObject)
+    ds_2 = ds_1.group_match(meta_object)
     assert_not_same ds_1, ds_2
-    assert_not_equal ds_1.instance_variable_get(:@_match),
-      ds_2.instance_variable_get(:@_match)
+    assert_not_equal ds_1.instance_variable_get(:@linkage_options),
+      ds_2.instance_variable_get(:@linkage_options)
   end
 
-  test "add match expression with alias, then each_group" do
+  test "subsequent group_match replaces old options" do
     ds_1 = Linkage::Dataset.new('foo:/bar', "foo", {:foo => 'bar'})
-    @dataset.expects(:clone).returns(@dataset)
-    ds_2 = ds_1.match(:foo, :aliased_foo)
-    @dataset.expects(:group_and_count).with(:foo.as(:aliased_foo)).returns(@dataset)
-    @dataset.expects(:having).returns(@dataset)
-    @dataset.expects(:each).yields({:aliased_foo => 123, :count => 1})
-    ds_2.each_group { |g| }
+    @dataset.expects(:clone).at_least_once.returns(@dataset)
+    meta_object_1 = stub_instance(Linkage::MetaObject)
+    ds_2 = ds_1.group_match(meta_object_1)
+    assert_equal([{:meta_object => meta_object_1}], ds_2.linkage_options[:group_match])
+
+    meta_object_2 = stub_instance(Linkage::MetaObject)
+    ds_3 = ds_2.group_match(meta_object_2)
+    assert_equal([{:meta_object => meta_object_2}], ds_3.linkage_options[:group_match])
+  end
+
+  test "group_match_more appends to group_match options" do
+    ds_1 = Linkage::Dataset.new('foo:/bar', "foo", {:foo => 'bar'})
+    @dataset.expects(:clone).at_least_once.returns(@dataset)
+    meta_object_1 = stub_instance(Linkage::MetaObject)
+    ds_2 = ds_1.group_match(meta_object_1)
+    assert_equal([{:meta_object => meta_object_1}], ds_2.linkage_options[:group_match])
+
+    meta_object_2 = stub_instance(Linkage::MetaObject)
+    ds_3 = ds_2.group_match_more(meta_object_2)
+    assert_equal([{:meta_object => meta_object_1}, {:meta_object => meta_object_2}], ds_3.linkage_options[:group_match])
   end
 
   test "group_by_matches" do
     ds = Linkage::Dataset.new('foo:/bar', "foo", {:foo => 'bar'})
 
     @dataset.expects(:clone).returns(@dataset)
-    ds = ds.match(:foo)
+    meta_object = stub_instance(Linkage::MetaObject, :to_expr => :foo)
+    ds = ds.group_match(meta_object)
     @dataset.expects(:group).with(:foo).returns(@dataset)
 
     ds.group_by_matches
@@ -67,7 +117,8 @@ class UnitTests::TestDataset < Test::Unit::TestCase
   test "dataset_for_group" do
     ds = Linkage::Dataset.new('foo:/bar', "foo", {:foo => 'bar'})
     @dataset.expects(:clone).returns(@dataset)
-    ds = ds.match(:foo, :foo_bar)
+    meta_object = stub_instance(Linkage::MetaObject, :to_expr => :foo)
+    ds = ds.group_match({:meta_object => meta_object, :alias => :foo_bar})
 
     group = stub("group", :values => {:foo_bar => 'baz'})
     filtered_dataset = stub('filtered dataset')
@@ -78,7 +129,8 @@ class UnitTests::TestDataset < Test::Unit::TestCase
   test "dataset_for_group without aliases" do
     ds = Linkage::Dataset.new('foo:/bar', "foo", {:foo => 'bar'})
     @dataset.expects(:clone).returns(@dataset)
-    ds = ds.match(:foo)
+    meta_object = stub_instance(Linkage::MetaObject, :to_expr => :foo)
+    ds = ds.group_match(meta_object)
 
     group = stub("group", :values => {:foo => 'baz'})
     filtered_dataset = stub('filtered dataset')