finitio 0.4.1 → 0.5.0

data/spec/type/multi_tuple_type/test_initialize.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+module Finitio
+  describe MultiTupleType, "initialize" do
+
+    let(:heading){
+      Heading.new([Attribute.new(:a, intType)])
+    }
+
+    context 'with a valid heading' do
+      subject{ MultiTupleType.new(heading) }
+
+      it{ should be_a(MultiTupleType) }
+
+      it 'correctly sets the instance variable' do
+        expect(subject.heading).to eq(heading)
+      end
+    end
+
+    context 'with an invalid heading' do
+      subject{ MultiTupleType.new("foo") }
+
+      it 'should raise an error' do
+        expect{
+          subject
+        }.to raise_error(ArgumentError, "Heading expected, got `foo`")
+      end
+    end
+
+  end
+end

data/spec/type/multi_tuple_type/test_name.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+module Finitio
+  describe MultiTupleType, "name" do
+
+    let(:heading){
+      Heading.new([Attribute.new(:a, byte, false)])
+    }
+
+    subject{ type.name }
+
+    context 'when not provided' do
+      let(:type){ MultiTupleType.new(heading) }
+
+      it{ should eq("{a :? Byte}") }
+    end
+
+    context 'when provided' do
+      let(:type){ MultiTupleType.new(heading, "Color") }
+
+      it{ should eq("Color") }
+    end
+
+  end
+end

data/spec/type/proxy_type/test_delegation.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+module Finitio
+  describe ProxyType, "delegation pattern" do
+
+    let(:proxy){ ProxyType.new('Int', intType) }
+
+    it 'should delegate name' do
+      expect(proxy.name).to eq(intType.name)
+    end
+
+    it 'should delegate default_name' do
+      expect(proxy.default_name).to eq(intType.default_name)
+    end
+
+    it 'should delegate hash' do
+      expect(proxy.hash).to eq(intType.hash)
+    end
+
+    it 'should delegate ==' do
+      expect(intType == proxy).to eq(true)
+      expect(proxy == intType).to eq(true)
+    end
+
+    it 'should delegate dress' do
+      expect(proxy.dress(12)).to eq(12)
+    end
+
+    it 'should delegate include?' do
+      expect(proxy.include?(12)).to eq(true)
+    end
+
+    it 'should delegate to_s' do
+      expect(proxy.to_s).to eq(intType.to_s)
+    end
+
+  end
+end

data/spec/type/proxy_type/test_resolve.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+module Finitio
+  describe ProxyType, "delegation pattern" do
+
+    let(:proxy){ ProxyType.new('Int') }
+
+    subject{ proxy.resolve(system) }
+
+    context 'when type exists' do
+      let(:system){ {'Int' => intType} }
+
+      it 'resolves fine' do
+        subject
+        expect(proxy.target).to eq(intType)
+      end
+    end
+
+    context 'when type does not exist' do
+      let(:system){ {} }
+
+      it 'raises an error' do
+        expect{
+          subject
+        }.to raise_error(Finitio::Error, "No such type `Int`")
+      end
+    end
+
+  end
+end

data/spec/{unit/type → type}/relation_type/test_dress.rb

@@ -29,8 +29,8 @@ module Finitio
       }
 
       it 'should coerce to an Enumerable of tuples' do
-        subject.should be_a(Enumerable)
-        subject.to_a.should eq(expected)
+        expect(subject).to be_a(Enumerable)
+        expect(subject.to_a).to eq(expected)
       end
     end
 
@@ -43,8 +43,8 @@ module Finitio
       }
 
       it 'should coerce to an Enumerable of tuples' do
-        subject.should be_a(Enumerable)
-        subject.to_a.should eq(expected)
+        expect(subject).to be_a(Enumerable)
+        expect(subject.to_a).to eq(expected)
       end
     end
 
@@ -60,16 +60,16 @@ module Finitio
         }
 
         it 'should raise a TypeError' do
-          subject.should be_a(TypeError)
-          subject.message.should eq("Invalid value `foo` for colors")
+          expect(subject).to be_a(TypeError)
+          expect(subject.message).to eq("Invalid colors `foo`")
         end
 
         it 'should have no cause' do
-          subject.cause.should be_nil
+          expect(subject.cause).to be_nil
         end
 
         it 'should have an empty location' do
-          subject.location.should eq('')
+          expect(subject.location).to eq('')
         end
       end
 
@@ -79,16 +79,16 @@ module Finitio
         }
 
         it 'should raise a TypeError' do
-          subject.should be_a(TypeError)
-          subject.message.should eq("Invalid value `foo` for {r: Byte, g: Byte, b: Byte}")
+          expect(subject).to be_a(TypeError)
+          expect(subject.message).to eq("Invalid {r: Byte, g: Byte, b: Byte} `foo`")
         end
 
         it 'should have no cause' do
-          subject.cause.should be_nil
+          expect(subject.cause).to be_nil
         end
 
         it 'should have the correct location' do
-          subject.location.should eq('0')
+          expect(subject.location).to eq('0')
         end
       end
 
@@ -101,16 +101,16 @@ module Finitio
         }
 
         it 'should raise a TypeError' do
-          subject.should be_a(TypeError)
-          subject.message.should eq("Missing attribute `b`")
+          expect(subject).to be_a(TypeError)
+          expect(subject.message).to eq("Missing attribute `b`")
         end
 
         it 'should have no cause' do
-          subject.cause.should be_nil
+          expect(subject.cause).to be_nil
         end
 
         it 'should have the correct location' do
-          subject.location.should eq('1')
+          expect(subject.location).to eq('1')
         end
       end
 
@@ -123,16 +123,16 @@ module Finitio
         }
 
         it 'should raise a TypeError' do
-          subject.should be_a(TypeError)
-          subject.message.should eq("Invalid value `12.0` for Byte")
+          expect(subject).to be_a(TypeError)
+          expect(subject.message).to eq("Invalid Byte `12.0`")
         end
 
         it 'should have a cause' do
-          subject.cause.should_not be_nil
+          expect(subject.cause).not_to be_nil
         end
 
         it 'should have the correct location' do
-          subject.location.should eq('1/b')
+          expect(subject.location).to eq('1/b')
         end
       end
 
@@ -146,16 +146,16 @@ module Finitio
         }
 
         it 'should raise a TypeError' do
-          subject.should be_a(TypeError)
-          subject.message.should eq("Duplicate tuple")
+          expect(subject).to be_a(TypeError)
+          expect(subject.message).to eq("Duplicate tuple")
         end
 
         it 'should have no cause' do
-          subject.cause.should be_nil
+          expect(subject.cause).to be_nil
         end
 
         it 'should have the correct location' do
-          subject.location.should eq('2')
+          expect(subject.location).to eq('2')
         end
       end
     end

data/spec/{unit/type → type}/relation_type/test_equality.rb

@@ -11,21 +11,21 @@ module Finitio
     let(:type3)  { RelationType.new(h3) }
 
     it 'should apply structural equality' do
-      (type1 == type2).should be_true
-      (type2 == type1).should be_true
+      expect(type1 == type2).to eq(true)
+      expect(type2 == type1).to eq(true)
     end
 
     it 'should apply distinguish different types' do
-      (type1 == type3).should be_false
-      (type2 == type3).should be_false
+      expect(type1 == type3).to eq(false)
+      expect(type2 == type3).to eq(false)
     end
 
     it 'should be a total function, with nil for non types' do
-      (type1 == 12).should be_false
+      expect(type1 == 12).to eq(false)
     end
 
     it 'should implement hash accordingly' do
-      [type1, type2].map(&:hash).uniq.size.should eq(1)
+      expect([type1, type2].map(&:hash).uniq.size).to eq(1)
     end
 
   end

data/spec/{unit/type → type}/relation_type/test_include.rb

@@ -13,7 +13,7 @@ module Finitio
     context 'when a empty set' do
       let(:arg){ Set.new }
 
-      it{ should be_true }
+      it{ should eq(true) }
     end
 
     context 'when a valid, non empty set' do
@@ -23,13 +23,13 @@ module Finitio
         arg << {a: 12} << {a: 15}
       end
 
-      it{ should be_true }
+      it{ should eq(true) }
     end
 
     context 'when not a set' do
       let(:arg){ "foo" }
 
-      it{ should be_false }
+      it{ should eq(false) }
     end
 
     context 'when a set containing invalid tuples' do
@@ -39,7 +39,7 @@ module Finitio
         arg << {a: 12.0}
       end
 
-      it{ should be_false }
+      it{ should eq(false) }
     end
 
   end

data/spec/{unit/type → type}/relation_type/test_initialize.rb

@@ -16,9 +16,9 @@ module Finitio
       subject{ RelationType.new("foo", "bar") }
 
       it 'should raise an error' do
-        ->{
+        expect{
           subject
-        }.should raise_error(ArgumentError, "Heading expected, got `foo`")
+        }.to raise_error(ArgumentError, "Heading expected, got `foo`")
       end
     end
 

data/spec/{unit/type → type}/seq_type/test_dress.rb

@@ -22,9 +22,9 @@ module Finitio
       let(:arg){ "foo" }
 
       it 'should raise an error' do
-        ->{
+        expect{
           subject
-        }.should raise_error("Invalid value `foo` for [Byte]")
+        }.to raise_error("Invalid [Byte] `foo`")
       end
     end
 
@@ -36,12 +36,12 @@ module Finitio
       }
 
       it 'should raise an error' do
-        subject.should be_a(TypeError)
-        subject.message.should eq("Invalid value `-12` for Byte")
+        expect(subject).to be_a(TypeError)
+        expect(subject.message).to eq("Invalid Byte `-12`")
       end
 
       it 'should have correct location' do
-        subject.location.should eq("2")
+        expect(subject.location).to eq("2")
       end
     end
 

data/spec/{unit/type → type}/seq_type/test_equality.rb

@@ -7,19 +7,19 @@ module Finitio
     let(:type3){ SeqType.new(floatType) }
 
     it 'should apply structural equality' do
-      (type == type2).should be_true
+      expect(type == type2).to eq(true)
     end
 
     it 'should apply distinguish different types' do
-      (type == type3).should be_false
+      expect(type == type3).to eq(false)
     end
 
     it 'should be a total function, with false for non types' do
-      (type == 12).should be_false
+      expect(type == 12).to eq(false)
     end
 
     it 'should implement hash accordingly' do
-      (type.hash == type2.hash).should be_true
+      expect(type.hash == type2.hash).to eq(true)
     end
 
   end

data/spec/{unit/type → type}/seq_type/test_include.rb

@@ -9,7 +9,7 @@ module Finitio
     context 'when included on empty array' do
       let(:arg){ [] }
 
-      it{ should be_true }
+      it{ should eq(true) }
     end
 
     context 'when included on non empty array' do
@@ -19,13 +19,13 @@ module Finitio
         arg << 12
       end
 
-      it{ should be_true }
+      it{ should eq(true) }
     end
 
     context 'when not an array' do
       let(:arg){ Set.new }
 
-      it{ should be_false }
+      it{ should eq(false) }
     end
 
     context 'when an array with non ints' do
@@ -36,7 +36,7 @@ module Finitio
         arg << "foo"
       end
 
-      it{ should be_false }
+      it{ should eq(false) }
     end
 
   end

data/spec/{unit/type → type}/seq_type/test_initialize.rb

@@ -10,7 +10,7 @@ module Finitio
       it{ should be_a(SeqType) }
 
       it 'should set the instance variables' do
-        subject.elm_type.should eq(intType)
+        expect(subject.elm_type).to eq(intType)
       end
     end
 
@@ -18,9 +18,9 @@ module Finitio
       subject{ SeqType.new("foo") }
 
       it 'should raise an error' do
-        ->{
+        expect{
           subject
-        }.should raise_error(ArgumentError, 'Finitio::Type expected, got `foo`')
+        }.to raise_error(ArgumentError, 'Finitio::Type expected, got `foo`')
       end
     end
 

data/spec/{unit/type → type}/set_type/test_dress.rb

@@ -22,9 +22,9 @@ module Finitio
       let(:arg){ "foo" }
 
       it 'should raise an error' do
-        ->{
+        expect{
           subject
-        }.should raise_error("Invalid value `foo` for {Byte}")
+        }.to raise_error("Invalid {Byte} `foo`")
       end
     end
 
@@ -36,12 +36,12 @@ module Finitio
       }
 
       it 'should raise an error' do
-        subject.should be_a(TypeError)
-        subject.message.should eq("Invalid value `-12` for Byte")
+        expect(subject).to be_a(TypeError)
+        expect(subject.message).to eq("Invalid Byte `-12`")
       end
 
       it 'should have correct location' do
-        subject.location.should eq("2")
+        expect(subject.location).to eq("2")
       end
     end
 
@@ -53,12 +53,12 @@ module Finitio
       }
 
       it 'should raise an error' do
-        subject.should be_a(TypeError)
-        subject.message.should eq("Duplicate value `2`")
+        expect(subject).to be_a(TypeError)
+        expect(subject.message).to eq("Duplicate value `2`")
       end
 
       it 'should have correct location' do
-        subject.location.should eq("2")
+        expect(subject.location).to eq("2")
       end
     end