qrb 0.1.0

data/spec/unit/type/builtin_type/test_name.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+module Qrb
+  describe BuiltinType, "name" do
+
+    subject{ type.name }
+
+    context 'when not provided' do
+      let(:type){ BuiltinType.new(Integer) }
+
+      it 'uses the default name' do
+        subject.should eq("Integer")
+      end
+    end
+
+    context 'when provided' do
+      let(:type){ BuiltinType.new(Integer, "int") }
+
+      it 'uses the specified name' do
+        subject.should eq("int")
+      end
+    end
+
+  end
+end

data/spec/unit/type/relation_type/test_default_name.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+module Qrb
+  describe RelationType, "default_name" do
+
+    let(:heading){
+      Heading.new([Attribute.new(:a, byte)])
+    }
+
+    subject{ type.default_name }
+
+    let(:type){ RelationType.new(heading) }
+
+    it{ should eq("{{a: Byte}}") }
+
+  end
+end

data/spec/unit/type/relation_type/test_dress.rb

@@ -0,0 +1,164 @@
+require 'spec_helper'
+module Qrb
+  describe RelationType, "dress" do
+
+    let(:heading){
+      Heading.new([Attribute.new(:r, byte),
+                   Attribute.new(:g, byte),
+                   Attribute.new(:b, byte)])
+    }
+
+    let(:type){
+      RelationType.new(heading, "colors")
+    }
+
+    subject{ type.dress(arg)  }
+
+    context 'with a valid array of Hashes' do
+      let(:arg){
+        [
+          { "r" => 12, "g" => 13, "b" => 255 },
+          { "r" => 12, "g" => 15, "b" => 198 }
+        ]
+      }
+      let(:expected){
+        [
+          { r: 12, g: 13, b: 255 },
+          { r: 12, g: 15, b: 198 }
+        ]
+      }
+
+      it 'should coerce to an Enumerable of tuples' do
+        subject.should be_a(Enumerable)
+        subject.to_a.should eq(expected)
+      end
+    end
+
+    context 'with an empty array' do
+      let(:arg){
+        []
+      }
+      let(:expected){
+        []
+      }
+
+      it 'should coerce to an Enumerable of tuples' do
+        subject.should be_a(Enumerable)
+        subject.to_a.should eq(expected)
+      end
+    end
+
+    context 'when raising an error' do
+
+      subject do
+        type.dress(arg) rescue $!
+      end
+
+      context 'with something else than an Array' do
+        let(:arg){
+          "foo"
+        }
+
+        it 'should raise a TypeError' do
+          subject.should be_a(TypeError)
+          subject.message.should eq("Invalid value `foo` for colors")
+        end
+
+        it 'should have no cause' do
+          subject.cause.should be_nil
+        end
+
+        it 'should have an empty location' do
+          subject.location.should eq('')
+        end
+      end
+
+      context 'with Array of non-tuples' do
+        let(:arg){
+          ["foo"]
+        }
+
+        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}")
+        end
+
+        it 'should have no cause' do
+          subject.cause.should be_nil
+        end
+
+        it 'should have the correct location' do
+          subject.location.should eq('0')
+        end
+      end
+
+      context 'with a wrong tuple' do
+        let(:arg){
+          [
+            { "r" => 12, "g" => 13, "b" => 255 },
+            { "r" => 12, "g" => 13 }
+          ]
+        }
+
+        it 'should raise a TypeError' do
+          subject.should be_a(TypeError)
+          subject.message.should eq("Missing attribute `b`")
+        end
+
+        it 'should have no cause' do
+          subject.cause.should be_nil
+        end
+
+        it 'should have the correct location' do
+          subject.location.should eq('1')
+        end
+      end
+
+      context 'with a wrong tuple attribute' do
+        let(:arg){
+          [
+            { "r" => 12, "g" => 13, "b" => 255  },
+            { "r" => 12, "g" => 13, "b" => 12.0 }
+          ]
+        }
+
+        it 'should raise a TypeError' do
+          subject.should be_a(TypeError)
+          subject.message.should eq("Invalid value `12.0` for Byte")
+        end
+
+        it 'should have a cause' do
+          subject.cause.should_not be_nil
+        end
+
+        it 'should have the correct location' do
+          subject.location.should eq('1/b')
+        end
+      end
+
+      context 'with a duplicate tuple' do
+        let(:arg){
+          [
+            { "r" => 12, "g" => 13, "b" => 255 },
+            { "r" => 12, "g" => 192, "b" => 13 },
+            { "r" => 12, "g" => 13, "b" => 255 }
+          ]
+        }
+
+        it 'should raise a TypeError' do
+          subject.should be_a(TypeError)
+          subject.message.should eq("Duplicate tuple")
+        end
+
+        it 'should have no cause' do
+          subject.cause.should be_nil
+        end
+
+        it 'should have the correct location' do
+          subject.location.should eq('2')
+        end
+      end
+    end
+
+  end
+end

data/spec/unit/type/relation_type/test_equality.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+module Qrb
+  describe RelationType, "equality" do
+
+    let(:h1){ Heading.new([Attribute.new(:r, intType), Attribute.new(:b, intType)]) }
+    let(:h2){ Heading.new([Attribute.new(:b, intType), Attribute.new(:r, intType)]) }
+    let(:h3){ Heading.new([Attribute.new(:b, intType)])                             }
+
+    let(:type1)  { RelationType.new(h1) }
+    let(:type2)  { RelationType.new(h2) }
+    let(:type3)  { RelationType.new(h3) }
+
+    it 'should apply structural equality' do
+      (type1 == type2).should be_true
+      (type2 == type1).should be_true
+    end
+
+    it 'should apply distinguish different types' do
+      (type1 == type3).should be_false
+      (type2 == type3).should be_false
+    end
+
+    it 'should be a total function, with nil for non types' do
+      (type1 == 12).should be_false
+    end
+
+    it 'should implement hash accordingly' do
+      [type1, type2].map(&:hash).uniq.size.should eq(1)
+    end
+
+  end
+end

data/spec/unit/type/relation_type/test_include.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+module Qrb
+  describe RelationType, "include?" do
+
+    let(:heading){
+      Heading.new([Attribute.new(:a, intType)])
+    }
+
+    let(:type){ RelationType.new(heading) }
+
+    subject{ type.include?(arg) }
+
+    context 'when a empty set' do
+      let(:arg){ Set.new }
+
+      it{ should be_true }
+    end
+
+    context 'when a valid, non empty set' do
+      let(:arg){ Set.new }
+
+      before do
+        arg << {a: 12} << {a: 15}
+      end
+
+      it{ should be_true }
+    end
+
+    context 'when not a set' do
+      let(:arg){ "foo" }
+
+      it{ should be_false }
+    end
+
+    context 'when a set containing invalid tuples' do
+      let(:arg){ Set.new }
+
+      before do
+        arg << {a: 12.0}
+      end
+
+      it{ should be_false }
+    end
+
+  end
+end

data/spec/unit/type/relation_type/test_initialize.rb

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

data/spec/unit/type/relation_type/test_name.rb

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

data/spec/unit/type/seq_type/test_default_name.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+module Qrb
+  describe SeqType, 'default_name' do
+
+    let(:type){
+      SeqType.new(intType, "foo")
+    }
+
+    subject{ type.default_name }
+
+    it{ should eq('[intType]') }
+
+  end
+end

data/spec/unit/type/seq_type/test_dress.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+module Qrb
+  describe SeqType, 'dress' do
+
+    let(:type){ SeqType.new(byte) }
+
+    subject{ type.dress(arg) }
+
+    context 'with an empty array' do
+      let(:arg){ [] }
+
+      it{ should eq([]) }
+    end
+
+    context 'with a valid array' do
+      let(:arg){ [12, 16] }
+
+      it{ should eq([12, 16]) }
+    end
+
+    context 'with not a enumerable' do
+      let(:arg){ "foo" }
+
+      it 'should raise an error' do
+        ->{
+          subject
+        }.should raise_error("Invalid value `foo` for [Byte]")
+      end
+    end
+
+    context 'with an array with non bytes' do
+      let(:arg){ [2, 4, -12] }
+
+      subject{
+        type.dress(arg) rescue $!
+      }
+
+      it 'should raise an error' do
+        subject.should be_a(TypeError)
+        subject.message.should eq("Invalid value `-12` for Byte")
+      end
+
+      it 'should have correct location' do
+        subject.location.should eq("2")
+      end
+    end
+
+  end
+end

data/spec/unit/type/seq_type/test_equality.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+module Qrb
+  describe SeqType, "equality" do
+
+    let(:type) { SeqType.new(intType)   }
+    let(:type2){ SeqType.new(intType)   }
+    let(:type3){ SeqType.new(floatType) }
+
+    it 'should apply structural equality' do
+      (type == type2).should be_true
+    end
+
+    it 'should apply distinguish different types' do
+      (type == type3).should be_false
+    end
+
+    it 'should be a total function, with false for non types' do
+      (type == 12).should be_false
+    end
+
+    it 'should implement hash accordingly' do
+      (type.hash == type2.hash).should be_true
+    end
+
+  end
+end

data/spec/unit/type/seq_type/test_include.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+module Qrb
+  describe SeqType, "include?" do
+
+    let(:type){ SeqType.new(intType) }
+
+    subject{ type.include?(arg) }
+
+    context 'when included on empty array' do
+      let(:arg){ [] }
+
+      it{ should be_true }
+    end
+
+    context 'when included on non empty array' do
+      let(:arg){ [] }
+
+      before do
+        arg << 12
+      end
+
+      it{ should be_true }
+    end
+
+    context 'when not an array' do
+      let(:arg){ Set.new }
+
+      it{ should be_false }
+    end
+
+    context 'when an array with non ints' do
+      let(:arg){ [] }
+
+      before do
+        arg << 12
+        arg << "foo"
+      end
+
+      it{ should be_false }
+    end
+
+  end
+end

data/spec/unit/type/seq_type/test_initialize.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+module Qrb
+  describe SeqType, 'initialize' do
+
+    subject{
+      SeqType.new(intType)
+    }
+
+    context 'with valid arguments' do
+      it{ should be_a(SeqType) }
+
+      it 'should set the instance variables' do
+        subject.elm_type.should eq(intType)
+      end
+    end
+
+    context 'with invalid arguments' do
+      subject{ SeqType.new("foo") }
+
+      it 'should raise an error' do
+        ->{
+          subject
+        }.should raise_error(ArgumentError, 'Qrb::Type expected, got `foo`')
+      end
+    end
+
+  end
+end

data/spec/unit/type/seq_type/test_name.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+module Qrb
+  describe SeqType, 'name' do
+
+    subject{ type.name }
+
+    context 'when not specified' do
+      let(:type){
+        SeqType.new(intType)
+      }
+
+      it{ should eq('[intType]') }
+    end
+
+    context 'when specified' do
+      let(:type){
+        SeqType.new(intType, "foo")
+      }
+
+      it{ should eq('foo') }
+    end
+
+  end
+end

data/spec/unit/type/set_type/test_default_name.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+module Qrb
+  describe SetType, 'default_name' do
+
+    let(:type){
+      SetType.new(intType, "foo")
+    }
+
+    subject{ type.default_name }
+
+    it{ should eq('{intType}') }
+
+  end
+end

data/spec/unit/type/set_type/test_dress.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+module Qrb
+  describe SetType, 'dress' do
+
+    let(:type){ SetType.new(byte) }
+
+    subject{ type.dress(arg) }
+
+    context 'with an empty array' do
+      let(:arg){ [] }
+
+      it{ should eq([].to_set) }
+    end
+
+    context 'with a valid array' do
+      let(:arg){ [12, 16] }
+
+      it{ should eq([12, 16].to_set) }
+    end
+
+    context 'with not a enumerable' do
+      let(:arg){ "foo" }
+
+      it 'should raise an error' do
+        ->{
+          subject
+        }.should raise_error("Invalid value `foo` for {Byte}")
+      end
+    end
+
+    context 'with an array with non bytes' do
+      let(:arg){ [2, 4, -12] }
+
+      subject{
+        type.dress(arg) rescue $!
+      }
+
+      it 'should raise an error' do
+        subject.should be_a(TypeError)
+        subject.message.should eq("Invalid value `-12` for Byte")
+      end
+
+      it 'should have correct location' do
+        subject.location.should eq("2")
+      end
+    end
+
+    context 'with an array with duplicates' do
+      let(:arg){ [2, 4, 2] }
+
+      subject{
+        type.dress(arg) rescue $!
+      }
+
+      it 'should raise an error' do
+        subject.should be_a(TypeError)
+        subject.message.should eq("Duplicate value `2`")
+      end
+
+      it 'should have correct location' do
+        subject.location.should eq("2")
+      end
+    end
+
+  end
+end

data/spec/unit/type/set_type/test_equality.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+module Qrb
+  describe SetType, "equality" do
+
+    let(:type) { SetType.new(intType)   }
+    let(:type2){ SetType.new(intType)   }
+    let(:type3){ SetType.new(floatType) }
+
+    it 'should apply structural equality' do
+      (type == type2).should be_true
+    end
+
+    it 'should apply distinguish different types' do
+      (type == type3).should be_false
+    end
+
+    it 'should be a total function, with false for non types' do
+      (type == 12).should be_false
+    end
+
+    it 'should implement hash accordingly' do
+      (type.hash == type2.hash).should be_true
+    end
+
+  end
+end

data/spec/unit/type/set_type/test_include.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+module Qrb
+  describe SetType, "include?" do
+
+    let(:type){ SetType.new(intType) }
+
+    subject{ type.include?(arg) }
+
+    context 'when included on empty set' do
+      let(:arg){ Set.new }
+
+      it{ should be_true }
+    end
+
+    context 'when included on non empty set' do
+      let(:arg){ Set.new }
+
+      before do
+        arg << 12
+      end
+
+      it{ should be_true }
+    end
+
+    context 'when not a set' do
+      let(:arg){ [] }
+
+      it{ should be_false }
+    end
+
+    context 'when a set with non ints' do
+      let(:arg){ Set.new }
+
+      before do
+        arg << 12
+        arg << "foo"
+      end
+
+      it{ should be_false }
+    end
+
+  end
+end