veritas 0.0.1

data/spec/unit/veritas/attribute/equal_value_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe 'Veritas::Attribute#==' do
+  subject { attribute == other }
+
+  let(:name)      { :id                          }
+  let(:attribute) { Attribute::Integer.new(name) }
+
+  context 'with the same attribute' do
+    let(:other) { attribute }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == (other == attribute)
+    end
+  end
+
+  context 'with an equivalent attribute' do
+    let(:other) { attribute.dup }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == (other == attribute)
+    end
+  end
+
+  context 'with a different attribute' do
+    let(:other) { Attribute::String.new(:name) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should == (other == attribute)
+    end
+  end
+
+  context 'with an equivalent attribute of a different class' do
+    let(:other) { Class.new(Attribute::Integer).new(name) }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == (other == attribute)
+    end
+  end
+end

data/spec/unit/veritas/attribute/float/class_methods/primitive_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe 'Veritas::Attribute::Float.primitive' do
+  subject { Attribute::Float.primitive }
+
+  it { should equal(Float) }
+end

data/spec/unit/veritas/attribute/hash_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe 'Veritas::Attribute#hash' do
+  subject { attribute.hash }
+
+  let(:name)      { :id                                   }
+  let(:options)   { { :size => 1..10 }                    }
+  let(:attribute) { Attribute::Integer.new(name, options) }
+
+  it { should be_kind_of(Integer) }
+
+  it { should == name.hash ^ options.hash }
+
+  it_should_behave_like 'an idempotent method'
+end

data/spec/unit/veritas/attribute/inspect_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe 'Veritas::Attribute#inspect' do
+  subject { attribute.inspect }
+
+  let(:attribute) { Attribute::Integer.new(:id) }
+
+  it { should be_kind_of(String) }
+
+  it { should == '<Attribute::Integer name: id>' }
+end

data/spec/unit/veritas/attribute/integer/class_methods/primitive_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe 'Veritas::Attribute::Integer.primitive' do
+  subject { Attribute::Integer.primitive }
+
+  it { should equal(Integer) }
+end

data/spec/unit/veritas/attribute/joinable_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe 'Veritas::Attribute#joinable?' do
+  subject { attribute.joinable?(other) }
+
+  let(:attribute) { Attribute::Integer.new(:id) }
+
+  context 'when the other attribute is the same type' do
+    let(:other) { attribute.dup }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == other.joinable?(attribute)
+    end
+  end
+
+  context 'when the other attribute is a different class' do
+    let(:other) { Attribute::String.new(:different) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should == other.joinable?(attribute)
+    end
+  end
+
+  context 'when the other attribute is a descendant type' do
+    let(:other) { Class.new(Attribute::Integer).new(:descendant) }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == other.joinable?(attribute)
+    end
+  end
+
+  context 'when the other attribute shares a common type' do
+    let(:other) { Attribute::Numeric.new(:ancestor) }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == other.joinable?(attribute)
+    end
+  end
+end

data/spec/unit/veritas/attribute/name_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe 'Veritas::Attribute#name' do
+  subject { attribute.name }
+
+  let(:name)      { :id                          }
+  let(:attribute) { Attribute::Integer.new(name) }
+
+  it { should == name }
+end

data/spec/unit/veritas/attribute/numeric/class_methods/primitive_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe 'Veritas::Attribute::Numeric.primitive' do
+  subject { Attribute::Numeric.primitive }
+
+  it { should equal(Numeric) }
+end

data/spec/unit/veritas/attribute/numeric/joinable_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe 'Veritas::Attribute::Numeric#joinable?' do
+  subject { attribute.joinable?(other) }
+
+  let(:attribute) { Attribute::Numeric.new(:numeric, :size => 10..20) }
+
+  context 'when the attribute types and sizes are the same' do
+    let(:other) { Attribute::Numeric.new(:numeric, :size => 10..20) }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == other.joinable?(attribute)
+    end
+  end
+
+  context 'when the attribute types are the same and the sizes are different' do
+    let(:other) { Attribute::Numeric.new(:numeric, :size => 1..20) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should == other.joinable?(attribute)
+    end
+  end
+
+  context 'when the attribute types are different' do
+    let(:other) { Attribute::String.new(:different) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should == other.joinable?(attribute)
+    end
+  end
+end

data/spec/unit/veritas/attribute/numeric/size_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+[ :size, :range ].each do |method|
+  describe "Veritas::Attribute::Numeric##{method}" do
+    subject { attribute.send(method) }
+
+    context 'without :size option passed to constructor' do
+      let(:attribute) { Attribute::Numeric.new(:id) }
+
+      it { should == (0..2**31-1) }
+    end
+
+    context 'with :size option passed to constructor' do
+      let(:attribute) { Attribute::Numeric.new(:id, :size => 1..100) }
+
+      it { should == (1..100) }
+    end
+  end
+end

data/spec/unit/veritas/attribute/numeric/valid_value_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe 'Veritas::Attribute::Numeric#valid_value?' do
+  subject { attribute.valid_value?(value) }
+
+  let(:attribute) { Veritas::Attribute::Numeric.new(:numeric, :size => 1..50) }
+
+  context 'with a numeric value' do
+    context 'that is within the allowed size range' do
+      let(:value) { 1 }
+
+      it { should be(true) }
+    end
+
+    context 'that is greater than the allowed size range' do
+      let(:value) { 51 }
+
+      it { should be(false) }
+    end
+
+    context 'that is less than the allowed size range' do
+      let(:value) { 0 }
+
+      it { should be(false) }
+    end
+  end
+
+  context 'with a value that is not a numeric' do
+    let(:value) { 'a' }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/attribute/object/class_methods/primitive_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe 'Veritas::Attribute::Object.primitive' do
+  subject { Attribute::Object.primitive }
+
+  it { should equal(Object) }
+end

data/spec/unit/veritas/attribute/options_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe 'Veritas::Attribute#options' do
+  subject { attribute.options }
+
+  let(:name)      { :id                                   }
+  let(:attribute) { Attribute::Integer.new(name, options) }
+
+  context 'when no options are provided' do
+    let(:attribute) { Attribute::Integer.new(name) }
+
+    it { should eql({}) }
+
+    it { should be_frozen }
+  end
+
+  context 'when options are frozen' do
+    let(:options) { {}.freeze }
+
+    it { should equal(options) }
+  end
+
+  context 'when options are not frozen' do
+    let(:options) { {} }
+
+    it { should_not equal(options) }
+
+    it { should eql(options) }
+
+    it { should be_frozen }
+  end
+end

data/spec/unit/veritas/attribute/orderable/asc_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe 'Veritas::Attribute::Orderable#asc' do
+  subject { comparable.asc }
+
+  let(:comparable) { OrderableSpecs::Object.new }
+
+  it { should be_kind_of(Relation::Operation::Order::Ascending) }
+end

data/spec/unit/veritas/attribute/orderable/desc_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe 'Veritas::Attribute::Orderable#desc' do
+  subject { comparable.desc }
+
+  let(:comparable) { OrderableSpecs::Object.new }
+
+  it { should be_kind_of(Relation::Operation::Order::Descending) }
+end

data/spec/unit/veritas/attribute/orderable/fixtures/classes.rb

@@ -0,0 +1,5 @@
+module OrderableSpecs
+  class Object
+    include Attribute::Orderable
+  end # class Object
+end # module OrderableSpecs

data/spec/unit/veritas/attribute/rename_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe 'Veritas::Attribute#rename' do
+  subject { attribute.rename(name) }
+
+  let(:attribute) { Attribute::Integer.new(:id, :size => 1..10) }
+
+  context 'when the new name is the same' do
+    let(:name) { attribute.name }
+
+    it { should equal(attribute) }
+  end
+
+  context 'when the new name is different' do
+    let(:name) { :other_id }
+
+    it { should be_kind_of(Attribute) }
+
+    it { should_not equal(attribute) }
+
+    its(:name) { should equal(name) }
+
+    its(:options) { should equal(attribute.options) }
+  end
+end

data/spec/unit/veritas/attribute/required_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe 'Veritas::Attribute#required?' do
+  subject { attribute.required? }
+
+  context 'without :required option passed to constructor' do
+    let(:attribute) { Attribute::Integer.new(:id) }
+
+    it { should be(true) }
+  end
+
+  context 'with :required => true option passed to constructor' do
+    let(:attribute) { Attribute::Integer.new(:id, :required => true) }
+
+    it { should be(true) }
+  end
+
+  context 'with :required => false option passed to constructor' do
+    let(:attribute) { Attribute::Integer.new(:id, :required => false) }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/attribute/string/class_methods/primitive_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe 'Veritas::Attribute::String.primitive' do
+  subject { Attribute::String.primitive }
+
+  it { should equal(String) }
+end

data/spec/unit/veritas/attribute/string/joinable_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe 'Veritas::Attribute::String#joinable?' do
+  subject { attribute.joinable?(other) }
+
+  let(:attribute) { Attribute::String.new(:string, :length => 10..20) }
+
+  context 'when the attribute types and lengths are the same' do
+    let(:other) { Attribute::String.new(:string, :length => 10..20) }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == other.joinable?(attribute)
+    end
+  end
+
+  context 'when the attribute types are the same and the lengths are different' do
+    let(:other) { Attribute::String.new(:string, :length => 1..20) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should == other.joinable?(attribute)
+    end
+  end
+
+  context 'when the attribute types are different' do
+    let(:other) { Attribute::String.new(:different) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should == other.joinable?(attribute)
+    end
+  end
+end

data/spec/unit/veritas/attribute/string/length_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+[ :length, :range ].each do |method|
+  describe "Veritas::Attribute::String##{method}" do
+    subject { attribute.send(method) }
+
+    context 'without :length option passed to constructor' do
+      let(:attribute) { Attribute::String.new(:name) }
+
+      it { should == (0..50) }
+    end
+
+    context 'with :length option passed to constructor' do
+      let(:attribute) { Attribute::String.new(:name, :length => 1..100) }
+
+      it { should == (1..100) }
+    end
+  end
+end

data/spec/unit/veritas/attribute/string/valid_value_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe 'Veritas::Attribute::String#valid_value?' do
+  subject { attribute.valid_value?(value) }
+
+  let(:attribute) { Veritas::Attribute::String.new(:string, :length => 1..50) }
+
+  context 'with a string value' do
+    context 'that is within the allowed length range' do
+      let(:value) { 'a' }
+
+      it { should be(true) }
+    end
+
+    context 'that is greater than the allowed length range' do
+      let(:value) { 'a' * 51 }
+
+      it { should be(false) }
+    end
+
+    context 'that is less than the allowed length range' do
+      let(:value) { '' }
+
+      it { should be(false) }
+    end
+  end
+
+  context 'with a value that is not a string' do
+    let(:value) { 1 }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/attribute/time/class_methods/primitive_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe 'Veritas::Attribute::Time.primitive' do
+  subject { Attribute::Time.primitive }
+
+  it { should equal(Time) }
+end

data/spec/unit/veritas/attribute/time/range_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe 'Veritas::Attribute::Time#range' do
+  subject { attribute.range }
+
+  let(:attribute) { Veritas::Attribute::Time.new(:time) }
+
+  it { should == (Time.at(0)..Time.at(2**31-1)) }
+end

data/spec/unit/veritas/attribute/valid_primitive_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe 'Veritas::Attribute#valid_primitive?' do
+  subject { attribute.valid_primitive?(value) }
+
+  let(:attribute) { Attribute::Integer.new(:id) }
+
+  context 'with a valid value' do
+    let(:value) { 1 }
+
+    it { should be(true) }
+  end
+
+  context 'with an invalid value' do
+    let(:value) { 'a' }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/attribute/valid_value_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe 'Veritas::Attribute#valid_value?' do
+  subject { attribute.valid_value?(value) }
+
+  context 'when value is nil' do
+    let(:value) { nil }
+
+    context 'and the attribute is required' do
+      let(:attribute) { Attribute::Integer.new(:id) }
+
+      it { should be(false) }
+    end
+
+    context 'and the attribute not required' do
+      let(:attribute) { Attribute::Integer.new(:id, :required => false) }
+
+      it { should be(true) }
+    end
+  end
+
+  context 'when the value is a valid primitive' do
+    let(:attribute) { Attribute::Integer.new(:id) }
+    let(:value)     { 1                           }
+
+    it { should be(true) }
+  end
+
+  context 'when the value is not a valid primitive' do
+    let(:attribute) { Attribute::Integer.new(:id) }
+    let(:value)     { 'a'                         }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/evaluator/expression/add_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe 'Veritas::Evaluator::Expression#add' do
+  subject { klass.new(&expression) }
+
+  let(:klass)     { Veritas::Evaluator::Expression }
+  let(:attribute) { Attribute::Integer.new(:id)    }
+
+  context 'when a function is provided' do
+    let(:function)   { mock('Function')                          }
+    let(:expression) { lambda { |o| o.add(attribute, function) } }
+
+    its(:expressions) { should == { attribute => function } }
+  end
+
+  context 'when a block is provided' do
+    let(:block)      { proc {}                                 }
+    let(:expression) { lambda { |o| o.add(attribute, &block) } }
+
+    its(:expressions) { should == { attribute => block } }
+  end
+end

data/spec/unit/veritas/evaluator/expression/expressions_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe 'Veritas::Evaluator::Expression#expressions' do
+  subject { object.expressions }
+
+  let(:klass)     { Veritas::Evaluator::Expression               }
+  let(:attribute) { Attribute::Integer.new(:id)                  }
+  let(:function)  { mock('Function')                             }
+  let(:object)    { klass.new { |o| o.add(attribute, function) } }
+
+  it { should == { attribute => function } }
+
+  it { should be_frozen }
+end

data/spec/unit/veritas/immutable/class_methods/freeze_object_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe 'Veritas::Immutable.freeze_object' do
+  subject { object.freeze_object(value) }
+
+  let(:object) { Immutable }
+
+  context 'with a numeric value' do
+    let(:value) { 1 }
+
+    it { should equal(value) }
+  end
+
+  context 'with a true value' do
+    let(:value) { true }
+
+    it { should equal(value) }
+  end
+
+  context 'with a false value' do
+    let(:value) { false }
+
+    it { should equal(value) }
+  end
+
+  context 'with a nil value' do
+    let(:value) { nil }
+
+    it { should equal(value) }
+  end
+
+  context 'with a frozen value' do
+    let(:value) { String.new.freeze }
+
+    it { should equal(value) }
+  end
+
+  context 'with an unfrozen value' do
+    let(:value) { String.new }
+
+    it { should_not equal(value) }
+
+    it { should eql(value) }
+  end
+end

data/spec/unit/veritas/immutable/class_methods/new_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+require File.expand_path('../../fixtures/classes', __FILE__)
+
+describe 'Veritas::Immutable::ClassMethods#new' do
+  subject { klass.new }
+
+  let(:klass) { ImmutableSpecs::Object }
+
+  it { should be_kind_of(klass) }
+
+  it { should be_frozen }
+end

data/spec/unit/veritas/immutable/dup_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe 'Veritas::Immutable#dup' do
+  subject { immutable.dup }
+
+  let(:klass)     { ImmutableSpecs::Object }
+  let(:immutable) { klass.new              }
+
+  it { should equal(immutable) }
+end