de 0.0.1

data/test/de_boolean_not_test.rb

@@ -0,0 +1,39 @@
+require 'test/unit'
+require 'de'
+require 'de/boolean'
+
+class DeBooleanNotTest < Test::Unit::TestCase
+
+  def test_constructor
+    assert_nothing_raised(De::Error::AbstractClassObjectCreationError) { De::Boolean::Not.new }
+    assert_nothing_raised(De::Error::AbstractClassObjectCreationError) { De::Boolean::Not.new(De::Boolean::Operand.new('some name', true)) }
+  end
+
+  def test_add
+    not1 = De::Boolean::Not.new
+    operand1 = De::Boolean::Operand.new('some name', true)
+
+    not1 << operand1
+    assert_equal(2, not1.size)
+
+    not2 = De::Boolean::Not.new
+    or1 = De::Boolean::Or.new
+    not2 << or1
+    assert_equal(1, or1.size)
+
+    assert_raise(De::Error::ArgumentNumerError) { not2 << operand1 }
+  end
+
+  def test_evaluate
+    not1 = De::Boolean::Not.new
+    operand_true1 = De::Boolean::Operand.new('some name', true)
+    operand_false1 = De::Boolean::Operand.new('third name', false)
+
+    not1 << operand_true1
+    assert_equal(false, not1.evaluate)
+
+    not2 = De::Boolean::Not.new(operand_false1)
+    assert_equal(true, not2.evaluate)
+  end
+
+end

data/test/de_boolean_operand_test.rb

@@ -0,0 +1,30 @@
+require 'test/unit'
+require 'de'
+require 'de/boolean'
+
+class DeBooleanOperandTest < Test::Unit::TestCase
+
+  def test_constructor
+    assert_nothing_raised(De::Error::AbstractClassObjectCreationError) { De::Boolean::Operand.new('first', true) }
+  end
+
+  def test_valid?
+    operand1 = De::Boolean::Operand.new('first', true)
+    operand2 = De::Boolean::Operand.new('second', false)
+    operand3 = De::Boolean::Operand.new('third', 'some string')
+
+    assert_equal(true, operand1.valid?)
+    assert_equal(true, operand2.valid?)
+    assert_equal(false, operand3.valid?)
+  end
+
+  def test_evaluate
+    operand1 = De::Boolean::Operand.new('first', true)
+    operand2 = De::Boolean::Operand.new('second', false)
+    operand3 = De::Boolean::Operand.new('third', 'some string')
+
+    assert_equal(true, operand1.evaluate)
+    assert_equal(false, operand2.evaluate)
+    assert_raise(De::Error::InvalidExpressionError, "Invalid expression") { operand3.evaluate }
+  end
+end

data/test/de_boolean_operator_test.rb

@@ -0,0 +1,34 @@
+require 'test/unit'
+require 'de'
+require 'de/boolean'
+
+class DeBooleanOperatorTest < Test::Unit::TestCase
+
+  class SomeOperator < De::Boolean::BooleanOperator; end
+  class SomeOperator < De::Boolean::BooleanOperator; end
+  class NotSuitableOperand < De::Operand; end
+
+  def test_constructor
+    assert_raise(De::Error::AbstractClassObjectCreationError) { De::Boolean::BooleanOperator.new('first') }
+    assert_nothing_raised(De::Error::AbstractClassObjectCreationError) { SomeOperator.new('some name') }
+  end
+
+  def test_add
+    operator = SomeOperator.new('first')
+    operator2 = SomeOperator.new('second')
+    operand = De::Boolean::Operand.new('third', true)
+    not_suitable_operand = NotSuitableOperand.new('four', true)
+
+    assert_nothing_raised(De::Error::TypeError) {
+      operator << operator2
+      assert_equal(2, operator.size)
+
+      operator << operand
+      assert_equal(3, operator.size)
+    }
+
+    assert_raise(De::Error::TypeError) { operator << not_suitable_operand }
+
+  end
+
+end

data/test/de_boolean_or_test.rb

@@ -0,0 +1,51 @@
+require 'test/unit'
+require 'de'
+require 'de/boolean'
+
+class DeBooleanOrTest < Test::Unit::TestCase
+
+  def test_constructor
+    assert_nothing_raised(De::Error::AbstractClassObjectCreationError) { De::Boolean::Or.new }
+    assert_nothing_raised(De::Error::AbstractClassObjectCreationError) { De::Boolean::Or.new([De::Boolean::Operand.new('some name', true)]) }
+  end
+
+  def test_add
+    or1 = De::Boolean::Or.new
+    operand1 = De::Boolean::Operand.new('some name', true)
+
+    or1 << operand1
+    assert_equal(2, or1.size)
+
+    or2 = De::Boolean::Or.new
+    or1 << or2
+    assert_equal(3, or1.size)
+  end
+
+  def test_evaluate
+    or1 = De::Boolean::Or.new
+    operand_true1 = De::Boolean::Operand.new('some name', true)
+    operand_true2 = De::Boolean::Operand.new('second name', true)
+    operand_false1 = De::Boolean::Operand.new('third name', false)
+    operand_false2 = De::Boolean::Operand.new('fourth name', false)
+
+    or1 << operand_true1
+    or1 << operand_true2
+    assert_equal(true, or1.evaluate)
+
+    or2 = De::Boolean::Or.new
+    or2 << operand_true1
+    or2 << operand_false1
+    assert_equal(true, or2.evaluate)
+
+    or3 = De::Boolean::Or.new([operand_false1, operand_false2])
+    assert_equal(false, or3.evaluate)
+
+    or1 << or3
+    assert_equal(true, or1.evaluate)
+
+    or4 = De::Boolean::Or.new([operand_true1, operand_true2])
+    or1 << or4
+    assert_equal(true, or1.evaluate)
+  end
+
+end

data/test/de_expression_test.rb

@@ -0,0 +1,35 @@
+require 'test/unit'
+require 'de'
+
+class DeExpressionTest < Test::Unit::TestCase
+  class SomeOperator < De::Operator; end
+  class SomeOperand < De::Operand; end
+
+  def setup
+    @expression = De::Expression.new('some name', 'some content')
+  end
+
+  def test_expression_create
+    assert_equal('some name', @expression.name)
+    assert_equal('some content', @expression.content)
+  end
+
+  def test_add
+    operator = SomeOperator.new('some operator')
+    assert_nothing_raised(De::Error::TypeError) { @expression << operator }
+    assert_equal(@expression.children[0], operator)
+
+    operand = SomeOperand.new('some operand', 'operand content')
+    assert_nothing_raised(De::Error::TypeError) { @expression << operand }
+    assert_equal(@expression.children[1], operand)
+
+    obj = Object.new
+    assert_raise(De::Error::TypeError, "Cannot add object to expression") { @expression << obj }
+    assert_equal(3, @expression.size)
+  end
+
+  def test_valid?
+    assert_raise(De::Error::MethodShouldBeOverridenByExtendingClassError, "Cannot add object to expression") { @expression.valid? }
+  end
+  
+end

data/test/de_operand_test.rb

@@ -0,0 +1,29 @@
+require 'test/unit'
+require 'de'
+
+class DeOperandTest < Test::Unit::TestCase
+
+  class SomeOperand < De::Operand; end
+  
+  def test_constructor
+    assert_raise(De::Error::AbstractClassObjectCreationError, "Cannot create operator object") { De::Operand.new('some name', 'some value') }
+
+    assert_nothing_raised(De::Error::AbstractClassObjectCreationError) {
+      operand =  SomeOperand.new('some name', 'some value')
+      assert_equal('some name', operand.name)
+      assert_equal('some value', operand.content)
+    }
+  end
+
+  def test_add
+    operand =  SomeOperand.new('some name', 'some value')
+    operand2 =  SomeOperand.new('another name', 'another value')
+
+    assert_raise(De::Error::TypeError, "Cannot add child to operand") { operand << operand2 }
+  end
+
+  def test_evaluate
+    operand =  SomeOperand.new('some name', 'some value')
+    assert_raise(De::Error::MethodShouldBeOverridenByExtendingClassError, "evlauate method should raise Exception") { operand.evaluate }
+  end
+end

data/test/de_operator_test.rb

@@ -0,0 +1,48 @@
+require 'test/unit'
+require 'de'
+
+class DeOperatorTest < Test::Unit::TestCase
+
+  class SomeOperator < De::Operator; end
+  class SomeValidOperand < De::Operand;
+    def valid?
+      true
+    end
+  end
+  class SomeInvalidOperand < De::Operand;
+    def valid?
+      false
+    end
+  end
+
+  def test_constructor
+    assert_raise(De::Error::AbstractClassObjectCreationError, "Cannot create operator object") { De::Operator.new('some name') }
+
+    assert_nothing_raised(De::Error::AbstractClassObjectCreationError) {
+      operator =  SomeOperator.new('some name')
+      assert_equal('some name', operator.name)
+      assert_equal(1, operator.size, 'No children noDes should be adDed')
+
+      operator2 = SomeOperator.new('another name', [operator])
+      assert_equal(2, operator2.size, 'First operator should be adDed as child to second one')
+      assert_equal(operator, operator2.children[0], 'First operator should be adDed as child to second one')
+    }
+
+    assert_raise(De::Error::TypeError, "Cannot create operator object") { SomeOperator.new('some name', 10) }
+  end
+
+  def test_valid?
+
+    operator =  SomeOperator.new('some name')
+    assert_equal(false, operator.valid?)
+
+    operand = SomeValidOperand.new('another name', 5)
+    operator << operand
+    assert_equal(true, operator.valid?)
+
+    operand2 = SomeInvalidOperand.new('third name', 7)
+    operator << operand2
+    assert_equal(false, operator.valid?)
+
+  end
+end

data/test/de_sunspot_solr_and_test.rb

@@ -0,0 +1,113 @@
+require 'test/unit'
+require 'de'
+require 'de/sunspot_solr'
+
+class DeSunspotSolrAndTest < Test::Unit::TestCase
+  include De::SunspotSolr
+
+  def test_constructor
+    assert_nothing_raised(De::Error::AbstractClassObjectCreationError) { And.new }
+    assert_nothing_raised(De::Error::AbstractClassObjectCreationError) { And.new([SunspotOperand.new('some name', :client_id, :equal_to, 42)]) }
+  end
+
+  def test_equal
+    a = And.new
+    b = And.new
+    c = Or.new
+    assert(a == b)
+    assert(a != c)
+
+    d = And.new([EqualTo.new(:client_id, 42), GreaterThan.new(:price, 200)])
+    e = And.new([EqualTo.new(:client_id, 42), GreaterThan.new(:price, 200)])
+    f = And.new([GreaterThan.new(:price, 200), EqualTo.new(:client_id, 42)])
+    g = And.new([GreaterThan.new(:price, 200), EqualTo.new(:client_id, 42), Without.new(:products_group_id, 188)])
+    assert(d == e)
+    assert(d == f)
+    assert(e != g)
+
+    a << d
+    b << f
+    assert(a == b)
+
+    h = And.new
+    h << g
+    assert(a != h)
+  end
+
+  def test_add
+    and1 = And.new
+    operand1 = SunspotOperand.new('some name', :client_id, :eaual_to, 42)
+
+    result = and1 << operand1
+    assert_equal(2, and1.size)
+    assert_equal(operand1, result)
+
+    operand2 = SunspotOperand.new('some name 2', :client_id, :eaual_to, 42)
+    result = and1 << operand2
+    assert_equal(2, and1.size)
+    assert(result === operand1)
+
+    and2 = And.new
+    and1 << and2
+    assert_equal(3, and1.size)
+
+    and3 = And.new
+    and4 = And.new([EqualTo.new(:client_id, 42), GreaterThan.new(:price, 200)])
+    and5 = And.new([GreaterThan.new(:price, 200), EqualTo.new(:client_id, 42)])
+    or1 = Or.new([EqualTo.new(:client_id, 42), GreaterThan.new(:price, 200)])
+
+    and3 << and4
+    assert_equal(4, and3.size)
+    assert_equal(1, and3.children.size)
+    assert_equal(and4, and3.first_child)
+
+    result = and3 << and5
+    assert(and4 === result)
+    assert_equal(4, and3.size)
+    assert_equal(1, and3.children.size)
+    assert_equal(and4, and3.first_child)
+    
+    result = and3 << or1
+    assert(or1 === result)
+    assert_equal(7, and3.size)
+    assert_equal(2, and3.children.size)
+    assert_equal(or1, and3.children[1])
+  end
+
+  def test_evaluate
+    and1 = And.new
+    client_operand = EqualTo.new(:client_id, 42)
+    name_operand = SunspotOperand.new('name', :name, :equal_to, 'some name')
+    price_operand = SunspotOperand.new('price', :price, :greater_than, 100)
+    name2_operand = SunspotOperand.new('name2', :name, :equal_to, 'some name 2')
+    search = Search.new('search_product', 'Product', {
+      :properties => {
+        :client_id => {:type => :integer, :dynamic => false},
+        :name => {:type => :string, :dynamic => false},
+        :price => {:type => :integer, :dynamic => true}
+      },
+      :dynamics => {:integer => :int_params, :string => :string_params, :time => :time_params, :text => :string_params}
+    })
+
+
+    and1 << client_operand
+    and1 << name_operand
+    assert_raise (De::Error::InvalidExpressionError) { and1.evaluate }
+
+    search << and1
+    assert_nothing_raised(De::Error::InvalidExpressionError) {
+      assert_equal("all_of do with(:client_id).equal_to(42) with(:name).equal_to('some name') end", and1.evaluate.gsub(/\s+/, ' '))
+    }
+    
+    and1 << price_operand
+    assert_equal("all_of do with(:client_id).equal_to(42) with(:name).equal_to('some name') dynamic(:int_params) do with(:price).greater_than(100) end end", and1.evaluate.gsub(/\s+/, ' '))
+
+    and2 = And.new
+    and2 << name2_operand
+    and1 << and2
+    assert_equal("all_of do with(:name).equal_to('some name 2') end", and2.evaluate.gsub(/\s+/, ' '))
+    assert_equal("all_of do with(:client_id).equal_to(42) with(:name).equal_to('some name') dynamic(:int_params) do with(:price).greater_than(100) end all_of do with(:name).equal_to('some name 2') end end", and1.evaluate.gsub(/\s+/, ' '))
+
+  end
+
+end

data/test/de_sunspot_solr_not_test.rb

@@ -0,0 +1,49 @@
+require 'test/unit'
+require 'de'
+require 'de/sunspot_solr'
+
+class DeSunspotSolrNotTest < Test::Unit::TestCase
+  include De::SunspotSolr
+
+  def test_constructor
+    assert_nothing_raised(De::Error::AbstractClassObjectCreationError) { Not.new }
+    assert_nothing_raised(De::Error::AbstractClassObjectCreationError) { Not.new(SunspotOperand.new('some name', :client_id, :equal_to, 42)) }
+  end
+
+  def test_add
+    not1 = Not.new
+    operand1 = SunspotOperand.new('some name', :client_id, :equal_to, 42)
+
+    not1 << operand1
+    assert_equal(2, not1.size)
+
+    or1 = Or.new
+    operand2 = EqualTo.new(:client_id, 42)
+
+    assert_raise(De::Error::TypeError) { not1 << or1 }
+    assert_raise(De::Error::ArgumentNumerError) { not1 << operand2 }
+  end
+
+  def test_evaluate
+    not1 = Not.new(EqualTo.new(:client_id, 42))
+    not2 = Not.new(GreaterThanOrEqual.new(:price, 100))
+    search = Search.new('search_product', 'Product', {
+      :properties => {
+        :client_id => {:type => :integer, :dynamic => false},
+        :name => {:type => :string, :dynamic => false},
+        :price => {:type => :integer, :dynamic => true}
+      },
+      :dynamics => {:integer => :int_params, :string => :string_params, :time => :time_params, :text => :string_params}
+    })
+
+
+    search << not1
+    assert_nothing_raised(De::Error::InvalidExpressionError) {
+      assert_equal("without(:client_id).equal_to(42)", not1.evaluate.gsub(/\s+/, ' '))
+    }
+    
+    search << not2
+    assert_equal("dynamic(:int_params) do any_of do without(:price).greater_than(100) without(:price, 100) end end", not2.evaluate.gsub(/\s+/, ' '))
+  end
+
+end

data/test/de_sunspot_solr_or_test.rb

@@ -0,0 +1,61 @@
+require 'test/unit'
+require 'de'
+require 'de/sunspot_solr'
+
+class DeSunspotSolrOrTest < Test::Unit::TestCase
+  include De::SunspotSolr
+  
+  def test_constructor
+    assert_nothing_raised(De::Error::AbstractClassObjectCreationError) { Or.new }
+    assert_nothing_raised(De::Error::AbstractClassObjectCreationError) { Or.new([SunspotOperand.new('some name', :client_id, :equal_to, 42)]) }
+  end
+
+  def test_add
+    or1 = Or.new
+    operand1 = SunspotOperand.new('some name', :client_id, :equal_to, 42)
+
+    or1 << operand1
+    assert_equal(2, or1.size)
+
+    or2 = Or.new
+    or1 << or2
+    assert_equal(3, or1.size)
+  end
+
+  def test_evaluate
+    or1 = Or.new
+    client_operand = EqualTo.new(:client_id, 42)
+    name_operand = SunspotOperand.new('name', :name, :equal_to, 'some name')
+    price_operand = SunspotOperand.new('price', :price, :greater_than, 100)
+    name2_operand = SunspotOperand.new('name2', :name, :equal_to, 'some name 2')
+    search = Search.new('search_product', 'Product', {
+      :properties => {
+        :client_id => {:type => :integer, :dynamic => false},
+        :name => {:type => :string, :dynamic => false},
+        :price => {:type => :integer, :dynamic => true}
+      },
+      :dynamics => {:integer => :int_params, :string => :string_params, :time => :time_params, :text => :string_params}
+    })
+
+
+    or1 << client_operand
+    or1 << name_operand
+    assert_raise (De::Error::InvalidExpressionError) { or1.evaluate }
+
+    search << or1
+    assert_nothing_raised(De::Error::InvalidExpressionError) {
+      assert_equal("any_of do with(:client_id).equal_to(42) with(:name).equal_to('some name') end", or1.evaluate.gsub(/\s+/, ' '))
+    }
+    
+    or1 << price_operand
+    assert_equal("any_of do with(:client_id).equal_to(42) with(:name).equal_to('some name') dynamic(:int_params) do with(:price).greater_than(100) end end", or1.evaluate.gsub(/\s+/, ' '))
+
+    and1 = And.new
+    and1 << name2_operand
+    or1 << and1
+    assert_equal("all_of do with(:name).equal_to('some name 2') end", and1.evaluate.gsub(/\s+/, ' '))
+    assert_equal("any_of do with(:client_id).equal_to(42) with(:name).equal_to('some name') dynamic(:int_params) do with(:price).greater_than(100) end all_of do with(:name).equal_to('some name 2') end end", or1.evaluate.gsub(/\s+/, ' '))
+
+  end
+
+end