finitio 0.4.1 → 0.5.0

data/spec/type/multi_relation_type/test_equality.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+module Finitio
+  describe MultiRelationType, "equality" do
+
+    let(:h1){ Heading.new([Attribute.new(:r, intType), Attribute.new(:b, intType, false)]) }
+    let(:h2){ Heading.new([Attribute.new(:b, intType, false), Attribute.new(:r, intType)]) }
+    let(:h3){ Heading.new([Attribute.new(:b, intType)])                             }
+    let(:h4){ Heading.new([Attribute.new(:b, intType), Attribute.new(:r, intType)]) }
+
+    let(:type1)  { MultiRelationType.new(h1) }
+    let(:type2)  { MultiRelationType.new(h2) }
+    let(:type3)  { MultiRelationType.new(h3) }
+    let(:type4)  { MultiRelationType.new(h4) }
+
+    it 'should apply structural equality' do
+      expect(type1 == type2).to eq(true)
+      expect(type2 == type1).to eq(true)
+    end
+
+    it 'should apply distinguish different types' do
+      expect(type1 == type3).to eq(false)
+      expect(type2 == type3).to eq(false)
+      expect(type1 == type4).to eq(false)
+    end
+
+    it 'should be a total function, with false for non types' do
+      expect(type1 == 12).to eq(false)
+    end
+
+    it 'should implement hash accordingly' do
+      expect([type1, type2].map(&:hash).uniq.size).to eq(1)
+      expect(type1.hash).not_to eq(type4.hash)
+    end
+
+  end
+end

data/spec/type/multi_relation_type/test_include.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+module Finitio
+  describe MultiRelationType, "include?" do
+
+    let(:heading){
+      Heading.new([
+        Attribute.new(:a, intType),
+        Attribute.new(:b, intType, false)
+      ])
+    }
+
+    let(:type){ MultiRelationType.new(heading) }
+
+    subject{ type.include?(arg) }
+
+    context 'when a empty set' do
+      let(:arg){ Set.new }
+
+      it{ should eq(true) }
+    end
+
+    context 'when a valid, non empty set' do
+      let(:arg){ Set.new }
+
+      before do
+        arg << {a: 12, b: 15} << {a: 15, b: 16}
+      end
+
+      it{ should eq(true) }
+    end
+
+    context 'when a valid, non empty set but missing optionals' do
+      let(:arg){ Set.new }
+
+      before do
+        arg << {a: 12} << {a: 15, b: 16}
+      end
+
+      it{ should eq(true) }
+    end
+
+    context 'when not a set' do
+      let(:arg){ "foo" }
+
+      it{ should eq(false) }
+    end
+
+    context 'when a set containing invalid tuples' do
+      let(:arg){ Set.new }
+
+      before do
+        arg << {a: 12.0}
+      end
+
+      it{ should eq(false) }
+    end
+
+    context 'when a set containing tuples with missing required' do
+      let(:arg){ Set.new }
+
+      before do
+        arg << {b: 12}
+      end
+
+      it{ should eq(false) }
+    end
+
+    context 'when a set containing tuples with extra' do
+      let(:arg){ Set.new }
+
+      before do
+        arg << {a: 12, b: 12, c: 15}
+      end
+
+      it{ should eq(false) }
+    end
+
+    context 'when a set containing tuples with invalid optional' do
+      let(:arg){ Set.new }
+
+      before do
+        arg << {a: 12, b: 12.5}
+      end
+
+      it{ should eq(false) }
+    end
+
+  end
+end

data/spec/type/multi_relation_type/test_initialize.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+module Finitio
+  describe MultiRelationType, "initialize" do
+
+    let(:heading){
+      Heading.new([
+        Attribute.new(:a, intType),
+        Attribute.new(:b, intType, false)
+      ])
+    }
+
+    context 'with a valid heading' do
+      subject{ MultiRelationType.new(heading) }
+
+      it{ should be_a(MultiRelationType) }
+    end
+
+    context 'with an invalid heading' do
+      subject{ MultiRelationType.new("foo", "bar") }
+
+      it 'should raise an error' do
+        expect{
+          subject
+        }.to raise_error(ArgumentError, "Heading expected, got `foo`")
+      end
+    end
+
+  end
+end

data/spec/type/multi_relation_type/test_name.rb

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

data/spec/type/multi_tuple_type/test_default_name.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+module Finitio
+  describe MultiTupleType, "default_name" do
+
+    let(:heading){
+      Heading.new([
+        Attribute.new(:a, byte, true),
+        Attribute.new(:b, byte, false)
+      ])
+    }
+
+    subject{ MultiTupleType.new(heading).default_name }
+
+    it{ should eq("{a: Byte, b :? Byte}") }
+
+  end
+end

data/spec/type/multi_tuple_type/test_dress.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+module Finitio
+  describe MultiTupleType, "dress" do
+
+    let(:r)      { Attribute.new(:r, byte)        }
+    let(:g)      { Attribute.new(:g, byte)        }
+    let(:maybe_b){ Attribute.new(:b, byte, false) }
+
+    let(:type){
+      MultiTupleType.new(heading, "color")
+    }
+
+    subject{ type.dress(arg)  }
+
+    context 'when not allowing extra' do
+      let(:heading){
+        Heading.new([r, g, maybe_b])
+      }
+
+      context 'with a valid Hash' do
+        let(:arg){
+          { "r" => 12, "g" => 13, "b" => 255 }
+        }
+
+        it 'should coerce to a tuple' do
+          expect(subject).to eq(r: 12, g: 13, b: 255)
+        end
+      end
+
+      context 'with a valid Hash and no optional' do
+        let(:arg){
+          { "r" => 12, "g" => 13 }
+        }
+
+        it 'should coerce to a tuple' do
+          expect(subject).to eq(r: 12, g: 13)
+        end
+      end
+
+      context 'when raising an error' do
+
+        subject do
+          type.dress(arg) rescue $!
+        end
+
+        context 'with something else than a Hash' do
+          let(:arg){
+            "foo"
+          }
+
+          it 'should raise a TypeError' do
+            expect(subject).to be_a(TypeError)
+            expect(subject.message).to eq("Invalid color `foo`")
+          end
+
+          it 'should have no cause' do
+            expect(subject.cause).to be_nil
+          end
+
+          it 'should have an empty location' do
+            expect(subject.location).to eq('')
+          end
+        end
+
+        context 'with a missing attribute' do
+          let(:arg){
+            { "r" => 12, "b" => 13 }
+          }
+
+          it 'should raise a TypeError' do
+            expect(subject).to be_a(TypeError)
+            expect(subject.message).to eq("Missing attribute `g`")
+          end
+
+          it 'should have no cause' do
+            expect(subject.cause).to be_nil
+          end
+
+          it 'should have an empty location' do
+            expect(subject.location).to eq('')
+          end
+        end
+
+        context 'with an extra attribute' do
+          let(:arg){
+            { "r" => 12, "g" => 13, "extr" => 165 }
+          }
+
+          it 'should raise a TypeError' do
+            expect(subject).to be_a(TypeError)
+            expect(subject.message).to eq("Unrecognized attribute `extr`")
+          end
+
+          it 'should have no cause' do
+            expect(subject.cause).to be_nil
+          end
+
+          it 'should have an empty location' do
+            expect(subject.location).to eq('')
+          end
+        end
+
+        context 'with an invalid attribute' do
+          let(:arg){
+            { "r" => 12, "g" => 13, "b" => 255.0 }
+          }
+
+          it 'should raise a TypeError' do
+            expect(subject).to be_a(TypeError)
+            expect(subject.message).to eq("Invalid Byte `255.0`")
+          end
+
+          it 'should have the correct cause' do
+            expect(subject.cause).to be_a(TypeError)
+            expect(subject.cause.message).to eq("Invalid intType `255.0`")
+          end
+
+          it 'should have the correct location' do
+            expect(subject.location).to eq("b")
+          end
+        end
+      end
+    end
+
+    context 'when not allowing extra' do
+      let(:heading){
+        Heading.new([r, g, maybe_b], allow_extra: true)
+      }
+
+      context 'with an extra attribute' do
+        let(:arg){
+          { "r" => 12, "g" => 13, "extr" => 165 }
+        }
+
+        it 'should not raise a TypeError' do
+          expect(subject).not_to be_a(TypeError)
+        end
+
+        it 'should return a coerced/projection' do
+          expect(subject).to eq(r: 12, g: 13)
+        end
+      end
+    end
+
+  end
+end

data/spec/type/multi_tuple_type/test_equality.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+module Finitio
+  describe MultiTupleType, "equality" do
+
+    let(:h1){ Heading.new([Attribute.new(:r, intType, false), Attribute.new(:b, intType)]) }
+    let(:h2){ Heading.new([Attribute.new(:b, intType), Attribute.new(:r, intType, false)]) }
+    let(:h3){ Heading.new([Attribute.new(:b, intType)])                             }
+
+    let(:type1)  { MultiTupleType.new(h1) }
+    let(:type2)  { MultiTupleType.new(h2) }
+    let(:type3)  { MultiTupleType.new(h3) }
+
+    it 'should apply structural equality' do
+      expect(type1 == type2).to eq(true)
+      expect(type2 == type1).to eq(true)
+    end
+
+    it 'should apply distinguish different types' do
+      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
+      expect(type1 == 12).to eq(false)
+    end
+
+    it 'should implement hash accordingly' do
+      expect([type1, type2].map(&:hash).uniq.size).to eq(1)
+    end
+
+  end
+end

data/spec/type/multi_tuple_type/test_include.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+module Finitio
+  describe MultiTupleType, "include?" do
+
+    let(:a)      { Attribute.new(:a, intType)        }
+    let(:maybe_b){ Attribute.new(:b, intType, false) }
+
+    let(:type){ MultiTupleType.new(heading) }
+
+    subject{ type.include?(arg) }
+
+    context 'without extra allowed' do
+      let(:heading){
+        Heading.new([a, maybe_b])
+      }
+
+      context 'when a valid hash and both attributes' do
+        let(:arg){ {a: 12, b: 14} }
+
+        it{ should eq(true) }
+      end
+
+      context 'when a valid hash but no optional attribute' do
+        let(:arg){ {a: 12} }
+
+        it{ should eq(true) }
+      end
+
+      context 'when an invalid hash (too many attributes)' do
+        let(:arg){ {a: 12, c: 15} }
+
+        it{ should eq(false) }
+      end
+
+      context 'when an invalid hash (too few attributes)' do
+        let(:arg){ {b: 12} }
+
+        it{ should eq(false) }
+      end
+
+      context 'when an invalid hash (wrong type)' do
+        let(:arg){ {a: 12, b: 15.0} }
+
+        it{ should eq(false) }
+      end
+
+      context 'when an invalid hash (wrong type II)' do
+        let(:arg){ {a: 12.0, b: 15} }
+
+        it{ should eq(false) }
+      end
+    end
+
+    context 'with extra allowed' do
+      let(:heading){
+        Heading.new([a, maybe_b], allow_extra: true)
+      }
+
+      context 'when valid hash, yet with no extra attribute' do
+        let(:arg){ {a: 12} }
+
+        it{ should eq(true) }
+      end
+
+      context 'when valid hash, yet with extra attributes' do
+        let(:arg){ {a: 12, c: 15} }
+
+        it{ should eq(true) }
+      end
+    end
+
+  end
+end