finitio 0.7.0.pre.rc2 → 0.9.0

data/spec/heading/test_looks_similar.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+module Finitio
+  describe Heading, "looks_similar?" do
+
+    let(:heading){
+      Heading.new([Attribute.new(:a, intType),
+                   Attribute.new(:b, stringType)])
+    }
+
+    subject{
+      heading.looks_similar?(h2)
+    }
+
+    context 'when equal' do
+      let(:h2){ heading }
+
+      it 'says yes' do
+        expect(subject).to be_truthy
+      end
+    end
+
+    context 'when shared attributes are in majority' do
+      let(:h2){
+        Heading.new([Attribute.new(:a, intType),
+                     Attribute.new(:c, stringType)])
+      }
+
+      it 'says yes' do
+        expect(subject).to be_truthy
+      end
+    end
+
+    context 'when shared attributes are in minority' do
+      let(:h2){
+        Heading.new([Attribute.new(:d, intType),
+                     Attribute.new(:c, stringType)])
+      }
+
+      it 'says no' do
+        expect(subject).to be_falsy
+      end
+    end
+
+  end
+end

data/spec/heading/test_suppremum.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+module Finitio
+  describe Heading, "suppremum" do
+
+    subject{
+      left.suppremum(right)
+    }
+
+    let(:left){
+      Heading.new([Attribute.new(:a, intType),
+                   Attribute.new(:b, stringType)])
+    }
+
+    context 'when both are equal' do
+      let(:right){
+        Heading.new([Attribute.new(:a, intType),
+                     Attribute.new(:b, stringType)])
+      }
+
+      it 'works' do
+        expect(subject).to be(left)
+      end
+    end
+
+    context 'when they are different' do
+      let(:right){
+        Heading.new([Attribute.new(:a, nilType),
+                     Attribute.new(:b, stringType)])
+      }
+
+      it 'works' do
+        expect(subject).to be_a(Heading)
+        expect(subject[:a].type).to eql(UnionType.new [intType, nilType])
+        expect(subject[:b].type).to eql(stringType)
+      end
+    end
+
+    context 'when they are different II' do
+      let(:right){
+        Heading.new([Attribute.new(:c, nilType),
+                     Attribute.new(:b, stringType)])
+      }
+
+      it 'works' do
+        expect(subject).to be_a(Heading)
+        expect(subject[:a].type).to eql(intType)
+        expect(subject[:a].required).to eql(false)
+        expect(subject[:b].type).to eql(stringType)
+        expect(subject[:b].required).to eql(true)
+        expect(subject[:c].type).to eql(nilType)
+        expect(subject[:c].required).to eql(false)
+      end
+    end
+
+  end
+end

data/spec/inference/test_inference.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'finitio/inference'
+module Finitio
+  describe Inference do
+
+    let(:system) {
+      Finitio.system <<~FIO
+        @import finitio/data
+
+        Nil = .NilClass
+        Boolean = .TrueClass|.FalseClass
+        Integer = .Integer
+        Date = .Date <iso8601> .String \\( s | Date.iso8601(s) )
+                                       \\( d | d.iso8601       )
+        String = .String
+      FIO
+    }
+
+    let(:input) {
+      [
+        { "id" => 1, "createdAt" => "2018-01-12", "size" => "15", "priority" => "XL", "meta" => { foo: true, bar: "foo" }, "hobbies" => [] },
+        { "id" => 2, "createdAt" => "2019-02-23", "size" => "1",  "priority" => "L",  "meta" => { foo: true, bar: "baz" }, "hobbies" => ["testing"] },
+        { "id" => 3, "createdAt" => "2018-07-15", "size" => "7",  "priority" => "S",  "meta" => { foo: true, bar: "bar" } },
+        { "id" => 4, "createdAt" => "2019-12-12", "size" => "9",  "priority" => "M",  "meta" => { foo: true, baz: "baz" } },
+        { "id" => 4, "createdAt" => nil,          "size" => "9",  "priority" => "M"  },
+      ]
+    }
+
+    it 'works as expected' do
+      result = Inference.new(system).call(input)
+      expect(result).to be_a(SeqType)
+      expect(result.elm_type).to be_a(MultiTupleType)
+      expect(result.elm_type[:id].type.name).to eql("Integer")
+      expect(result.elm_type[:createdAt].type.name).to eql("Date|Nil")
+      expect(result.elm_type[:size].type.name).to eql("String")
+      expect(result.elm_type[:priority].type.name).to eql("String")
+
+      puts result
+    end
+
+  end
+end

data/spec/json_schema/test_ad_type.rb

@@ -0,0 +1,20 @@
+module Finitio
+  module JsonSchema
+    describe "AdType" do
+
+      let(:type) {
+        type = AdType.new(Color, [rgb_contract, hex_contract])
+      }
+
+      it 'works as expected' do
+        expect(type.to_json_schema).to eql({
+          anyOf: [
+            { type: "integer" },
+            { type: "string" }
+          ]
+        })
+      end
+
+    end
+  end
+end

data/spec/json_schema/test_alias_type.rb

@@ -0,0 +1,15 @@
+module Finitio
+  module JsonSchema
+    describe "AliasType" do
+
+      let(:alias_type) {
+        AliasType.new(anyType, "X")
+      }
+
+      it 'works as expected' do
+        expect(alias_type.to_json_schema).to eql({})
+      end
+
+    end
+  end
+end

data/spec/json_schema/test_any_type.rb

@@ -0,0 +1,11 @@
+module Finitio
+  module JsonSchema
+    describe "AnyType" do
+
+      it 'works as expected' do
+        expect(anyType.to_json_schema).to eql({})
+      end
+
+    end
+  end
+end

data/spec/json_schema/test_builtin_type.rb

@@ -0,0 +1,51 @@
+module Finitio
+  module JsonSchema
+    describe "BuiltinType" do
+
+      let(:builtin_type) {
+        BuiltinType.new(ruby_type)
+      }
+
+      subject {
+        builtin_type.to_json_schema
+      }
+
+      context 'with NilClass' do
+        let(:ruby_type){ NilClass }
+
+        it 'works' do
+          expect(subject).to eql({ type: "null" })
+        end
+      end
+
+      context 'with String' do
+        let(:ruby_type){ String }
+
+        it 'works' do
+          expect(subject).to eql({ type: "string" })
+        end
+      end
+
+      [Fixnum, Bignum, Integer].each do |rt|
+        context "with #{rt}" do
+          let(:ruby_type){ rt }
+
+          it 'works' do
+            expect(subject).to eql({ type: "integer" })
+          end
+        end
+      end
+
+      [Float, Numeric].each do |rt|
+        context "with #{rt}" do
+          let(:ruby_type){ rt }
+
+          it 'works' do
+            expect(subject).to eql({ type: "number" })
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/json_schema/test_multi_relation_type.rb

@@ -0,0 +1,58 @@
+module Finitio
+  module JsonSchema
+    describe "MultiRelationType" do
+
+      context 'with a true allow extra and some optional attribute' do
+        let(:heading){
+          Heading.new([
+            Attribute.new(:a, anyType),
+            Attribute.new(:b, anyType, false),
+          ], allow_extra: true)
+        }
+
+        let(:multi_relation_type) {
+          MultiRelationType.new(heading)
+        }
+
+        it 'works as expected' do
+          expect(multi_relation_type.to_json_schema).to eql({
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                a: {},
+                b: {}
+              },
+              required: [:a],
+              additionalProperties: {}
+            },
+            uniqueItems: true
+          })
+        end
+      end
+
+      context 'with a allow extra requiring Strings' do
+        let(:heading){
+          Heading.new([
+          ], allow_extra: BuiltinType.new(String))
+        }
+
+        let(:multi_relation_type) {
+          MultiRelationType.new(heading)
+        }
+
+        it 'works as expected' do
+          expect(multi_relation_type.to_json_schema).to eql({
+            type: "array",
+            items: {
+              type: "object",
+              additionalProperties: { type: "string" }
+            },
+            uniqueItems: true
+          })
+        end
+      end
+
+    end
+  end
+end

data/spec/json_schema/test_multi_tuple_type.rb

@@ -0,0 +1,50 @@
+module Finitio
+  module JsonSchema
+    describe "MultiTupleType" do
+
+      context 'with a true allow extra and some optional attribute' do
+        let(:heading){
+          Heading.new([
+            Attribute.new(:a, anyType),
+            Attribute.new(:b, anyType, false),
+          ], allow_extra: true)
+        }
+
+        let(:multi_tuple_type) {
+          MultiTupleType.new(heading)
+        }
+
+        it 'works as expected' do
+          expect(multi_tuple_type.to_json_schema).to eql({
+            type: "object",
+            properties: {
+              a: {},
+              b: {}
+            },
+            required: [:a],
+            additionalProperties: {}
+          })
+        end
+      end
+
+      context 'with a allow extra requiring Strings' do
+        let(:heading){
+          Heading.new([
+          ], allow_extra: BuiltinType.new(String))
+        }
+
+        let(:multi_tuple_type) {
+          MultiTupleType.new(heading)
+        }
+
+        it 'works as expected' do
+          expect(multi_tuple_type.to_json_schema).to eql({
+            type: "object",
+            additionalProperties: { type: "string" }
+          })
+        end
+      end
+
+    end
+  end
+end

data/spec/json_schema/test_relation_type.rb

@@ -0,0 +1,30 @@
+module Finitio
+  module JsonSchema
+    describe "RelationType" do
+
+      let(:heading){
+        Heading.new([Attribute.new(:a, anyType)])
+      }
+
+      let(:tuple_type) {
+        RelationType.new(heading)
+      }
+
+      it 'works as expected' do
+        expect(tuple_type.to_json_schema).to eql({
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              a: {}
+            },
+            required: [:a],
+            additionalProperties: false
+          },
+          uniqueItems: true
+        })
+      end
+
+    end
+  end
+end

data/spec/json_schema/test_seq_type.rb

@@ -0,0 +1,18 @@
+module Finitio
+  module JsonSchema
+    describe "SeqType" do
+
+      let(:type) {
+        SeqType.new(anyType)
+      }
+
+      it 'works as expected' do
+        expect(type.to_json_schema).to eql({
+          type: "array",
+          items: {}
+        })
+      end
+
+    end
+  end
+end

data/spec/json_schema/test_set_type.rb

@@ -0,0 +1,19 @@
+module Finitio
+  module JsonSchema
+    describe "SetType" do
+
+      let(:type) {
+        SetType.new(anyType)
+      }
+
+      it 'works as expected' do
+        expect(type.to_json_schema).to eql({
+          type: "array",
+          items: {},
+          uniqueItems: true
+        })
+      end
+
+    end
+  end
+end

data/spec/json_schema/test_struct_type.rb

@@ -0,0 +1,18 @@
+module Finitio
+  module JsonSchema
+    describe "StructType" do
+
+      let(:type) {
+        StructType.new([anyType,anyType])
+      }
+
+      it 'works as expected' do
+        expect(type.to_json_schema).to eql({
+          type: "array",
+          items: [{},{}]
+        })
+      end
+
+    end
+  end
+end