coupler 0.0.1-java

data/test/unit/models/test_comparison.rb

@@ -0,0 +1,619 @@
+require 'helper'
+
+module Coupler
+  module Models
+    class TestComparison < Coupler::Test::UnitTest
+      def sequel_expr(*args)
+        if args.length == 1
+          obj = args[0]
+          obj.is_a?(Sequel::SQL::BooleanExpression) ? obj : Sequel::SQL::BooleanExpression.from_value_pairs(obj)
+        else
+          Sequel::SQL::BooleanExpression.new(*args)
+        end
+      end
+
+      def new_comparison(attribs = {})
+        values = {
+          :lhs_type      => "integer",
+          :raw_lhs_value => 1,
+          :rhs_type      => "integer",
+          :raw_rhs_value => 1,
+          :operator      => "equals",
+          :matcher       => @matcher
+        }.update(attribs)
+        c = Comparison.new(values)
+        c
+      end
+
+      def setup
+        super
+        @matcher = stub('matcher', :id => 123, :pk => 123, :associations => {})
+      end
+
+      test "sequel model" do
+        assert_equal ::Sequel::Model, Comparison.superclass
+        assert_equal :comparisons, Comparison.table_name
+      end
+
+      test "many to one matcher" do
+        assert_respond_to Comparison.new, :matcher
+      end
+
+      #def test_serializes_lhs_and_rhs_values
+        #comparison = new_comparison({
+          #:lhs_type => "integer", :raw_lhs_value => 123,
+          #:rhs_type => "integer", :raw_rhs_value => 123
+        #}).save!
+        #assert_equal 123, comparison.raw_lhs_value
+        #assert_equal 123, comparison.raw_rhs_value
+      #end
+
+      test "requires values" do
+        comparison = new_comparison({
+          :raw_lhs_value => nil,
+          :raw_rhs_value => nil
+        })
+        comparison.expects(:validates_presence).with { |fields|
+          (fields - [:raw_lhs_value, :raw_rhs_value]).empty?
+        }.returns(false)
+        comparison.valid?
+      end
+
+      test "requires valid types" do
+        comparison = new_comparison({
+          :lhs_type => 'foo', :rhs_type => 'foo'
+        })
+        comparison.stubs(:validates_includes).at_least_once
+        comparison.expects(:validates_includes).with(%w{field integer string}, [:lhs_type, :rhs_type]).returns(false)
+        comparison.valid?
+      end
+
+      test "requires valid operator" do
+        comparison = new_comparison({
+          :operator => 'foo'
+        })
+        comparison.stubs(:validates_includes).at_least_once
+        comparison.expects(:validates_includes).with(%w{equals does_not_equal greater_than less_than}, :operator).returns(false)
+        comparison.valid?
+      end
+
+      test "requires valid lhs_which and rhs_which" do
+        comparison = new_comparison({
+          :raw_lhs_value => 1, :lhs_type => 'field', :lhs_which => 123,
+          :raw_rhs_value => 2, :rhs_type => 'field', :rhs_which => 123
+        })
+        comparison.stubs(:validates_includes).at_least_once
+        comparison.expects(:validates_includes).with([1, 2], :lhs_which).returns(false)
+        comparison.expects(:validates_includes).with([1, 2], :rhs_which).returns(false)
+        comparison.valid?
+      end
+
+      test "value methods return fields if type is field" do
+        comparison = new_comparison({
+          :lhs_type => "field", :raw_lhs_value => 1,
+          :rhs_type => "field", :raw_rhs_value => 2
+        }).save!
+
+        field_1 = stub('field 1')
+        field_2 = stub('field 2')
+        Field.expects(:[]).with(:id => 1).returns(field_1)
+        Field.expects(:[]).with(:id => 2).returns(field_2)
+
+        assert_equal field_1, comparison.lhs_value
+        assert_equal field_2, comparison.rhs_value
+      end
+
+      test "values are coerced to integer when type is integer" do
+        comparison = new_comparison({
+          :lhs_type => "integer", :raw_lhs_value => "123",
+          :rhs_type => "integer", :raw_rhs_value => "123"
+        }).save!
+
+        assert_equal 123, comparison.raw_lhs_value
+        assert_equal 123, comparison.raw_rhs_value
+      end
+
+      test "fields returns lhs field" do
+        comparison = new_comparison({
+          :lhs_type => "field", :raw_lhs_value => 1,
+          :rhs_type => "integer", :raw_rhs_value => 123
+        }).save!
+
+        field = stub("field")
+        Field.expects(:[]).with(:id => 1).returns(field)
+        assert_equal [field], comparison.fields
+      end
+
+      test "fields returns rhs field" do
+        comparison = new_comparison({
+          :lhs_type => "integer", :raw_lhs_value => 123,
+          :rhs_type => "field", :raw_rhs_value => 1,
+        }).save!
+
+        field = stub("field")
+        Field.expects(:[]).with(:id => 1).returns(field)
+        assert_equal [field], comparison.fields
+      end
+
+      test "fields returns two fields" do
+        comparison = new_comparison({
+          :lhs_type => "field", :raw_lhs_value => 1,
+          :rhs_type => "field", :raw_rhs_value => 2
+        }).save!
+
+        field_1 = stub("field 1")
+        field_2 = stub("field 2")
+        Field.expects(:[]).with(:id => 1).returns(field_1)
+        Field.expects(:[]).with(:id => 2).returns(field_2)
+        assert_equal [field_1, field_2], comparison.fields
+      end
+
+      test "fields returns empty array" do
+        comparison = new_comparison({
+          :lhs_type => "integer", :raw_lhs_value => 123,
+          :rhs_type => "integer", :raw_rhs_value => 123,
+        }).save!
+        assert_equal [], comparison.fields
+      end
+
+      test "operator symbol" do
+        comparison = Comparison.new(:operator => 'equals')
+        assert_equal "=", comparison.operator_symbol
+        comparison.operator = "does_not_equal"
+        assert_equal "!=", comparison.operator_symbol
+        comparison.operator = "greater_than"
+        assert_equal ">", comparison.operator_symbol
+        comparison.operator = "less_than"
+        assert_equal "<", comparison.operator_symbol
+      end
+
+      %w{lhs rhs}.each do |name|
+        test "#{name}_label" do
+          resource = stub("resource", :name => "foo")
+          field = stub("field", :name => "ssn", :resource => resource)
+          Field.stubs(:[]).with(:id => 1).returns(field)
+
+          comparison = Comparison.new(:"#{name}_type" => 'field', :"raw_#{name}_value" => 1)
+          assert_equal "ssn (foo)", comparison.send("#{name}_label")
+
+          comparison.send("#{name}_which=", 1)
+          assert_equal %{ssn (foo<span class="sup">1</span>)}, comparison.send("#{name}_label")
+
+          comparison.send("#{name}_which=", 2)
+          assert_equal %{ssn (foo<span class="sup">2</span>)}, comparison.send("#{name}_label")
+
+          comparison.send("#{name}_type=", 'integer')
+          comparison.send("raw_#{name}_value=", 123)
+          assert_equal "123", comparison.send("#{name}_label")
+
+          comparison.send("#{name}_type=", 'string')
+          comparison.send("raw_#{name}_value=", 'foo')
+          assert_equal %{"foo"}, comparison.send("#{name}_label")
+        end
+      end
+
+      test "apply field equality" do
+        comparison = new_comparison({
+          :lhs_type => 'field', :raw_lhs_value => 1, :lhs_which => 1,
+          :rhs_type => 'field', :raw_rhs_value => 1, :rhs_which => 2,
+          :operator => 'equals'
+        }).save!
+
+        field = stub("field", :name => "first_name")
+        Field.stubs(:[]).with(:id => 1).returns(field)
+        dataset = mock('dataset', :opts => {})
+        dataset.expects(:clone).with({:select => [:first_name], :order => [:first_name]}).returns(dataset)
+        dataset.expects(:filter).with(~{:first_name => nil}).returns(dataset)
+        assert_equal dataset, comparison.apply(dataset)
+      end
+
+      test "apply field equality to one side only" do
+        comparison = new_comparison({
+          :lhs_type => 'field', :raw_lhs_value => 1, :lhs_which => 1,
+          :rhs_type => 'field', :raw_rhs_value => 1, :rhs_which => 2,
+          :operator => 'equals'
+        }).save!
+
+        field = stub("field", :name => "first_name")
+        Field.stubs(:[]).with(:id => 1).returns(field)
+        dataset_1 = mock('dataset', :opts => {})
+        dataset_1.expects(:clone).with({:select => [:first_name], :order => [:first_name]}).returns(dataset_1)
+        dataset_1.expects(:filter).with(~{:first_name => nil}).returns(dataset_1)
+        dataset_2 = mock('dataset', :opts => {})
+        dataset_2.expects(:clone).with({:select => [:first_name], :order => [:first_name]}).returns(dataset_2)
+        dataset_2.expects(:filter).with(~{:first_name => nil}).returns(dataset_2)
+
+        assert_equal dataset_1, comparison.apply(dataset_1, 0)
+        assert_equal dataset_2, comparison.apply(dataset_2, 1)
+      end
+
+      test "apply two field equality" do
+        comparison = new_comparison({
+          :lhs_type => 'field', :raw_lhs_value => 1, :lhs_which => 1,
+          :rhs_type => 'field', :raw_rhs_value => 2, :rhs_which => 2,
+          :operator => 'equals'
+        }).save!
+
+        field_1 = stub("field 1", :name => 'ssn_1')
+        field_2 = stub("field 2", :name => 'ssn_2')
+        Field.stubs(:[]).with(:id => 1).returns(field_1)
+        Field.stubs(:[]).with(:id => 2).returns(field_2)
+        dataset = mock('dataset', :opts => {})
+        dataset.expects(:clone).with({:select => [:ssn_1, :ssn_2], :order => [:ssn_1, :ssn_2]}).returns(dataset)
+        dataset.expects(:filter).with(~{:ssn_1 => nil}, ~{:ssn_2 => nil}).returns(dataset)
+        assert_equal dataset, comparison.apply(dataset)
+      end
+
+      test "apply two field equality to one side only" do
+        comparison = new_comparison({
+          :lhs_type => 'field', :raw_lhs_value => 1, :lhs_which => 1,
+          :rhs_type => 'field', :raw_rhs_value => 2, :rhs_which => 2,
+          :operator => 'equals'
+        }).save!
+
+        field_1 = stub("field 1", :name => 'ssn_1')
+        field_2 = stub("field 2", :name => 'ssn_2')
+        Field.stubs(:[]).with(:id => 1).returns(field_1)
+        Field.stubs(:[]).with(:id => 2).returns(field_2)
+        dataset_1 = mock('dataset', :opts => {})
+        dataset_1.expects(:clone).with({:select => [:ssn_1], :order => [:ssn_1]}).returns(dataset_1)
+        dataset_1.expects(:filter).with(~{:ssn_1 => nil}).returns(dataset_1)
+        dataset_2 = mock('dataset', :opts => {})
+        dataset_2.expects(:clone).with({:select => [:ssn_2], :order => [:ssn_2]}).returns(dataset_2)
+        dataset_2.expects(:filter).with(~{:ssn_2 => nil}).returns(dataset_2)
+
+        assert_equal dataset_1, comparison.apply(dataset_1, 0)
+        assert_equal dataset_2, comparison.apply(dataset_2, 1)
+      end
+
+=begin
+      def test_apply_field_inequality_to_single_dataset
+        field = stub("field", :name => 'first_name')
+        Field.stubs(:[]).with(:id => 1).returns(field)
+        comparison = new_comparison({
+          :lhs_type => 'field', :raw_lhs_value => 1, :lhs_which => 1,
+          :rhs_type => 'field', :raw_rhs_value => 1, :rhs_which => 2,
+          :operator => 'does_not_equal'
+        }).save!
+        dataset = mock('dataset', :opts => {})
+        dataset.expects(:clone).with({:select => [:first_name], :order => [:first_name]}).returns(dataset)
+        dataset.expects(:filter).with(~{:first_name => nil}).returns(dataset)
+        assert_equal dataset, comparison.apply(dataset)
+      end
+
+      def test_apply_field_inequality_to_dual_datasets
+        field = stub("field", :name => 'first_name')
+        Field.stubs(:[]).with(:id => 1).returns(field)
+        comparison = new_comparison({
+          :lhs_type => 'field', :raw_lhs_value => 1, :lhs_which => 1,
+          :rhs_type => 'field', :raw_rhs_value => 1, :rhs_which => 2,
+          :operator => 'does_not_equal'
+        }).save!
+        dataset_1 = mock('dataset_1', :opts => {})
+        dataset_1.expects(:clone).with({:select => [:first_name], :order => [:first_name]}).returns(dataset_1)
+        dataset_1.expects(:filter).with(~{:first_name => nil}).returns(dataset_1)
+        dataset_2 = mock('dataset_2', :opts => {})
+        dataset_2.expects(:clone).with({:select => [:first_name], :order => [:first_name]}).returns(dataset_2)
+        dataset_2.expects(:filter).with(~{:first_name => nil}).returns(dataset_2)
+        assert_equal [dataset_1, dataset_2], comparison.apply(dataset_1, dataset_2)
+      end
+=end
+
+      test "apply same row field equality indifferently" do
+        comparison_1 = new_comparison({
+          :lhs_type => 'field', :raw_lhs_value => 1, :lhs_which => 1,
+          :rhs_type => 'field', :raw_rhs_value => 2, :rhs_which => 1,
+          :operator => 'equals'
+        }).save!
+        comparison_2 = new_comparison({
+          :lhs_type => 'field', :raw_lhs_value => 2, :lhs_which => 2,
+          :rhs_type => 'field', :raw_rhs_value => 1, :rhs_which => 2,
+          :operator => 'equals'
+        }).save!
+
+        field_1 = stub("field 1", :name => 'ssn_1')
+        field_2 = stub("field 2", :name => 'ssn_2')
+        Field.stubs(:[]).with(:id => 1).returns(field_1)
+        Field.stubs(:[]).with(:id => 2).returns(field_2)
+        dataset = mock('dataset')
+
+        dataset.expects(:filter).with(sequel_expr(:ssn_1 => :ssn_2)).returns(dataset)
+        assert_equal dataset, comparison_1.apply(dataset)
+
+        dataset.expects(:filter).with(sequel_expr(:ssn_2 => :ssn_1)).returns(dataset)
+        assert_equal dataset, comparison_2.apply(dataset)
+      end
+
+      test "apply same row field equality to one side only" do
+        comparison_1 = new_comparison({
+          :lhs_type => 'field', :raw_lhs_value => 1, :lhs_which => 1,
+          :rhs_type => 'field', :raw_rhs_value => 2, :rhs_which => 1,
+          :operator => 'equals'
+        }).save!
+        comparison_2 = new_comparison({
+          :lhs_type => 'field', :raw_lhs_value => 2, :lhs_which => 2,
+          :rhs_type => 'field', :raw_rhs_value => 1, :rhs_which => 2,
+          :operator => 'equals'
+        }).save!
+
+        field_1 = stub("field 1", :name => 'ssn_1')
+        field_2 = stub("field 2", :name => 'ssn_2')
+        Field.stubs(:[]).with(:id => 1).returns(field_1)
+        Field.stubs(:[]).with(:id => 2).returns(field_2)
+        dataset_1 = mock('dataset')
+        dataset_2 = mock('dataset')
+
+        dataset_1.expects(:filter).with(sequel_expr(:ssn_1 => :ssn_2)).returns(dataset_1)
+        assert_equal dataset_1, comparison_1.apply(dataset_1, 0)
+        dataset_1.expects(:filter).never
+        assert_equal dataset_1, comparison_2.apply(dataset_1, 0)
+
+        dataset_2.expects(:filter).never
+        assert_equal dataset_2, comparison_1.apply(dataset_2, 1)
+        dataset_2.expects(:filter).with(sequel_expr(:ssn_2 => :ssn_1)).returns(dataset_2)
+        assert_equal dataset_2, comparison_2.apply(dataset_2, 1)
+      end
+
+#=begin
+      #def test_apply_field_greater_than_field
+        #field_1 = @resource.fields_dataset[:name => 'first_name']
+        #field_2 = @resource.fields_dataset[:name => 'last_name']
+        #comparison = new_comparison({
+          #:lhs_type => 'field', :raw_lhs_value => field_1.id, :lhs_which => 1,
+          #:rhs_type => 'field', :raw_rhs_value => field_2.id, :rhs_which => 2,
+          #:operator => 'greater_than'
+        #}).save!
+        #dataset = mock('dataset', :opts => {})
+        #dataset.expects(:clone).with({:select => [:first_name, :last_name]}).returns(dataset)
+        #dataset.expects(:filter).with(~{:first_name => nil}, ~{:last_name => nil}).returns(dataset)
+        #assert_equal dataset, comparison.apply(dataset)
+      #end
+#=end
+
+      test "apply does not duplicate selects or orders" do
+        comparison = new_comparison({
+          :lhs_type => 'field', :raw_lhs_value => 1, :lhs_which => 1,
+          :rhs_type => 'field', :raw_rhs_value => 2, :rhs_which => 2,
+          :operator => 'equals'
+        }).save!
+
+        field_1 = stub("field 1", :name => 'ssn_1')
+        field_2 = stub("field 2", :name => 'ssn_2')
+        Field.stubs(:[]).with(:id => 1).returns(field_1)
+        Field.stubs(:[]).with(:id => 2).returns(field_2)
+        dataset = mock('dataset', :opts => { :order => [:ssn_1], :select => [:foo, :ssn_1] })
+        dataset.expects(:clone).with({:select => [:foo, :ssn_1, :ssn_2], :order => [:ssn_1, :ssn_2]}).returns(dataset)
+        dataset.expects(:filter).with(~{:ssn_2 => nil}).returns(dataset)
+        assert_equal dataset, comparison.apply(dataset)
+      end
+
+      test "apply field equals non field indifferently" do
+        comparison_1 = new_comparison({
+          :lhs_type => 'field', :raw_lhs_value => 1, :lhs_which => 1,
+          :rhs_type => 'integer', :raw_rhs_value => 123,
+          :operator => 'equals'
+        }).save!
+        comparison_2 = new_comparison({
+          :lhs_type => 'field', :raw_lhs_value => 2, :lhs_which => 2,
+          :rhs_type => 'integer', :raw_rhs_value => 123,
+          :operator => 'equals'
+        }).save!
+
+        field_1 = stub("field 1", :name => 'ssn_1')
+        field_2 = stub("field 2", :name => 'ssn_2')
+        Field.stubs(:[]).with(:id => 1).returns(field_1)
+        Field.stubs(:[]).with(:id => 2).returns(field_2)
+        dataset = mock('dataset')
+        dataset.expects(:filter).with(sequel_expr({:ssn_1 => 123})).returns(dataset)
+        assert_equal dataset, comparison_1.apply(dataset)
+        dataset.expects(:filter).with(sequel_expr({:ssn_2 => 123})).returns(dataset)
+        assert_equal dataset, comparison_2.apply(dataset)
+      end
+
+      test "apply field equals non field to one side only" do
+        comparison_1 = new_comparison({
+          :lhs_type => 'field', :raw_lhs_value => 1, :lhs_which => 1,
+          :rhs_type => 'integer', :raw_rhs_value => 123,
+          :operator => 'equals'
+        }).save!
+        comparison_2 = new_comparison({
+          :lhs_type => 'field', :raw_lhs_value => 2, :lhs_which => 2,
+          :rhs_type => 'integer', :raw_rhs_value => 123,
+          :operator => 'equals'
+        }).save!
+
+        field_1 = stub("field 1", :name => 'ssn_1')
+        field_2 = stub("field 2", :name => 'ssn_2')
+        Field.stubs(:[]).with(:id => 1).returns(field_1)
+        Field.stubs(:[]).with(:id => 2).returns(field_2)
+        dataset_1 = mock('dataset 1')
+        dataset_2 = mock('dataset 2')
+
+        dataset_1.expects(:filter).with(sequel_expr({:ssn_1 => 123})).returns(dataset_1)
+        assert_equal dataset_1, comparison_1.apply(dataset_1, 0)
+        dataset_1.expects(:filter).never
+        assert_equal dataset_1, comparison_2.apply(dataset_1, 0)
+
+        dataset_2.expects(:filter).never
+        assert_equal dataset_2, comparison_1.apply(dataset_2, 1)
+        dataset_2.expects(:filter).with(sequel_expr({:ssn_2 => 123})).returns(dataset_2)
+        assert_equal dataset_2, comparison_2.apply(dataset_2, 1)
+      end
+
+      test "apply non field equals field" do
+        field = stub("field", :name => 'first_name')
+        Field.stubs(:[]).with(:id => 1).returns(field)
+        comparison = new_comparison({
+          :lhs_type => 'integer', :raw_lhs_value => 123,
+          :rhs_type => 'field', :raw_rhs_value => 1, :rhs_which => 1,
+          :operator => 'equals'
+        }).save!
+        dataset = mock('dataset')
+        dataset.expects(:filter).with(sequel_expr({123 => :first_name})).returns(dataset)
+        assert_equal dataset, comparison.apply(dataset)
+      end
+
+      test "apply field does not equal non field" do
+        field = stub("field", :name => 'first_name')
+        Field.stubs(:[]).with(:id => 1).returns(field)
+        comparison = new_comparison({
+          :lhs_type => 'field', :raw_lhs_value => 1,
+          :rhs_type => 'integer', :raw_rhs_value => 123,
+          :operator => 'does_not_equal'
+        }).save!
+        dataset = mock('dataset')
+        dataset.expects(:filter).with(sequel_expr(~{:first_name => 123})).returns(dataset)
+        assert_equal dataset, comparison.apply(dataset)
+      end
+
+      test "apply non field does not equal field" do
+        field = stub("field", :name => 'first_name')
+        Field.stubs(:[]).with(:id => 1).returns(field)
+        comparison = new_comparison({
+          :lhs_type => 'integer', :raw_lhs_value => 123,
+          :rhs_type => 'field', :raw_rhs_value => 1,
+          :operator => 'does_not_equal'
+        }).save!
+        dataset = mock('dataset')
+        dataset.expects(:filter).with(sequel_expr(~{123 => :first_name})).returns(dataset)
+        assert_equal dataset, comparison.apply(dataset)
+      end
+
+      test "apply field greater than non field" do
+        field = stub("field", :name => 'first_name')
+        Field.stubs(:[]).with(:id => 1).returns(field)
+        comparison = new_comparison({
+          :lhs_type => 'field', :raw_lhs_value => 1,
+          :rhs_type => 'integer', :raw_rhs_value => 123,
+          :operator => 'greater_than'
+        }).save!
+        dataset = mock('dataset')
+        dataset.expects(:filter).with(sequel_expr(:first_name > 123)).returns(dataset)
+        assert_equal dataset, comparison.apply(dataset)
+      end
+
+      test "apply non field greater than field" do
+        field = stub("field", :name => 'first_name')
+        Field.stubs(:[]).with(:id => 1).returns(field)
+        comparison = new_comparison({
+          :lhs_type => 'integer', :raw_lhs_value => 123,
+          :rhs_type => 'field', :raw_rhs_value => 1,
+          :operator => 'greater_than'
+        }).save!
+        dataset = mock('dataset')
+        dataset.expects(:filter).with(sequel_expr(:'>', 123, :first_name)).returns(dataset)
+        assert_equal dataset, comparison.apply(dataset)
+      end
+
+      test "apply field less than non field" do
+        field = stub("field", :name => 'first_name')
+        Field.stubs(:[]).with(:id => 1).returns(field)
+        comparison = new_comparison({
+          :lhs_type => 'field', :raw_lhs_value => 1,
+          :rhs_type => 'integer', :raw_rhs_value => 123,
+          :operator => 'less_than'
+        }).save!
+        dataset = mock('dataset')
+        dataset.expects(:filter).with(sequel_expr(:first_name < 123)).returns(dataset)
+        assert_equal dataset, comparison.apply(dataset)
+      end
+
+      test "apply non field less than field" do
+        field = stub("field", :name => 'first_name')
+        Field.stubs(:[]).with(:id => 1).returns(field)
+        comparison = new_comparison({
+          :lhs_type => 'integer', :raw_lhs_value => 123,
+          :rhs_type => 'field', :raw_rhs_value => 1,
+          :operator => 'less_than'
+        }).save!
+        dataset = mock('dataset')
+        dataset.expects(:filter).with(Sequel::SQL::BooleanExpression.new(:'<', 123, :first_name)).returns(dataset)
+        assert_equal dataset, comparison.apply(dataset)
+      end
+
+      test "apply non field equal non field" do
+        comparison = new_comparison({
+          :lhs_type => 'integer', :raw_lhs_value => 123,
+          :rhs_type => 'integer', :raw_rhs_value => 123,
+          :operator => 'equals'
+        }).save!
+        dataset = mock('dataset')
+        dataset.expects(:filter).with(sequel_expr(123 => 123)).returns(dataset)
+        assert_equal dataset, comparison.apply(dataset)
+      end
+
+      test "apply non field equal non field regardless of side" do
+        comparison = new_comparison({
+          :lhs_type => 'integer', :raw_lhs_value => 123,
+          :rhs_type => 'integer', :raw_rhs_value => 123,
+          :operator => 'equals'
+        }).save!
+        dataset_1 = mock('dataset 1')
+        dataset_2 = mock('dataset 2')
+
+        dataset_1.expects(:filter).with(sequel_expr(123 => 123)).returns(dataset_1)
+        assert_equal dataset_1, comparison.apply(dataset_1, 0)
+        dataset_2.expects(:filter).with(sequel_expr(123 => 123)).returns(dataset_2)
+        assert_equal dataset_2, comparison.apply(dataset_2, 1)
+      end
+
+      test "blocking?" do
+        field = stub("field", :name => 'first_name') {
+          stubs(:[]).with(:type).returns('string')
+        }
+        Field.stubs(:[]).with(:id => 1).returns(field)
+        comparison = new_comparison({
+          :lhs_type => 'field', :raw_lhs_value => 1, :lhs_which => 1,
+          :rhs_type => 'field', :raw_rhs_value => 1, :rhs_which => 2,
+          :operator => 'equals'
+        }).save!
+        assert !comparison.blocking?
+      end
+
+      test "cross_match?" do
+        field_1 = stub("field 1", :id => 1, :name => 'ssn_1', :resource_id => 1) {
+          stubs(:[]).with(:type).returns('string')
+        }
+        Field.stubs(:[]).with(:id => 1).returns(field_1)
+        field_2 = stub("field 2", :id => 2, :name => 'ssn_2', :resource_id => 1) {
+          stubs(:[]).with(:type).returns('string')
+        }
+        Field.stubs(:[]).with(:id => 2).returns(field_2)
+        comparison = new_comparison({
+          :lhs_type => 'field', :raw_lhs_value => 1, :lhs_which => 1,
+          :rhs_type => 'field', :raw_rhs_value => 2, :rhs_which => 2,
+          :operator => 'equals'
+        }).save!
+        assert comparison.cross_match?
+      end
+
+      test "does not allow two fields of different types" do
+        field_1 = stub("field 1", :name => 'first_name') {
+          stubs(:[]).with(:type).returns('string')
+        }
+        Field.stubs(:[]).with(:id => 1).returns(field_1)
+        field_2 = stub("field 2", :name => 'age') {
+          stubs(:[]).with(:type).returns('integer')
+        }
+        Field.stubs(:[]).with(:id => 2).returns(field_2)
+        comparison = new_comparison({
+          :lhs_type => 'field', :raw_lhs_value => 1, :lhs_which => 1,
+          :rhs_type => 'field', :raw_rhs_value => 2, :rhs_which => 2,
+          :operator => 'equals'
+        })
+        assert !comparison.valid?, "Comparison should have been invalid"
+      end
+
+      test "does not allow non-equality comparisons for fields" do
+        field = stub("field", :name => 'first_name') { stubs(:[]).with(:type).returns('string') }
+        Field.stubs(:[]).with(:id => 1).returns(field)
+        comparison = new_comparison({
+          :lhs_type => 'field', :raw_lhs_value => 1, :lhs_which => 1,
+          :rhs_type => 'field', :raw_rhs_value => 1, :rhs_which => 2,
+          :operator => 'greater_than'
+        })
+        assert !comparison.valid?, "Comparison should have been invalid"
+      end
+    end
+  end
+end