axiom 0.1.0

data/spec/unit/axiom/aggregate/equality_operator_spec.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Aggregate, '#==' do
+  subject { object == other }
+
+  let(:described_class) { Class.new(Aggregate)           }
+  let(:object)          { described_class.new(attribute) }
+  let(:attribute)       { Attribute::Integer.new(:id)    }
+
+  context 'with the same object' do
+    let(:other) { object }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should eql(other == object)
+    end
+  end
+
+  context 'with an equivalent object' do
+    let(:other) { object.dup }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should eql(other == object)
+    end
+  end
+
+  context 'with an equivalent object of a subclass' do
+    let(:other) { Class.new(described_class).new(attribute) }
+
+    it { should be(true) }
+
+    it 'is not symmetric' do
+      should_not eql(other == object)
+    end
+  end
+
+  context 'with an object having a different attribute' do
+    let(:other_attribute) { Attribute::Integer.new(:other_id)    }
+    let(:other)           { described_class.new(other_attribute) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should eql(other.eql?(object))
+    end
+  end
+end

data/spec/unit/axiom/aggregate/finalize_spec.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Aggregate, '#finalize' do
+  subject { object.finalize(accumulator) }
+
+  let(:described_class) { Class.new(Aggregate)           }
+  let(:object)          { described_class.new(attribute) }
+  let(:attribute)       { Attribute::Integer.new(:id)    }
+  let(:accumulator)     { mock('Accumulator')            }
+
+  it 'delegates to self.class.finalize' do
+    return_value = mock('Return Value')
+    described_class.should_receive(:finalize).with(accumulator).and_return(return_value)
+    should equal(return_value)
+  end
+end

data/spec/unit/axiom/aggregate/hash_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Aggregate, '#hash' do
+  subject { object.hash }
+
+  let(:described_class) { Class.new(Aggregate)           }
+  let(:object)          { described_class.new(attribute) }
+  let(:attribute)       { Attribute::Integer.new(:id)    }
+
+  it_should_behave_like 'a hash method'
+
+  it { should == described_class.hash ^ attribute.hash }
+end

data/spec/unit/axiom/aggregate/maximum/class_methods/call_spec.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Aggregate::Maximum, '.call' do
+  subject { object.call(maximum, value) }
+
+  let(:object)   { described_class }
+  let(:maximum)  { 0               }
+  let(:value)    { 1               }
+
+  context 'when the value is greater than the maximum' do
+    let(:value) { 1 }
+
+    it { should eql(1) }
+  end
+
+  context 'when the value is equal to the maximum' do
+    let(:value) { 0 }
+
+    it { should eql(0) }
+  end
+
+  context 'when the value is less than the maximum' do
+    let(:value) { -1 }
+
+    it { should eql(0) }
+  end
+
+  context 'when the value is nil' do
+    let(:value)   { nil             }
+    let(:maximum) { mock('Maximum') }
+
+    it { should equal(maximum) }
+  end
+end

data/spec/unit/axiom/aggregate/maximum/class_methods/default_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Aggregate::Maximum, '.default' do
+  subject { object.default }
+
+  let(:object) { described_class }
+
+  it_should_behave_like 'an idempotent method'
+
+  it { should eql(-Float::INFINITY) }
+end

data/spec/unit/axiom/aggregate/maximum/methods/maximum_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+[ :maximum, :max ].each do |method|
+  describe Aggregate::Maximum::Methods, "##{method}" do
+    subject { object.send(method) }
+
+    let(:described_class) { Class.new { include Aggregate::Maximum::Methods } }
+    let(:object)          { described_class.new.freeze                        }
+
+    it { should be_instance_of(Aggregate::Maximum) }
+
+    its(:operand) { should equal(object) }
+  end
+end

data/spec/unit/axiom/aggregate/maximum/type_spec.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Aggregate::Maximum, '#type' do
+  subject { object.type }
+
+  let(:object)  { described_class.new(operand) }
+  let(:operand) { mock('Unhandled')            }
+
+  before do
+    operand.stub(:freeze => operand, :frozen? => true)
+  end
+
+  it 'delegates to Attribute.infer_type' do
+    return_value = mock('Return Value')
+    Attribute.should_receive(:infer_type).with(operand).and_return(return_value)
+    should equal(return_value)
+  end
+end

data/spec/unit/axiom/aggregate/mean/class_methods/call_spec.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Aggregate::Mean, '.call' do
+  subject do
+    values.reduce(default) do |accumulator, value|
+      object.call(accumulator, value)
+    end
+  end
+
+  let(:default) { object.default  }
+  let(:object)  { described_class }
+
+  context 'when the value is 0' do
+    let(:values) { [ 0 ] }
+
+    it 'returns the expected count and mean of the values' do
+      should eql([ 1, 0.0 ])
+    end
+  end
+
+  context 'when the values are not nil' do
+    let(:values) { [ -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6 ] }
+
+    it 'returns the expected count and mean of the values' do
+      should eql([ 13, 0.0 ])
+    end
+  end
+
+  context 'when the values are nil' do
+    let(:values) { [ nil ] }
+
+    it 'returns the default' do
+      should equal(default)
+    end
+  end
+end

data/spec/unit/axiom/aggregate/mean/class_methods/default_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Aggregate::Mean, '.default' do
+  subject { object.default }
+
+  let(:object) { described_class }
+
+  it_should_behave_like 'an idempotent method'
+
+  it { should be_frozen }
+
+  it { should eql([ 0, nil ]) }
+end

data/spec/unit/axiom/aggregate/mean/class_methods/finalize_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Aggregate::Mean, '.finalize' do
+  subject { object.finalize(accumulator) }
+
+  let(:object)      { described_class }
+  let(:accumulator) { [ count, mean ] }
+  let(:count)       { mock('Count')   }
+  let(:mean)        { mock('Mean')    }
+
+  it_should_behave_like 'an idempotent method'
+
+  it { should equal(mean) }
+end

data/spec/unit/axiom/aggregate/mean/methods/mean_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+[ :mean, :average, :avg ].each do |method|
+  describe Aggregate::Mean::Methods, "##{method}" do
+    subject { object.send(method) }
+
+    let(:described_class) { Class.new { include Aggregate::Mean::Methods } }
+    let(:object)          { described_class.new.freeze                     }
+
+    it { should be_instance_of(Aggregate::Mean) }
+
+    its(:operand) { should equal(object) }
+  end
+end

data/spec/unit/axiom/aggregate/mean/type_spec.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Aggregate::Mean, '#type' do
+  subject { object.type }
+
+  let(:object)  { described_class.new(operand) }
+  let(:operand) { Attribute::Integer.new(:id)  }
+
+  it { should equal(Attribute::Float) }
+end

data/spec/unit/axiom/aggregate/minimum/class_methods/call_spec.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Aggregate::Minimum, '.call' do
+  subject { object.call(minimum, value) }
+
+  let(:object)   { described_class }
+  let(:minimum)  { 0               }
+  let(:value)    { 1               }
+
+  context 'when the value is greater than the minimum' do
+    let(:value) { 1 }
+
+    it { should eql(0) }
+  end
+
+  context 'when the value is equal to the minimum' do
+    let(:value) { 0 }
+
+    it { should eql(0) }
+  end
+
+  context 'when the value is less than the minimum' do
+    let(:value) { -1 }
+
+    it { should eql(-1) }
+  end
+
+  context 'when the value is nil' do
+    let(:value)   { nil             }
+    let(:minimum) { mock('Minimum') }
+
+    it { should equal(minimum) }
+  end
+end

data/spec/unit/axiom/aggregate/minimum/class_methods/default_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Aggregate::Minimum, '.default' do
+  subject { object.default }
+
+  let(:object) { described_class }
+
+  it_should_behave_like 'an idempotent method'
+
+  it { should eql(Float::INFINITY) }
+end

data/spec/unit/axiom/aggregate/minimum/methods/minimum_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+[ :minimum, :min ].each do |method|
+  describe Aggregate::Minimum::Methods, "##{method}" do
+    subject { object.send(method) }
+
+    let(:described_class) { Class.new { include Aggregate::Minimum::Methods } }
+    let(:object)          { described_class.new.freeze                        }
+
+    it { should be_instance_of(Aggregate::Minimum) }
+
+    its(:operand) { should equal(object) }
+  end
+end

data/spec/unit/axiom/aggregate/minimum/type_spec.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Aggregate::Minimum, '#type' do
+  subject { object.type }
+
+  let(:object)  { described_class.new(operand) }
+  let(:operand) { mock('Unhandled')            }
+
+  before do
+    operand.stub(:freeze => operand, :frozen? => true)
+  end
+
+  it 'delegates to Attribute.infer_type' do
+    return_value = mock('Return Value')
+    Attribute.should_receive(:infer_type).with(operand).and_return(return_value)
+    should equal(return_value)
+  end
+end

data/spec/unit/axiom/aggregate/standard_deviation/class_methods/finalize_spec.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Aggregate::StandardDeviation, '.finalize' do
+  subject { object.finalize(accumulator) }
+
+  let(:object)      { described_class                 }
+  let(:accumulator) { [ count, mean, sum_of_squares ] }
+
+  context 'when the variance is 0.0' do
+    let(:count)          { 0   }
+    let(:mean)           { nil }
+    let(:sum_of_squares) { 0.0 }
+
+    it { should be_nil }
+  end
+
+  context 'when the variance is not 0.0' do
+    let(:count)          { 6    }
+    let(:mean)           { 3.5  }
+    let(:sum_of_squares) { 17.5 }
+
+    it { should be_within(1.70).of(0.01) }
+  end
+
+  context 'when the variance is 0.0' do
+    let(:count)          { 1               }
+    let(:mean)           { nil             }
+    let(:sum_of_squares) { Float::INFINITY }
+
+    it { should eql(Float::INFINITY) }
+  end
+end

data/spec/unit/axiom/aggregate/standard_deviation/methods/standard_deviation_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+[ :standard_deviation, :stddev ].each do |method|
+  describe Aggregate::StandardDeviation::Methods, "##{method}" do
+    subject { object.send(method) }
+
+    let(:described_class) { Class.new { include Aggregate::StandardDeviation::Methods } }
+    let(:object)          { described_class.new.freeze                                  }
+
+    it { should be_instance_of(Aggregate::StandardDeviation) }
+
+    its(:operand) { should equal(object) }
+  end
+end

data/spec/unit/axiom/aggregate/standard_deviation/type_spec.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Aggregate::StandardDeviation, '#type' do
+  subject { object.type }
+
+  let(:object)  { described_class.new(operand) }
+  let(:operand) { Attribute::Integer.new(:id)  }
+
+  it { should equal(Attribute::Float) }
+end

data/spec/unit/axiom/aggregate/sum/class_methods/call_spec.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Aggregate::Sum, '.call' do
+  subject do
+    values.reduce(default) do |accumulator, value|
+      object.call(accumulator, value)
+    end
+  end
+
+  let(:default) { object.default  }
+  let(:object)  { described_class }
+
+  context 'when the values are not nil' do
+    let(:values) { [ 1, 2, 3, 4, 5, 6 ] }
+
+    it 'returns the expected sum of the values' do
+      should eql(21)
+    end
+  end
+
+  context 'when the values are nil' do
+    let(:values) { [ nil ] }
+
+    it 'returns the default' do
+      should equal(default)
+    end
+  end
+end