compel 0.2.0 → 0.3.1

data/spec/compel/builder_spec.rb

@@ -2,219 +2,429 @@ 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
+    context 'Build' do
 
-    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 new Schema for givin type' do
+        builder = Compel.string
 
-    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
+        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 validate hash object from schema' do
-      schema = Compel.hash.keys({
-        a: Compel.float.required
-      })
+      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
+        })
 
-      expect(schema.validate({ a: nil }).errors.a).to \
-        include('is required')
-    end
+        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
+
+      context 'Builder::CommonValue' do
 
-    context 'Builder::CommonValue' do
+        context '#in, #range, #min, #max' do
 
-      context '#in, #range, #min, #max' do
+          subject(:builder) { Compel.string }
 
-        it 'should have value' do
-          [:in, :range, :min, :max].each do |method|
-            builder.send(method, "#{method}")
-            expect(builder.options[method]).to eq("#{method}")
+          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
 
-    end
+      context 'Builder::Common' do
+
+        subject(:builder) { Compel.string }
 
-    context 'Builder::Common' do
+        context '#is, #default' do
 
-      context '#is, #default' do
+          it 'should have value' do
 
-        it 'should have value' do
-          [:is, :default].each do |method|
-            builder.send(method, "#{method}")
-            expect(builder.options[method]).to eq("#{method}")
+            [:is, :default].each do |method|
+              builder.send(method, "#{method}")
+              expect(builder.options[method]).to eq("#{method}")
+            end
           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
 
-      context '#required' do
+            expect(builder.required?).to be true
+          end
 
-        it 'should be false' do
-          expect(builder.required?).to be false
         end
 
-        it 'should be true' do
-          builder.required
+        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
 
-          expect(builder.required?).to be true
         end
 
       end
 
-      context '#length' do
+      context 'Date' do
 
-        it 'should have value' do
-          builder.length(5)
+        subject(:builder) { Compel.date }
 
-          expect(builder.options[:length]).to be 5
-        end
+        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
 
-        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 'String' do
 
-    context 'Date' do
+        subject(:builder) { Compel.string }
 
-      subject(:builder) { Compel::Builder::Date.new }
+        context '#format' 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/)
 
-        it 'should have value' do
-          builder.format('%d-%m-%Y')
+            expect(builder.options[:format]).to eq(/1/)
+          end
 
-          expect(builder.options[:format]).to eq('%d-%m-%Y')
         end
 
-        it 'should have value' do
-          builder.iso8601
+        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
 
-          expect(builder.options[:format]).to eq('%Y-%m-%d')
         end
 
       end
 
     end
 
-    context 'String' do
+    context 'Validate' do
+
+      context 'Hash' do
 
-      context '#format' do
+        it 'should validate Hash schema' do
+          object = {
+            first_name: 'Joaquim',
+            birth_date: '1989-0',
+            address: {
+              line_one: 'Lisboa',
+              post_code: '1100',
+              country_code: 'PT'
+            }
+          }
 
-        it 'should raise exception for invalid type' do
-          expect { builder.format('abc') }.to \
-            raise_error Compel::TypeError, "'abc' is not a valid Regexp"
+          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 = schema.validate(object)
+
+          expect(result.value).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 have value' do
-          builder.format(/1/)
+        it 'should validate hash object from schema' do
+          schema = Compel.hash.keys({
+            a: Compel.float.required
+          })
 
-          expect(builder.options[:format]).to eq(/1/)
+          expect(schema.validate({ a: nil }).errors.a).to \
+            include('is required')
         end
 
       end
 
-      context '#min_length' do
+      context 'String' 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"
+        it 'should validate Type schema' do
+          schema = Compel.string.format(/^\d{4}-\d{3}$/).required
+          response = schema.validate('1234')
+
+          expect(response.errors).to \
+            include("must match format ^\\d{4}-\\d{3}$")
         end
 
-        it 'should have value' do
-          builder.min_length(4)
+      end
+
+      context 'Array' do
+
+        subject(:builder) { Compel.array }
+
+        it 'should validate nil without errors' do
+          result = builder.validate(nil)
+
+          expect(result.valid?).to be true
+        end
+
+        it 'should validate nil with errors' do
+          result = builder.required.validate(nil)
+
+          expect(result.errors[:base]).to include('is required')
+        end
+
+        it 'should validate with errors for invalid array' do
+          result = builder.required.validate(1)
+
+          expect(result.errors[:base]).to include("'1' is not a valid Array")
+        end
+
+        context '#items' do
+
+          it 'should validate without items' do
+            result = builder.validate([1, 2, 3])
+
+            expect(result.valid?).to be true
+            expect(result.value).to eq([1, 2, 3])
+          end
+
+          it 'should raise exception for invalid type' do
+            expect { builder.items('a') }.to \
+              raise_error Compel::TypeError, "#items must be a valid Schema"
+          end
+
+          it 'should raise exception for invalid type' do
+            expect { builder.items('a') }.to \
+              raise_error Compel::TypeError, "#items must be a valid Schema"
+          end
+
+          it 'should have value' do
+            builder.items(Compel.integer)
+
+            expect(builder.options[:items].class).to be(Compel::Builder::Integer)
+          end
+
+          it 'should validate all items' do
+            builder.items(Compel.integer)
+
+            result = builder.validate([1, '2', nil])
+
+            expect(result.valid?).to be true
+            expect(result.value).to eq([1, 2])
+          end
+
+          it 'should validate all items with errors' do
+            builder.items(Compel.float.required)
+
+            result = builder.validate([1, 'a', nil])
+
+            expect(result.valid?).to be false
+            expect(result.errors['1']).to include("'a' is not a valid Float")
+            expect(result.errors['2']).to include('is required')
+          end
+
+          it 'should coerce all hash items' do
+            builder.items(Compel.hash.keys({
+              a: Compel.string.required,
+              b: Compel.integer
+            }))
+
+            result = builder.validate([
+              { a: 'A', b: '1' },
+              { a: 'B' },
+              { a: 'C', b: 3 },
+            ])
+
+            expect(result.valid?).to be true
+            expect(result.value).to eq \
+              [
+                Hashie::Mash.new({ a: 'A', b: 1 }),
+                Hashie::Mash.new({ a: 'B' }),
+                Hashie::Mash.new({ a: 'C', b: 3 })
+              ]
+          end
+
+          it 'should coerce all hash items with errors' do
+            builder.items(Compel.hash.keys({
+              a: Compel.string.required,
+              b: Compel.string.format(/^abc$/).required
+            }))
+
+            result = builder.validate([
+              { a: 'A', b: 'abc' },
+              { a: 'B' },
+              { a: 'C', b: 'abcd' },
+            ])
+
+            expect(result.valid?).to be false
+            expect(result.errors['1'][:b]).to include('is required')
+            expect(result.errors['2'][:b]).to include('must match format ^abc$')
+
+            expect(result.value[0][:a]).to eq('A')
+            expect(result.value[0][:b]).to eq('abc')
+
+            expect(result.value[1][:a]).to eq('B')
+            expect(result.value[1][:b]).to be_nil
+            expect(result.value[1][:errors][:b]).to include('is required')
+
+            expect(result.value[2][:a]).to eq('C')
+            expect(result.value[2][:b]).to eq('abcd')
+            expect(result.value[2][:errors][:b]).to \
+              include('must match format ^abc$')
+          end
+
+          it 'should coerce array with hash items and nested array keys with errors' do
+            builder.items(Compel.hash.keys({
+              a: Compel.string,
+              b: Compel.array.items(Compel.integer.required).required
+            }))
+
+            result = builder.validate([
+              { a: 'C' },
+              { b: [1, 2, 3] },
+              { b: ['1', nil, 'a'] }
+            ])
+
+            expect(result.valid?).to be false
+
+            expect(result.value[0][:a]).to eq('C')
+            expect(result.value[0][:b]).to be_nil
+            expect(result.value[1][:a]).to be_nil
+            expect(result.value[1][:b]).to eq([1, 2, 3])
+            expect(result.value[2][:a]).to be_nil
+            expect(result.value[2][:b]).to eq([1, nil, 'a'])
+
+            expect(result.errors['0'][:b]).to include('is required')
+            expect(result.errors['2'][:b]['1']).to include('is required')
+            expect(result.errors['2'][:b]['2']).to \
+              include("'a' is not a valid Integer")
+          end
 
-          expect(builder.options[:min_length]).to eq(4)
         end
 
       end
 
-      context '#max_length' do
+      context 'Hash' do
+
+        subject(:builder) { Compel.hash }
 
-        it 'should raise exception for invalid type' do
-          expect { builder.max_length('a') }.to \
-            raise_error Compel::TypeError, "'a' is not a valid Integer"
+        it 'should validate empty keys option' do
+          schema = builder.required
+
+          expect(schema.validate({ a: 1 }).valid?).to be true
+        end
+
+        it 'should validate nil' do
+          schema = builder.required
+
+          result = schema.validate(nil)
+
+          expect(result.valid?).to be false
+          expect(result.errors[:base]).to \
+            include('is required')
         end
 
-        it 'should have value' do
-          builder.max_length(10)
+        it 'should validate empty keys with errors' do
+          schema = builder.required.length(2)
+
+          result = schema.validate({ a: 1 })
 
-          expect(builder.options[:max_length]).to eq(10)
+          expect(result.valid?).to be false
+          expect(result.errors[:base]).to \
+            include('cannot have length different than 2')
         end
 
       end

data/spec/compel/coercion_spec.rb

@@ -73,7 +73,7 @@ describe Compel::Coercion do
       end
 
       it 'should coerce with format' do
-        value = Compel::Coercion.coerce!('22-12-2015', Date, { format: '%d-%m-%Y'})
+        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
@@ -248,6 +248,21 @@ describe Compel::Coercion do
 
     end
 
+    context 'Array' do
+
+      it 'should not coerce' do
+        expect { Compel::Coercion.coerce!(123, Compel::Coercion::Array) }.to \
+          raise_error Compel::TypeError, "'123' is not a valid Array"
+      end
+
+      it 'should coerce' do
+        value = Compel::Coercion.coerce!([1, 2], Compel::Coercion::Array)
+
+        expect(value).to eq([1, 2])
+      end
+
+    end
+
   end
 
 end