axiom 0.1.1 → 0.2.0

data/spec/unit/axiom/attribute/class_methods/new_spec.rb

@@ -25,7 +25,7 @@ describe Attribute, '.new' do
       let(:object) { described_class }
 
       it 'does not freeze the options' do
-        options.should_not be_frozen
+        expect(options).not_to be_frozen
         expect { subject }.to_not change(options, :frozen?)
       end
 

data/spec/unit/axiom/attribute/comparable/asc_spec.rb

@@ -6,8 +6,10 @@ require File.expand_path('../fixtures/classes', __FILE__)
 describe Attribute::Comparable, '#asc' do
   subject { object.asc }
 
-  let(:described_class) { ComparableSpecs::Object }
   let(:object)          { described_class.new     }
+  let(:described_class) { ComparableSpecs::Object }
+
+  it { should be_instance_of(Relation::Operation::Sorted::Ascending) }
 
-  it { should be_instance_of(Relation::Operation::Order::Ascending) }
+  its(:attribute) { should be(object) }
 end

data/spec/unit/axiom/attribute/comparable/desc_spec.rb

@@ -6,8 +6,10 @@ require File.expand_path('../fixtures/classes', __FILE__)
 describe Attribute::Comparable, '#desc' do
   subject { object.desc }
 
-  let(:described_class) { ComparableSpecs::Object }
   let(:object)          { described_class.new     }
+  let(:described_class) { ComparableSpecs::Object }
+
+  it { should be_instance_of(Relation::Operation::Sorted::Descending) }
 
-  it { should be_instance_of(Relation::Operation::Order::Descending) }
+  its(:attribute) { should be(object) }
 end

data/spec/unit/axiom/attribute/comparable/range_spec.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe Attribute::Comparable, '#range' do
+  subject { object.range }
+
+  let(:object) { described_class.new }
+
+  let(:described_class) do
+    Class.new(ComparableSpecs::Object) do
+      def type
+        Types::Numeric
+      end
+    end
+  end
+
+  it { should eql(Types::NegativeInfinity.instance..Types::Infinity.instance) }
+end

data/spec/unit/axiom/attribute/eql_spec.rb

@@ -10,7 +10,7 @@ describe Attribute, '#eql?' do
   let(:object)          { described_class.new(name) }
 
   before do
-    described_class.stub(type: Types::Object)
+    allow(described_class).to receive(:type).and_return(Types::Object)
   end
 
   context 'with the same object' do

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

@@ -10,7 +10,7 @@ describe Attribute, '#==' do
   let(:object)          { described_class.new(name) }
 
   before do
-    described_class.stub(type: Types::Object)
+    allow(described_class).to receive(:type).and_return(Types::Object)
   end
 
   context 'with the same object' do

data/spec/unit/axiom/attribute/include_predicate_spec.rb

@@ -8,7 +8,7 @@ describe Attribute, '#include?' do
   let(:described_class) { Class.new(Attribute) }
 
   before do
-    described_class.stub(type: Types::Integer)
+    allow(described_class).to receive(:type).and_return(Types::Integer)
   end
 
   context 'when value is nil' do

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

@@ -9,7 +9,7 @@ describe Attribute, '#name' do
   let(:object)          { described_class.new(name) }
 
   before do
-    described_class.stub(type: Types::Object)
+    allow(described_class).to receive(:type).and_return(Types::Object)
   end
 
   context 'when name is a Symbol' do

data/spec/unit/axiom/attribute/optional_predicate_spec.rb

@@ -8,7 +8,7 @@ describe Attribute, '#optional?' do
   let(:described_class) { Class.new(Attribute) }
 
   before do
-    described_class.stub(type: Types::Object)
+    allow(described_class).to receive(:type).and_return(Types::Object)
   end
 
   context 'without :required option passed to constructor' do

data/spec/unit/axiom/attribute/relation/class_methods/new_spec.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Attribute::Relation, '.new' do
+  subject { object.new(name, options) }
+
+  let(:object) { described_class }
+  let(:name)   { :ids            }
+
+  context 'with a Header' do
+    let(:options) { { header: header }                        }
+    let(:header)  { Relation::Header.coerce([[:id, Integer]]) }
+
+    it { should be_instance_of(described_class) }
+
+    it 'sets the name' do
+      expect(subject.name).to be(name)
+    end
+
+    it 'does not freeze the options' do
+      expect(options).not_to be_frozen
+      expect { subject }.to_not change(options, :frozen?)
+    end
+
+    it 'sets the expected header' do
+      expect(subject.header).to be(header)
+    end
+  end
+
+  context 'with attributes' do
+    let(:options) { { header: header } }
+    let(:header)  { [[:id, Integer]]   }
+
+    it { should be_instance_of(described_class) }
+
+    it 'sets the name' do
+      expect(subject.name).to be(name)
+    end
+
+    it 'does not freeze the options' do
+      expect(options).not_to be_frozen
+      expect { subject }.to_not change(options, :frozen?)
+    end
+
+    it 'sets the expected header' do
+      expect(subject.header).to eql(Relation::Header.coerce(header))
+    end
+  end
+
+  context 'without a Header' do
+    let(:options) { {} }
+
+    specify { expect { subject }.to raise_error }
+  end
+end

data/spec/unit/axiom/attribute/relation/class_methods/type_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Attribute::Relation, '.type' do
+  subject { object.type }
+
+  let(:object) { described_class }
+
+  it_should_behave_like 'an idempotent method'
+
+  it { should be(Types::Relation) }
+end

data/spec/unit/axiom/attribute/relation/header_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Attribute::Relation, '#header' do
+  subject { object.header }
+
+  let(:object)  { described_class.new(:ids, options)        }
+  let(:options) { { header: header }                        }
+  let(:header)  { Relation::Header.coerce([[:id, Integer]]) }
+
+  it { should be(header) }
+end

data/spec/unit/axiom/attribute/relation/new_relation_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Attribute::Relation, '#new_relation' do
+  subject { object.new_relation(tuples) }
+
+  let(:object) { described_class.new(:ids, header: header) }
+  let(:header) { [[:id, Integer]]                          }
+  let(:tuples) { [[1]]                                     }
+
+  it 'returns the expected relation' do
+    expect(subject).to eql(Relation.new(header, tuples))
+  end
+end

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

@@ -9,7 +9,7 @@ describe Attribute, '#rename' do
   let(:object)          { described_class.new(:name, required: false) }
 
   before do
-    described_class.stub(type: Types::Object)
+    allow(described_class).to receive(:type).and_return(Types::Object)
   end
 
   context 'when the new name is the same' do

data/spec/unit/axiom/attribute/required_predicate_spec.rb

@@ -8,7 +8,7 @@ describe Attribute, '#required?' do
   let(:described_class) { Class.new(Attribute) }
 
   before do
-    described_class.stub(type: Types::Object)
+    allow(described_class).to receive(:type).and_return(Types::Object)
   end
 
   context 'without :required option passed to constructor' do

data/spec/unit/axiom/attribute/tuple/class_methods/new_spec.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Attribute::Tuple, '.new' do
+  subject { object.new(name, options) }
+
+  let(:object) { described_class }
+  let(:name)   { :ids            }
+
+  context 'with a Header' do
+    let(:options) { { header: header }                        }
+    let(:header)  { Relation::Header.coerce([[:id, Integer]]) }
+
+    it { should be_instance_of(described_class) }
+
+    it 'sets the name' do
+      expect(subject.name).to be(name)
+    end
+
+    it 'does not freeze the options' do
+      expect(options).not_to be_frozen
+      expect { subject }.to_not change(options, :frozen?)
+    end
+
+    it 'sets the expected header' do
+      expect(subject.header).to be(header)
+    end
+  end
+
+  context 'with attributes' do
+    let(:options) { { header: header } }
+    let(:header)  { [[:id, Integer]]   }
+
+    it { should be_instance_of(described_class) }
+
+    it 'sets the name' do
+      expect(subject.name).to be(name)
+    end
+
+    it 'does not freeze the options' do
+      expect(options).not_to be_frozen
+      expect { subject }.to_not change(options, :frozen?)
+    end
+
+    it 'sets the expected header' do
+      expect(subject.header).to eql(Relation::Header.coerce(header))
+    end
+  end
+
+  context 'without a Header' do
+    let(:options) { {} }
+
+    specify { expect { subject }.to raise_error }
+  end
+end

data/spec/unit/axiom/attribute/tuple/class_methods/type_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Attribute::Tuple, '.type' do
+  subject { object.type }
+
+  let(:object) { described_class }
+
+  it_should_behave_like 'an idempotent method'
+
+  it { should be(Types::Tuple) }
+end

data/spec/unit/axiom/attribute/tuple/header_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Attribute::Tuple, '#header' do
+  subject { object.header }
+
+  let(:object)  { described_class.new(:ids, options)        }
+  let(:options) { { header: header }                        }
+  let(:header)  { Relation::Header.coerce([[:id, Integer]]) }
+
+  it { should be(header) }
+end

data/spec/unit/axiom/equalizer/class_method/new_spec.rb

@@ -7,61 +7,49 @@ describe Axiom::Equalizer, '.new' do
   let(:name)   { 'User'          }
   let(:klass)  { ::Class.new     }
 
+  before do
+    # specify the class #name method
+    allow(klass).to receive(:name).and_return(name)
+    klass.send(:include, subject)
+  end
+
   context 'with no keys' do
     subject { object.new }
 
-    before do
-      # specify the class #name method
-      klass.stub(name: name)
-      klass.send(:include, subject)
-    end
-
     let(:instance) { klass.new }
 
     it { should be_instance_of(object) }
 
-    it 'defines #hash and #inspect methods dynamically' do
-      subject.public_instance_methods(false).map(&:to_s).should =~ %w[hash inspect]
-    end
-
     describe '#eql?' do
-      context 'when the objects are similar' do
-        let(:other) { instance.dup }
+      context 'when the objects are equivalent' do
+        let(:other) { klass.new }
 
-        it { instance.eql?(other).should be(true) }
+        it { expect(instance.eql?(other)).to be(true) }
       end
 
       context 'when the objects are different' do
         let(:other) { double('other') }
 
-        it { instance.eql?(other).should be(false) }
+        it { expect(instance.eql?(other)).to be(false) }
       end
     end
 
     describe '#==' do
-      context 'when the objects are similar' do
-        let(:other) { instance.dup }
+      context 'when the objects are equivalent' do
+        let(:other) { klass.new }
 
-        it { (instance == other).should be(true) }
+        it { expect(instance == other).to be(true) }
       end
 
       context 'when the objects are different' do
         let(:other) { double('other') }
 
-        it { (instance == other).should be(false) }
-      end
-    end
-
-    describe '#hash' do
-      it { instance.hash.should eql(klass.hash) }
-
-      it 'memoizes the hash code' do
-        instance.hash.should eql(instance.memoized(:hash))
+        it { expect(instance == other).to be(false) }
       end
     end
 
     describe '#inspect' do
-      it { instance.inspect.should eql('#<User>') }
+      it { expect(instance.inspect).to eql('#<User>') }
     end
   end
 
@@ -82,56 +70,38 @@ describe Axiom::Equalizer, '.new' do
       end
     end
 
-    before do
-      # specify the class #inspect method
-      klass.stub(name: nil, inspect: name)
-      klass.send(:include, subject)
-    end
-
     it { should be_instance_of(object) }
 
-    it 'defines #hash and #inspect methods dynamically' do
-      subject.public_instance_methods(false).map(&:to_s).should =~ %w[hash inspect]
-    end
-
     describe '#eql?' do
-      context 'when the objects are similar' do
-        let(:other) { instance.dup }
+      context 'when the objects are equivalent' do
+        let(:other) { klass.new(first_name) }
 
-        it { instance.eql?(other).should be(true) }
+        it { expect(instance.eql?(other)).to be(true) }
       end
 
       context 'when the objects are different' do
         let(:other) { double('other') }
 
-        it { instance.eql?(other).should be(false) }
+        it { expect(instance.eql?(other)).to be(false) }
       end
     end
 
     describe '#==' do
-      context 'when the objects are similar' do
-        let(:other) { instance.dup }
+      context 'when the objects are equivalent' do
+        let(:other) { klass.new(first_name) }
 
-        it { (instance == other).should be(true) }
+        it { expect(instance == other).to be(true) }
       end
 
       context 'when the objects are different' do
         let(:other) { double('other') }
 
-        it { (instance == other).should be(false) }
-      end
-    end
-
-    describe '#hash' do
-      it { instance.hash.should eql(klass.hash ^ first_name.hash) }
-
-      it 'memoizes the hash code' do
-        instance.hash.should eql(instance.memoized(:hash))
+        it { expect(instance == other).to be(false) }
       end
     end
 
     describe '#inspect' do
-      it { instance.inspect.should eql('#<User first_name="John">') }
+      it { expect(instance.inspect).to eql('#<User first_name="John">') }
     end
   end
 end