compel 0.1.3 → 0.2.0

data/spec/compel/builder_spec.rb

@@ -0,0 +1,226 @@
+describe Compel::Builder do
+
+  context 'Schema' do
+
+    subject(:builder) { Compel::Builder::String.new }
+
+    it 'shoudl' do
+      object = {
+        first_name: 'Joaquim',
+        birth_date: '1989-0',
+        address: {
+          line_one: 'Lisboa',
+          post_code: '1100',
+          country_code: 'PT'
+        }
+      }
+
+      schema = Compel.hash.keys({
+        first_name: Compel.string.required,
+        last_name: Compel.string.required,
+        birth_date: Compel.date.iso8601,
+        address: Compel.hash.keys({
+          line_one: Compel.string.required,
+          line_two: Compel.string.default('-'),
+          post_code: Compel.string.format(/^\d{4}-\d{3}$/).required,
+          country_code: Compel.string.in(['PT', 'GB']).default('PT')
+        })
+      })
+
+      result = Compel.run(object, schema)
+
+      expect(result).to \
+        eq({
+          "first_name" => "Joaquim",
+          "birth_date" => "1989-0",
+          "address" => {
+            "line_one" => "Lisboa",
+            "post_code" => "1100",
+            "country_code" => "PT",
+            "line_two" => "-"
+          },
+          "errors" => {
+            "last_name" => ["is required"],
+            "birth_date" => ["'1989-0' is not a parsable date with format: %Y-%m-%d"],
+            "address" => {
+              "post_code" => ["must match format ^\\d{4}-\\d{3}$"]
+            }
+          }
+        })
+    end
+
+    it 'should build new Schema for givin type' do
+      expect(builder.type).to be(Compel::Coercion::String)
+      expect(builder.options.keys).to eq([])
+      expect(builder.required?).to be false
+      expect(builder.default_value).to be nil
+    end
+
+    it 'should build Schema' do
+      schema = Compel.hash.keys({
+        a: Compel.float,
+        b: Compel.string,
+        c: Compel.hash.keys({
+          cc: Compel.integer.length(1)
+        }),
+        d: Compel.json,
+        e: Compel.time,
+        f: Compel.datetime,
+        g: Compel.date,
+        h: Compel.integer
+      })
+
+      keys_schemas = schema.options[:keys]
+
+      expect(keys_schemas.a.type).to be Compel::Coercion::Float
+      expect(keys_schemas.b.type).to be Compel::Coercion::String
+      expect(keys_schemas.c.type).to be Compel::Coercion::Hash
+      expect(keys_schemas.d.type).to be Compel::Coercion::JSON
+      expect(keys_schemas.e.type).to be Compel::Coercion::Time
+      expect(keys_schemas.f.type).to be Compel::Coercion::DateTime
+      expect(keys_schemas.g.type).to be Compel::Coercion::Date
+      expect(keys_schemas.h.type).to be Compel::Coercion::Integer
+    end
+
+    it 'should validate hash object from schema' do
+      schema = Compel.hash.keys({
+        a: Compel.float.required
+      })
+
+      expect(schema.validate({ a: nil }).errors.a).to \
+        include('is required')
+    end
+
+    context 'Builder::CommonValue' do
+
+      context '#in, #range, #min, #max' do
+
+        it 'should have value' do
+          [:in, :range, :min, :max].each do |method|
+            builder.send(method, "#{method}")
+            expect(builder.options[method]).to eq("#{method}")
+          end
+        end
+
+      end
+
+    end
+
+    context 'Builder::Common' do
+
+      context '#is, #default' do
+
+        it 'should have value' do
+          [:is, :default].each do |method|
+            builder.send(method, "#{method}")
+            expect(builder.options[method]).to eq("#{method}")
+          end
+        end
+
+      end
+
+      context '#required' do
+
+        it 'should be false' do
+          expect(builder.required?).to be false
+        end
+
+        it 'should be true' do
+          builder.required
+
+          expect(builder.required?).to be true
+        end
+
+      end
+
+      context '#length' do
+
+        it 'should have value' do
+          builder.length(5)
+
+          expect(builder.options[:length]).to be 5
+        end
+
+        it 'should raise exception for invalid type' do
+          expect { builder.length('abc') }.to \
+            raise_error Compel::TypeError, "'abc' is not a valid Integer"
+        end
+
+      end
+
+    end
+
+    context 'Date' do
+
+      subject(:builder) { Compel::Builder::Date.new }
+
+      context '#format' do
+
+        it 'should have value' do
+          builder.format('%d-%m-%Y')
+
+          expect(builder.options[:format]).to eq('%d-%m-%Y')
+        end
+
+        it 'should have value' do
+          builder.iso8601
+
+          expect(builder.options[:format]).to eq('%Y-%m-%d')
+        end
+
+      end
+
+    end
+
+    context 'String' do
+
+      context '#format' do
+
+        it 'should raise exception for invalid type' do
+          expect { builder.format('abc') }.to \
+            raise_error Compel::TypeError, "'abc' is not a valid Regexp"
+        end
+
+        it 'should have value' do
+          builder.format(/1/)
+
+          expect(builder.options[:format]).to eq(/1/)
+        end
+
+      end
+
+      context '#min_length' do
+
+        it 'should raise exception for invalid type' do
+          expect { builder.min_length('a') }.to \
+            raise_error Compel::TypeError, "'a' is not a valid Integer"
+        end
+
+        it 'should have value' do
+          builder.min_length(4)
+
+          expect(builder.options[:min_length]).to eq(4)
+        end
+
+      end
+
+      context '#max_length' do
+
+        it 'should raise exception for invalid type' do
+          expect { builder.max_length('a') }.to \
+            raise_error Compel::TypeError, "'a' is not a valid Integer"
+        end
+
+        it 'should have value' do
+          builder.max_length(10)
+
+          expect(builder.options[:max_length]).to eq(10)
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/compel/coercion_spec.rb

@@ -23,7 +23,7 @@ describe Compel::Coercion do
         expect(Compel::Coercion.valid?('123abc', Integer)).to eq(false)
 
         expect { Compel::Coercion.coerce!('123abc', Integer) }.to \
-          raise_error Compel::ParamTypeError, "'123abc' is not a valid Integer"
+          raise_error Compel::TypeError, "'123abc' is not a valid Integer"
       end
 
     end
@@ -40,7 +40,7 @@ describe Compel::Coercion do
         expect(Compel::Coercion.valid?('1.a233', Float)).to eq(false)
 
         expect { Compel::Coercion.coerce!('1.a233', Float) }.to \
-          raise_error Compel::ParamTypeError, "'1.a233' is not a valid Float"
+          raise_error Compel::TypeError, "'1.a233' is not a valid Float"
       end
 
     end
@@ -59,39 +59,89 @@ describe Compel::Coercion do
         expect(Compel::Coercion.valid?(value, String)).to eq(false)
 
         expect { Compel::Coercion.coerce!(value, String) }.to \
-          raise_error Compel::ParamTypeError, "'#{value}' is not a valid String"
+          raise_error Compel::TypeError, "'#{value}' is not a valid String"
       end
 
     end
 
     context 'Date' do
 
-      it 'should coerce' do
+      it 'should coerce with default format' do
         value = Compel::Coercion.coerce!('2015-12-22', Date)
 
         expect(value).to eq(Date.parse('2015-12-22'))
       end
 
+      it 'should coerce with format' do
+        value = Compel::Coercion.coerce!('22-12-2015', Date, { format: '%d-%m-%Y'})
+
+        expect(value).to eq(Date.strptime('22-12-2015', '%d-%m-%Y'))
+      end
+
       it 'should not coerce' do
         value = '2015-0'
 
         expect(Compel::Coercion.valid?(value, Date)).to eq(false)
 
         expect { Compel::Coercion.coerce!(value, Date) }.to \
-          raise_error Compel::ParamTypeError, "'#{value}' is not a valid Date"
+          raise_error \
+            Compel::TypeError,
+            "'#{value}' is not a parsable date with format: %Y-%m-%d"
+      end
+
+      it 'should not coerce 1' do
+        default_format = '%Y-%m-%d'
+        value = '22-12-2015'
+
+        expect { Compel::Coercion.coerce!(value, Date) }.to \
+          raise_error \
+            Compel::TypeError,
+            "'#{value}' is not a parsable date with format: #{default_format}"
       end
 
     end
 
-    context 'DateTime' do
+    context 'DateTime & Time' do
 
       it 'should coerce' do
-        value = Compel::Coercion.coerce!('2015-12-22', DateTime)
+        [DateTime, Time].each do |time_klass|
+          value = Compel::Coercion.coerce!('2015-12-22', time_klass, format: '%Y-%m-%d')
+
+          expect(value).to be_a time_klass
+          expect(value.year).to eq(2015)
+          expect(value.month).to eq(12)
+          expect(value.day).to eq(22)
+        end
+
+      end
+
+      it 'should coerce iso8601 format' do
+        [DateTime, Time].each do |time_klass|
+          value = Compel::Coercion.coerce!('2015-12-22T09:30:10', time_klass)
+
+          expect(value).to be_a time_klass
+          expect(value.year).to eq(2015)
+          expect(value.month).to eq(12)
+          expect(value.day).to eq(22)
+          expect(value.hour).to eq(9)
+          expect(value.min).to eq(30)
+          expect(value.sec).to eq(10)
+        end
+      end
+
+      it 'should not coerce' do
+        default_format = '%FT%T'
+        value = '22-12-2015'
+
+        [DateTime, Time].each do |time_klass|
+          type_down_cased = "#{time_klass}".downcase
+
+          expect { Compel::Coercion.coerce!('22-12-2015', time_klass) }.to \
+            raise_error \
+              Compel::TypeError,
+              "'#{value}' is not a parsable #{type_down_cased} with format: #{default_format}"
+        end
 
-        expect(value).to be_a DateTime
-        expect(value.year).to eq(2015)
-        expect(value.month).to eq(12)
-        expect(value.day).to eq(22)
       end
 
     end
@@ -136,17 +186,17 @@ describe Compel::Coercion do
 
       it 'should not coerce' do
         expect { Compel::Coercion.coerce!(123, Hash) }.to \
-          raise_error Compel::ParamTypeError, "'123' is not a valid Hash"
+          raise_error Compel::TypeError, "'123' is not a valid Hash"
       end
 
       it 'should not coerce 1' do
         expect { Compel::Coercion.coerce!('hash', Hash) }.to \
-          raise_error Compel::ParamTypeError, "'hash' is not a valid Hash"
+          raise_error Compel::TypeError, "'hash' is not a valid Hash"
       end
 
       it 'should not coerce 2' do
         expect { Compel::Coercion.coerce!(['hash'], Hash) }.to \
-          raise_error Compel::ParamTypeError, "'[\"hash\"]' is not a valid Hash"
+          raise_error Compel::TypeError, "'[\"hash\"]' is not a valid Hash"
       end
 
     end
@@ -167,18 +217,35 @@ describe Compel::Coercion do
 
     context 'Boolean' do
 
-      it 'should coerce' do
-        value = Compel::Coercion.coerce!('f', Compel::Boolean)
+      it 'should coerce false' do
+        value = Compel::Coercion.coerce!('f', Compel::Coercion::Boolean)
 
         expect(value).to eq(false)
       end
 
-      it 'should coerce' do
-        value = Compel::Coercion.coerce!('0', Compel::Boolean)
+      it 'should coerce false 1' do
+        value = Compel::Coercion.coerce!('0', Compel::Coercion::Boolean)
 
         expect(value).to eq(false)
       end
 
+      it 'should coerce true' do
+        value = Compel::Coercion.coerce!('t', Compel::Coercion::Boolean)
+
+        expect(value).to eq(true)
+      end
+
+      it 'should coerce true 1' do
+        value = Compel::Coercion.coerce!('true', Compel::Coercion::Boolean)
+
+        expect(value).to eq(true)
+      end
+
+      it 'should not coerce' do
+        expect{ Compel::Coercion.coerce!('trye', Compel::Coercion::Boolean) }.to \
+         raise_error Compel::TypeError, "'trye' is not a valid Boolean"
+      end
+
     end
 
   end