hayadentaku 3.5.7

data/spec/ast/abs_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/abs'
+require 'dentaku'
+
+describe 'Dentaku::AST::Function::Abs' do
+  it 'returns the absolute value of number' do
+    result = Dentaku('ABS(-4.2)')
+    expect(result).to eq(4.2)
+  end
+
+  it 'returns the correct value for positive number' do
+    result = Dentaku('ABS(1.3)')
+    expect(result).to eq(1.3)
+  end
+
+  it 'returns the correct value for zero' do
+    result = Dentaku('ABS(0)')
+    expect(result).to eq(0)
+  end
+
+  context 'checking errors' do
+    it 'raises an error if argument is not numeric' do
+      expect { Dentaku!("ABS(2020-1-1)") }.to raise_error(Dentaku::ArgumentError)
+    end
+  end
+end

data/spec/ast/addition_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+require 'dentaku/ast/arithmetic'
+
+require 'dentaku/token'
+
+describe Dentaku::AST::Addition do
+  let(:five) { Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, 5) }
+  let(:six)  { Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, 6) }
+
+  let(:t)    { Dentaku::AST::Numeric.new Dentaku::Token.new(:logical, true) }
+
+  it 'allows access to its sub-trees' do
+    node = described_class.new(five, six)
+    expect(node.left).to eq(five)
+    expect(node.right).to eq(six)
+  end
+
+  it 'performs addition' do
+    node = described_class.new(five, six)
+    expect(node.value).to eq(11)
+  end
+
+  it 'requires operands that respond to +' do
+    expect {
+      described_class.new(five, t)
+    }.to raise_error(Dentaku::NodeError, /requires operands/)
+
+    expression = Dentaku::AST::Multiplication.new(five, five)
+    group = Dentaku::AST::Grouping.new(expression)
+
+    expect {
+      described_class.new(group, five)
+    }.not_to raise_error
+  end
+
+  it 'allows operands that respond to addition' do
+    # Sample struct that has a custom definition for addition
+    Addable = Struct.new(:value) do
+      def +(other)
+        case other
+        when Addable
+          value + other.value
+        when Numeric
+          value + other
+        end
+      end
+    end
+
+    operand_five = Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, Addable.new(5))
+    operand_six = Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, Addable.new(6))
+
+    expect {
+      described_class.new(operand_five, operand_six).value
+    }.not_to raise_error
+
+    expect {
+      described_class.new(operand_five, six).value
+    }.not_to raise_error
+  end
+
+  it 'does not try to parse nested string as date' do
+    a = ['2017-01-01', '2017-01-02']
+    b = ['2017-01-01']
+
+    expect(Dentaku('a + b', a: a, b: b)).to eq(['2017-01-01', '2017-01-02', '2017-01-01'])
+  end
+end

data/spec/ast/all_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/all'
+require 'dentaku'
+
+describe Dentaku::AST::All do
+  let(:calculator) { Dentaku::Calculator.new }
+
+  it 'performs ALL operation' do
+    result = Dentaku('ALL(vals, val, val > 1)', vals: [1, 2, 3])
+    expect(result).to eq(false)
+  end
+
+  it 'works with a single value if needed for some reason' do
+    result = Dentaku('ALL(vals, val, val > 1)', vals: 1)
+    expect(result).to eq(false)
+
+    result = Dentaku('ALL(vals, val, val > 1)', vals: 2)
+    expect(result).to eq(true)
+  end
+
+  it 'raises argument error if a string is passed as identifier' do
+    expect { calculator.evaluate!('ALL({1, 2, 3}, "val", val % 2 == 0)') }.to raise_error(
+      Dentaku::ParseError, 'ALL() requires second argument to be an identifier'
+    )
+  end
+
+  it 'treats missing keys in hashes as NULL in permissive mode' do
+    expect(
+      calculator.evaluate('ALL(items, item, item.value)', items: [{value: 1}, {}])
+    ).to be_falsy
+  end
+
+  it 'raises an error if accessing a missing key in a hash in strict mode' do
+    expect {
+      calculator.evaluate!('ALL(items, item, item.value)', items: [{value: 1}, {}])
+    }.to raise_error(Dentaku::UnboundVariableError)
+  end
+end

data/spec/ast/and_function_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'dentaku'
+require 'dentaku/ast/functions/and'
+
+describe 'Dentaku::AST::And' do
+  let(:calculator) { Dentaku::Calculator.new }
+
+  it 'returns false if any of the arguments is false' do
+    result = Dentaku('AND(1 = 1, 0 = 1)')
+    expect(result).to eq(false)
+  end
+
+  it 'supports nested expressions' do
+    result = Dentaku('AND(y = 1, x = 1)', x: 1, y: 2)
+    expect(result).to eq(false)
+  end
+
+  it 'returns true if all of the arguments are true' do
+    result = Dentaku('AND(1 = 1, "2" = "2", true = true, true)')
+    expect(result).to eq(true)
+  end
+
+  it 'returns true if all nested AND functions return true' do
+    result = Dentaku('AND(AND(1 = 1), AND(true != false, AND(true)))')
+    expect(result).to eq(true)
+  end
+
+  it 'raises an error if no arguments are passed' do
+    expect { calculator.evaluate!('AND()') }.to raise_error(Dentaku::ArgumentError)
+  end
+
+  it 'raises an error if a non logical argument is passed' do
+    expect { calculator.evaluate!('AND("r")') }.to raise_error(Dentaku::ArgumentError)
+  end
+end

data/spec/ast/and_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'dentaku/ast/combinators'
+
+require 'dentaku/token'
+
+describe Dentaku::AST::And do
+  let(:t) { Dentaku::AST::Logical.new Dentaku::Token.new(:logical, true)  }
+  let(:f) { Dentaku::AST::Logical.new Dentaku::Token.new(:logical, false) }
+
+  let(:five) { Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, 5) }
+
+  it 'performs logical AND' do
+    node = described_class.new(t, f)
+    expect(node.value).to eq(false)
+  end
+
+  it 'requires logical operands' do
+    expect {
+      described_class.new(t, five)
+    }.to raise_error(Dentaku::NodeError, /requires logical operands/)
+
+    expression = Dentaku::AST::LessThanOrEqual.new(five, five)
+    expect {
+      described_class.new(t, expression)
+    }.not_to raise_error
+
+    expression = Dentaku::AST::Or.new(t, f)
+    expect {
+      described_class.new(t, expression)
+    }.not_to raise_error
+  end
+end

data/spec/ast/any_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/any'
+require 'dentaku'
+
+describe Dentaku::AST::Any do
+  let(:calculator) { Dentaku::Calculator.new }
+
+  it 'performs ANY operation' do
+    result = Dentaku('ANY(vals, val, val > 1)', vals: [1, 2, 3])
+    expect(result).to eq(true)
+  end
+
+  it 'works with a single value if needed for some reason' do
+    result = Dentaku('ANY(vals, val, val > 1)', vals: 1)
+    expect(result).to eq(false)
+
+    result = Dentaku('ANY(vals, val, val > 1)', vals: 2)
+    expect(result).to eq(true)
+  end
+
+  it 'raises argument error if a string is passed as identifier' do
+    expect { calculator.evaluate!('ANY({1, 2, 3}, "val", val % 2 == 0)') }.to raise_error(Dentaku::ParseError)
+  end
+
+  it 'treats missing keys in hashes as NULL in permissive mode' do
+    expect(
+      calculator.evaluate('ANY(items, item, item.value)', items: [{value: 1}, {}])
+    ).to be_truthy
+  end
+
+  it 'raises an error if accessing a missing key in a hash in strict mode' do
+    expect {
+      calculator.evaluate!('ANY(items, item, item.value)', items: [{}, {value: 1}])
+    }.to raise_error(Dentaku::UnboundVariableError)
+  end
+end

data/spec/ast/arithmetic_spec.rb

@@ -0,0 +1,147 @@
+require 'spec_helper'
+require 'dentaku/ast/arithmetic'
+require 'dentaku'
+
+describe Dentaku::AST::Arithmetic do
+  let(:one)  { Dentaku::AST::Numeric.new(Dentaku::Token.new(:numeric, 1)) }
+  let(:two)  { Dentaku::AST::Numeric.new(Dentaku::Token.new(:numeric, 2)) }
+  let(:x)    { Dentaku::AST::Identifier.new(Dentaku::Token.new(:identifier, 'x')) }
+  let(:y)    { Dentaku::AST::Identifier.new(Dentaku::Token.new(:identifier, 'y')) }
+  let(:ctx)  { {'x' => 1, 'y' => 2} }
+  let(:date) { Dentaku::AST::DateTime.new(Dentaku::Token.new(:datetime, DateTime.new(2020, 4, 16))) }
+
+  it 'performs an arithmetic operation with numeric operands' do
+    expect(add(one, two)).to eq(3)
+    expect(sub(one, two)).to eq(-1)
+    expect(mul(one, two)).to eq(2)
+    expect(div(one, two)).to eq(0.5)
+    expect(neg(one)).to eq(-1)
+  end
+
+  it 'performs an arithmetic operation with one numeric operand and one string operand' do
+    expect(add(one, x)).to eq(2)
+    expect(sub(one, x)).to eq(0)
+    expect(mul(one, x)).to eq(1)
+    expect(div(one, x)).to eq(1)
+
+    expect(add(y, two)).to eq(4)
+    expect(sub(y, two)).to eq(0)
+    expect(mul(y, two)).to eq(4)
+    expect(div(y, two)).to eq(1)
+  end
+
+  it 'performs an arithmetic operation with string operands' do
+    expect(add(x, y)).to eq(3)
+    expect(sub(x, y)).to eq(-1)
+    expect(mul(x, y)).to eq(2)
+    expect(div(x, y)).to eq(0.5)
+    expect(neg(x)).to eq(-1)
+  end
+
+  it 'correctly parses string operands to numeric values' do
+    expect(add(x, one, 'x' => '1')).to eq(2)
+    expect(add(x, one, 'x' => '1.1')).to eq(2.1)
+    expect(add(x, one, 'x' => '.1')).to eq(1.1)
+    expect { add(x, one, 'x' => 'invalid') }.to raise_error(Dentaku::ArgumentError)
+    expect { add(x, one, 'x' => '') }.to raise_error(Dentaku::ArgumentError)
+
+    int_one = Dentaku::AST::Numeric.new(Dentaku::Token.new(:numeric, "1"))
+    int_neg_one = Dentaku::AST::Numeric.new(Dentaku::Token.new(:numeric, "-1"))
+    decimal_one = Dentaku::AST::Numeric.new(Dentaku::Token.new(:numeric, "1.0"))
+    decimal_neg_one = Dentaku::AST::Numeric.new(Dentaku::Token.new(:numeric, "-1.0"))
+
+    [int_one, int_neg_one].permutation(2).each do |(left, right)|
+      expect(add(left, right).class).to eq(Integer)
+    end
+
+    [decimal_one, decimal_neg_one].each do |left|
+      [int_one, int_neg_one, decimal_one, decimal_neg_one].each do |right|
+        expect(add(left, right).class).to eq(BigDecimal)
+      end
+    end
+  end
+
+  it 'performs arithmetic on arrays' do
+    expect(add(x, y, 'x' => [1], 'y' => [2])).to eq([1, 2])
+    expect(sub(x, y, 'x' => [1], 'y' => [2])).to eq([1])
+  end
+
+  it 'performs date arithmetic' do
+    expect(add(date, one)).to eq(DateTime.new(2020, 4, 17))
+    expect(sub(date, one)).to eq(DateTime.new(2020, 4, 15))
+  end
+
+  it 'performs arithmetic on object which implements arithmetic' do
+    CanHazMath = Struct.new(:value) do
+      extend Forwardable
+
+      def_delegators :value, :zero?
+
+      def coerce(other)
+        case other
+        when Numeric
+          [other, value]
+        else
+          super
+        end
+      end
+
+      [:+, :-, :/, :*].each do |operand|
+        define_method(operand) do |other|
+          case other
+          when CanHazMath
+            value.public_send(operand, other.value)
+          when Numeric
+            value.public_send(operand, other)
+          end
+        end
+      end
+    end
+
+    op_one = CanHazMath.new(1)
+    op_two = CanHazMath.new(2)
+
+    [op_two, two].each do |left|
+      [op_one, one].each do |right|
+        expect(add(x, y, 'x' => left, 'y' => right)).to eq(3)
+        expect(sub(x, y, 'x' => left, 'y' => right)).to eq(1)
+        expect(mul(x, y, 'x' => left, 'y' => right)).to eq(2)
+        expect(div(x, y, 'x' => left, 'y' => right)).to eq(2)
+      end
+    end
+  end
+
+  it 'does not try to parse nested string as date' do
+    a = ['2017-01-01', '2017-01-02']
+    b = ['2017-01-01']
+
+    expect(Dentaku('a - b', a: a, b: b)).to eq(['2017-01-02'])
+  end
+
+  it 'raises ArgumentError if given individually valid but incompatible arguments' do
+    expect { add(one, date) }.to raise_error(Dentaku::ArgumentError)
+    expect { add(x, one, 'x' => [1]) }.to raise_error(Dentaku::ArgumentError)
+  end
+
+  private
+
+  def add(left, right, context = ctx)
+    Dentaku::AST::Addition.new(left, right).value(context)
+  end
+
+  def sub(left, right, context = ctx)
+    Dentaku::AST::Subtraction.new(left, right).value(context)
+  end
+
+  def mul(left, right, context = ctx)
+    Dentaku::AST::Multiplication.new(left, right).value(context)
+  end
+
+  def div(left, right, context = ctx)
+    Dentaku::AST::Division.new(left, right).value(context)
+  end
+
+  def neg(node, context = ctx)
+    Dentaku::AST::Negation.new(node).value(context)
+  end
+end

data/spec/ast/avg_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/avg'
+require 'dentaku'
+
+describe 'Dentaku::AST::Function::Avg' do
+  it 'returns the average of an array of Numeric values as BigDecimal' do
+    result = Dentaku('AVG(1, 2)')
+    expect(result).to eq(1.5)
+  end
+
+  it 'returns the average of an array of Numeric values' do
+    result = Dentaku('AVG(1, x, 1.8)', x: 2.3)
+    expect(result).to eq(1.7)
+  end
+
+  it 'returns the average of a single entry array of a Numeric value' do
+    result = Dentaku('AVG(x)', x: 2.3)
+    expect(result).to eq(2.3)
+  end
+
+  it 'returns the average even if a String is passed' do
+    result = Dentaku('AVG(1, x, 1.8)', x: '2.3')
+    expect(result).to eq(1.7)
+  end
+
+  it 'returns the average even if an array is passed' do
+    result = Dentaku('AVG(1, x, 2.3)', x: [4, 5])
+    expect(result).to eq(3.075)
+  end
+
+  context 'checking errors' do
+    let(:calculator) { Dentaku::Calculator.new }
+
+    it 'raises an error if no arguments are passed' do
+      expect { calculator.evaluate!('AVG()') }.to raise_error(Dentaku::ArgumentError)
+    end
+
+    it 'raises an error if an empty array is passed' do
+      expect { calculator.evaluate!('AVG(x)', x: []) }.to raise_error(Dentaku::ArgumentError)
+    end
+  end
+end

data/spec/ast/case_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+require 'dentaku/ast/operation'
+require 'dentaku/ast/logical'
+require 'dentaku/ast/identifier'
+require 'dentaku/ast/arithmetic'
+require 'dentaku/ast/case'
+
+require 'dentaku/token'
+
+describe Dentaku::AST::Case do
+  let!(:one) { Dentaku::AST::Logical.new Dentaku::Token.new(:numeric, 1) }
+  let!(:two)  { Dentaku::AST::Logical.new Dentaku::Token.new(:numeric, 2) }
+  let!(:apple) do
+    Dentaku::AST::Logical.new Dentaku::Token.new(:string, 'apple')
+  end
+  let!(:banana) do
+    Dentaku::AST::Logical.new Dentaku::Token.new(:string, 'banana')
+  end
+  let!(:identifier) do
+    Dentaku::AST::Identifier.new(Dentaku::Token.new(:identifier, :fruit))
+  end
+  let!(:switch) { Dentaku::AST::CaseSwitchVariable.new(identifier) }
+
+  let!(:when1) { Dentaku::AST::CaseWhen.new(apple) }
+  let!(:then1) { Dentaku::AST::CaseThen.new(one) }
+  let!(:conditional1) { Dentaku::AST::CaseConditional.new(when1, then1) }
+
+  let!(:when2) { Dentaku::AST::CaseWhen.new(banana) }
+  let!(:then2) { Dentaku::AST::CaseThen.new(two) }
+  let!(:conditional2) { Dentaku::AST::CaseConditional.new(when2, then2) }
+
+  describe '#value' do
+    it 'raises an exception if there is no switch variable' do
+      expect { described_class.new(conditional1, conditional2) }
+        .to raise_error('Case missing switch variable')
+    end
+
+    it 'raises an exception if a non-conditional is passed' do
+      expect { described_class.new(switch, conditional1, when2) }
+        .to raise_error(/is not a CaseConditional/)
+    end
+
+    it 'tests each conditional against the switch variable' do
+      node = described_class.new(switch, conditional1, conditional2)
+      expect(node.value(fruit: 'banana')).to eq(2)
+    end
+
+    it 'raises an exception if the conditional is not matched' do
+      node = described_class.new(switch, conditional1, conditional2)
+      expect { node.value(fruit: 'orange') }
+        .to raise_error("No block matched the switch value 'orange'")
+    end
+
+    it 'uses the else value if provided and conditional is not matched' do
+      three = Dentaku::AST::Logical.new Dentaku::Token.new(:numeric, 3)
+      else_statement = Dentaku::AST::CaseElse.new(three)
+      node = described_class.new(
+        switch,
+        conditional1,
+        conditional2,
+        else_statement)
+      expect(node.value(fruit: 'orange')).to eq(3)
+    end
+  end
+
+  describe '#dependencies' do
+    let!(:tax) do
+      Dentaku::AST::Identifier.new(Dentaku::Token.new(:identifier, :tax))
+    end
+    let!(:fallback) do
+      Dentaku::AST::Identifier.new(Dentaku::Token.new(:identifier, :fallback))
+    end
+    let!(:addition) { Dentaku::AST::Addition.new(two, tax) }
+    let!(:when2) { Dentaku::AST::CaseWhen.new(banana) }
+    let!(:then2) { Dentaku::AST::CaseThen.new(addition) }
+    let!(:else2) { Dentaku::AST::CaseElse.new(fallback) }
+    let!(:conditional2) { Dentaku::AST::CaseConditional.new(when2, then2) }
+
+    it 'gathers dependencies from switch and conditionals' do
+      node = described_class.new(switch, conditional1, conditional2, else2)
+      expect(node.dependencies).to eq([:fruit, :tax, :fallback])
+    end
+  end
+end

data/spec/ast/comparator_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+require 'dentaku/ast/comparators'
+
+require 'dentaku/token'
+
+describe Dentaku::AST::Comparator do
+  let(:one) { Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, 1) }
+  let(:one_str) { Dentaku::AST::String.new Dentaku::Token.new(:string, '1') }
+  let(:two) { Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, 2) }
+  let(:two_str) { Dentaku::AST::String.new Dentaku::Token.new(:string, '2') }
+  let(:x) { Dentaku::AST::Identifier.new Dentaku::Token.new(:identifier, 'x') }
+  let(:y) { Dentaku::AST::Identifier.new Dentaku::Token.new(:identifier, 'y') }
+  let(:nilly) do
+    Dentaku::AST::Identifier.new Dentaku::Token.new(:identifier, 'nilly')
+  end
+  let(:ctx) { { 'x' => 'hello', 'y' => 'world', 'nilly' => nil } }
+
+  it 'performs comparison with numeric operands' do
+    expect(less_than(one, two).value(ctx)).to be_truthy
+    expect(less_than(two, one).value(ctx)).to be_falsey
+    expect(greater_than(two, one).value(ctx)).to be_truthy
+    expect(not_equal(x, y).value(ctx)).to be_truthy
+    expect(equal(x, y).value(ctx)).to be_falsey
+  end
+
+  it 'performs conversion from string to numeric operands' do
+    expect(less_than(one, two_str).value(ctx)).to be_truthy
+    expect(less_than(one_str, two_str).value(ctx)).to be_truthy
+    expect(less_than(one_str, two).value(ctx)).to be_truthy
+  end
+
+  it 'raises a dentaku argument error when incorrect arguments are passed in' do
+    expect { less_than(one, nilly).value(ctx) }.to raise_error Dentaku::ArgumentError
+    expect { less_than_or_equal(one, nilly).value(ctx) }.to raise_error Dentaku::ArgumentError
+    expect { greater_than(one, nilly).value(ctx) }.to raise_error Dentaku::ArgumentError
+    expect { greater_than_or_equal(one, nilly).value(ctx) }.to raise_error Dentaku::ArgumentError
+    expect { greater_than_or_equal(one, x).value(ctx) }.to raise_error Dentaku::ArgumentError
+    expect { not_equal(one, nilly).value(ctx) }.to_not raise_error
+    expect { equal(one, nilly).value(ctx) }.to_not raise_error
+  end
+
+  it 'raises a dentaku argument error when nil is passed in as first argument' do
+    expect { less_than(nilly, one).value(ctx) }.to raise_error Dentaku::ArgumentError
+    expect { less_than_or_equal(nilly, one).value(ctx) }.to raise_error Dentaku::ArgumentError
+    expect { greater_than(nilly, one).value(ctx) }.to raise_error Dentaku::ArgumentError
+    expect { greater_than_or_equal(nilly, one).value(ctx) }.to raise_error Dentaku::ArgumentError
+    expect { not_equal(nilly, one).value(ctx) }.to_not raise_error
+    expect { equal(nilly, one).value(ctx) }.to_not raise_error
+  end
+
+  it 'returns correct operator symbols' do
+    expect(less_than(one, two).operator).to eq(:<)
+    expect(less_than_or_equal(one, two).operator).to eq(:<=)
+    expect(greater_than(one, two).operator).to eq(:>)
+    expect(greater_than_or_equal(one, two).operator).to eq(:>=)
+    expect(not_equal(x, y).operator).to eq(:!=)
+    expect(equal(x, y).operator).to eq(:==)
+    expect { Dentaku::AST::Comparator.new(one, two).operator }
+      .to raise_error(NotImplementedError)
+  end
+
+  private
+
+  def less_than(left, right)
+    Dentaku::AST::LessThan.new(left, right)
+  end
+
+  def less_than_or_equal(left, right)
+    Dentaku::AST::LessThanOrEqual.new(left, right)
+  end
+
+  def greater_than(left, right)
+    Dentaku::AST::GreaterThan.new(left, right)
+  end
+
+  def greater_than_or_equal(left, right)
+    Dentaku::AST::GreaterThanOrEqual.new(left, right)
+  end
+
+  def not_equal(left, right)
+    Dentaku::AST::NotEqual.new(left, right)
+  end
+
+  def equal(left, right)
+    Dentaku::AST::Equal.new(left, right)
+  end
+end

data/spec/ast/count_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'dentaku/ast/functions/count'
+require 'dentaku'
+
+describe 'Dentaku::AST::Count' do
+  it 'returns the length of an array' do
+    result = Dentaku('COUNT(1, x, 1.8)', x: 2.3)
+    expect(result).to eq(3)
+  end
+
+  it 'returns the length of a single number object' do
+    result = Dentaku('COUNT(x)', x: 2.3)
+    expect(result).to eq(1)
+  end
+
+  it 'returns the length if a single String is passed' do
+    result = Dentaku('COUNT(x)', x: 'dentaku')
+    expect(result).to eq(7)
+  end
+
+  it 'returns the length if an array is passed' do
+    result = Dentaku('COUNT(x)', x: [4, 5])
+    expect(result).to eq(2)
+  end
+
+  it 'returns the length if an array with one element is passed' do
+    result = Dentaku('COUNT(x)', x: [4])
+    expect(result).to eq(1)
+  end
+
+  it 'returns the length if an array even if it has nested array' do
+    result = Dentaku('COUNT(1, x, 3)', x: [4, 5])
+    expect(result).to eq(3)
+  end
+
+  it 'returns the length if an array is passed' do
+    result = Dentaku('COUNT()')
+    expect(result).to eq(0)
+  end
+end