compel 0.2.0 → 0.3.1

data/spec/compel/compel_spec.rb

@@ -4,8 +4,8 @@ describe Compel do
 
     context 'User validation example' do
 
-      def make_the_call(method, hash)
-        schema = Compel.hash.keys({
+      def user_schema
+        Compel.hash.keys({
           user: Compel.hash.keys({
             first_name: Compel.string.required,
             last_name: Compel.string.required,
@@ -16,98 +16,124 @@ describe Compel do
               admin: Compel.boolean.required
             })
           }).required
-        })
-
-        Compel.send(method, hash, schema)
+        }).required
       end
 
-      it 'should compel returning coerced values' do
-        hash = {
-          user: {
-            first_name: 'Joaquim',
-            last_name: 'Adráz',
-            birth_date: '1989-08-06T09:00:00',
-            age: '26',
-            admin: 'f',
-            blog_role: {
-              admin: '0'
-            }
-          }
-        }
+      context 'valid' do
 
-        expect(make_the_call(:run, hash)).to eq \
-          Hashie::Mash.new({
+        it 'return coerced values' do
+          object = {
             user: {
               first_name: 'Joaquim',
               last_name: 'Adráz',
-              birth_date: DateTime.parse('1989-08-06T09:00:00'),
-              age: 26,
-              admin: false,
+              birth_date: '1989-08-06T09:00:00',
+              age: '26',
+              admin: 'f',
               blog_role: {
-                admin: false
+                admin: '0'
               }
             }
-          })
-      end
-
-      it 'should not compel and leave other hash untouched' do
-        hash = {
-          other_param: 1,
-          user: {
-            first_name: 'Joaquim'
           }
-        }
 
-        expect(make_the_call(:run, hash)).to eq \
-          Hashie::Mash.new({
-            other_param: 1,
-            user: {
-              first_name: 'Joaquim',
-            },
-            errors: {
+          result = Compel.run(object, user_schema)
+
+          expect(result.valid?).to be true
+          expect(result.value).to eq \
+            Hashie::Mash.new({
               user: {
-                last_name: ['is required']
+                first_name: 'Joaquim',
+                last_name: 'Adráz',
+                birth_date: DateTime.parse('1989-08-06T09:00:00'),
+                age: 26,
+                admin: false,
+                blog_role: {
+                  admin: false
+                }
               }
-            }
-          })
-      end
+            })
+        end
 
-      it 'should not compel for invalid hash' do
-        expect{ make_the_call(:run, 1) }.to \
-          raise_error Compel::TypeError, 'must be an Hash'
       end
 
-      it 'should not compel for invalid hash 1' do
-        expect{ make_the_call(:run, nil) }.to \
-          raise_error Compel::TypeError, 'must be an Hash'
-      end
+      context 'invalid' do
 
-      it 'should not compel'  do
-        hash = {
-          user: {
-            first_name: 'Joaquim'
+        it 'should not compel and leave other keys untouched' do
+          object = {
+            other_param: 1,
+            user: {
+              first_name: 'Joaquim'
+            }
           }
-        }
 
-        expect(make_the_call(:run, hash)).to eq \
-          Hashie::Mash.new({
-            user:{
-              first_name: 'Joaquim',
-            },
-            errors: {
+          result = Compel.run(object, user_schema)
+
+          expect(result.valid?).to be false
+          expect(result.value).to eq \
+            Hashie::Mash.new({
+              other_param: 1,
               user: {
-                last_name: ['is required']
+                first_name: 'Joaquim',
+              },
+              errors: {
+                user: {
+                  last_name: ['is required']
+                }
               }
+            })
+        end
+
+        it 'should not compel for invalid hash' do
+          result = Compel.run(1, user_schema)
+
+          expect(result.valid?).to be false
+          expect(result.errors[:base]).to include("'1' is not a valid Hash")
+        end
+
+        it 'should not compel for missing hash' do
+          result = Compel.run(nil, user_schema)
+
+          expect(result.valid?).to be false
+          expect(result.errors[:base]).to include('is required')
+        end
+
+        it 'should not compel for empty hash' do
+          result = Compel.run({}, user_schema)
+
+          expect(result.valid?).to be false
+          expect(result.errors[:user]).to include('is required')
+        end
+
+        it 'should not compel for missing required key'  do
+          object = {
+            user: {
+              first_name: 'Joaquim'
             }
-          })
+          }
+
+          result = Compel.run(object, user_schema)
+
+          expect(result.valid?).to be false
+          expect(result.value).to eq \
+            Hashie::Mash.new({
+              user:{
+                first_name: 'Joaquim',
+              },
+              errors: {
+                user: {
+                  last_name: ['is required']
+                }
+              }
+            })
+        end
+
       end
 
     end
 
     context 'Address validation example' do
 
-      def make_the_call(method, hash)
-        schema = Compel.hash.keys({
+      def address_schema
+        Compel.hash.keys({
           address: Compel.hash.keys({
             line_one: Compel.string.required,
             line_two: Compel.string,
@@ -121,199 +147,196 @@ describe Compel do
             }).required
           }).required
         })
-
-        Compel.send(method, hash, schema)
       end
 
-      it 'should run?' do
-        hash = {
-          address: {
-            line_one: 'Lisbon',
-            line_two: 'Portugal',
-            post_code: {
-              prefix: 1100,
-              suffix: 100
+      context 'valid' do
+
+        it 'should compel with #run?' do
+          object = {
+            address: {
+              line_one: 'Lisbon',
+              line_two: 'Portugal',
+              post_code: {
+                prefix: 1100,
+                suffix: 100
+              }
             }
           }
-        }
 
-        expect(make_the_call(:run?, hash)).to eq(true)
+          expect(Compel.run?(object, address_schema)).to eq(true)
+        end
+
       end
 
-      it 'should not compel' do
-        hash = {
-          address: {
-            line_two: 'Portugal'
-          }
-        }
+      context 'invalid' do
 
-        expect(make_the_call(:run, hash)).to eq \
-          Hashie::Mash.new({
+        it 'should not compel for missing required keys' do
+          object = {
             address: {
               line_two: 'Portugal'
-            },
-            errors: {
-              address: {
-                line_one: ['is required'],
-                post_code: ['is required']
-              }
             }
-          })
-      end
+          }
 
-      it 'should not compel 1' do
-        hash = {
-          address: {
-            line_two: 'Portugal',
-            post_code: {
-              prefix: '1',
-              county: {
-                code: 'LX'
+          result = Compel.run(object, address_schema)
+
+          expect(result.valid?).to be false
+          expect(result.value).to eq \
+            Hashie::Mash.new({
+              address: {
+                line_two: 'Portugal'
+              },
+              errors: {
+                address: {
+                  line_one: ['is required'],
+                  post_code: ['is required']
+                }
               }
-            }
-          }
-        }
+            })
+        end
 
-        expect(make_the_call(:run, hash)).to eq \
-          Hashie::Mash.new({
+        it 'should not compel missing key and length invalid' do
+          object = {
             address: {
               line_two: 'Portugal',
               post_code: {
-                prefix: 1,
+                prefix: '1',
                 county: {
                   code: 'LX'
                 }
               }
-            },
-            errors: {
-              address: {
-                line_one: ['is required'],
-                post_code: {
-                  prefix: ['cannot have length different than 4']
-                }
-              }
-            }
-          })
-      end
-
-      it 'should not compel 2' do
-        hash = {
-          address: {
-            post_code: {
-              suffix: '1234'
             }
           }
-        }
 
-        expect(make_the_call(:run, hash)).to eq \
-          Hashie::Mash.new({
-            address: {
-              post_code: {
-                suffix: 1234
-              }
-            },
-            errors: {
+          result = Compel.run(object, address_schema)
+
+          expect(result.valid?).to be false
+          expect(result.value).to eq \
+            Hashie::Mash.new({
               address: {
-                line_one: ['is required'],
+                line_two: 'Portugal',
                 post_code: {
-                  prefix: ['is required'],
-                  suffix: ['cannot have length different than 3']
+                  prefix: 1,
+                  county: {
+                    code: 'LX'
+                  }
+                }
+              },
+              errors: {
+                address: {
+                  line_one: ['is required'],
+                  post_code: {
+                    prefix: ['cannot have length different than 4']
+                  }
                 }
               }
-            }
-          })
-      end
-
-      it 'should not compel 3' do
-        hash = {
-          address: {
-            post_code: {
-              prefix: '1100',
-              suffix: '100',
-              county: {}
-            },
-          }
-        }
+            })
+        end
 
-        expect(make_the_call(:run, hash)).to eq \
-          Hashie::Mash.new({
+        it 'should not compel for givin invalid optional value' do
+          object = {
             address: {
+              line_one: 'Line',
               post_code: {
-                prefix: 1100,
-                suffix: 100,
+                prefix: '1100',
+                suffix: '100',
                 county: {}
-              }
-            },
-            errors: {
+              },
+            }
+          }
+
+          result = Compel.run(object, address_schema)
+
+          expect(result.valid?).to be false
+          expect(result.value).to eq \
+            Hashie::Mash.new({
               address: {
-                line_one: ['is required'],
+                line_one: 'Line',
                 post_code: {
-                  county: {
-                    code: ['is required']
+                  prefix: 1100,
+                  suffix: 100,
+                  county: {}
+                }
+              },
+              errors: {
+                address: {
+                  post_code: {
+                    county: {
+                      code: ['is required']
+                    }
                   }
                 }
               }
-            }
-          })
+            })
 
-      end
+        end
 
-      it 'should not compel 4' do
-        hash = {
-          address: nil
-        }
+        it 'should not compel for missing required root key' do
+          object = {
+            address: nil
+          }
 
-        expect(make_the_call(:run, hash)).to eq \
-          Hashie::Mash.new({
-            address: nil,
-            errors: {
-              address: ['is required']
-            }
-          })
-      end
+          result = Compel.run(object, address_schema)
+
+          expect(result.valid?).to be false
+          expect(result.value).to eq \
+            Hashie::Mash.new({
+              address: nil,
+              errors: {
+                address: ['is required']
+              }
+            })
+        end
+
+        it 'should not compel for empty object' do
+          result = Compel.run({}, address_schema)
+
+          expect(result.valid?).to be false
+          expect(result.value).to eq \
+            Hashie::Mash.new({
+              errors: {
+                address: ['is required']
+              }
+            })
+        end
 
-      it 'should not compel 5' do
-        expect(make_the_call(:run, {})).to eq \
-          Hashie::Mash.new({
-            errors: {
-              address: ['is required']
-            }
-          })
       end
 
     end
 
     context 'Boolean' do
 
-      context 'required option' do
+      it 'it not compel for invalid boolean' do
+        result = Compel.run(nil, Compel.boolean.required)
 
-        it 'should compel' do
-          schema = Compel.hash.keys({
-            admin: Compel.boolean.required
-          })
+        expect(result.valid?).to be false
+        expect(result.errors).to include('is required')
+      end
 
-          expect(Compel.run?({ admin: 1 }, schema)).to be true
+      context 'required option' do
+
+        it 'should compel with valid option' do
+          expect(Compel.run?(1, Compel.boolean.required)).to be true
         end
 
-        it 'should not compel' do
+        it 'should not compel for missing required boolean' do
           schema = Compel.hash.keys({
             admin: Compel.boolean.required
           })
 
-          expect(Compel.run({ admin: nil }, schema).errors[:admin]).to \
-            include('is required')
+          result = Compel.run({ admin: nil }, schema)
+
+          expect(result.valid?).to be false
+          expect(result.errors[:admin]).to include('is required')
         end
 
       end
 
       context 'default option' do
 
-        it 'should compel' do
-          schema = Compel.hash.keys({
-            admin: Compel.boolean.default(false)
-          })
+        it 'should compel with default option set' do
+          result = Compel.run(nil, Compel.boolean.default(false))
 
-          expect(Compel.run({ admin: nil }, schema).admin).to be false
+          expect(result.value).to be false
         end
 
       end
@@ -321,20 +344,14 @@ describe Compel do
       context 'is option' do
 
         it 'should compel' do
-          schema = Compel.hash.keys({
-            admin: Compel.boolean.is(1)
-          })
-
-          expect(Compel.run?({ admin: 1 }, schema)).to be true
+          expect(Compel.run?(1, Compel.boolean.is(1))).to be true
         end
 
         it 'should not compel' do
-          schema = Compel.hash.keys({
-            admin: Compel.boolean.is(1)
-          })
+          result = Compel.run(0, Compel.boolean.is(1))
 
-          expect(Compel.run({ admin: 0 }, schema).errors[:admin]).to \
-            include('must be 1')
+          expect(result.valid?).to be false
+          expect(result.errors).to include('must be 1')
         end
 
       end
@@ -346,20 +363,17 @@ describe Compel do
       context 'format option' do
 
         it 'should compel' do
-          schema = Compel.hash.keys({
-            post_code: Compel.string.format(/^\d{4}-\d{3}$/)
-          })
+          schema = Compel.string.format(/^\d{4}-\d{3}$/)
 
-          expect(Compel.run?({ post_code: '1100-100' }, schema)).to be true
+          expect(Compel.run?('1100-100', schema)).to be true
         end
 
         it 'should not compel' do
-          schema = Compel.hash.keys({
-            post_code: Compel.string.format(/^\d{4}-\d{3}$/)
-          })
+          schema = Compel.string.format(/^\d{4}-\d{3}$/)
+
+          result = Compel.run('110-100', schema)
 
-          expect(Compel.run({ post_code: '110-100' }, schema).errors[:post_code]).to \
-            include('must match format ^\\d{4}-\\d{3}$')
+          expect(result.errors).to include('must match format ^\\d{4}-\\d{3}$')
         end
 
       end
@@ -371,39 +385,36 @@ describe Compel do
       context 'format option' do
 
         it 'should not compel' do
-          schema = Compel.hash.keys({
-            birth_date: Compel.time
-          })
+          schema = Compel.time
+          result = Compel.run('1989-08-06', schema)
 
-          expect(Compel.run({ birth_date: '1989-08-06' }, schema).errors.birth_date).to \
+          expect(result.valid?).to be false
+          expect(result.errors).to \
             include("'1989-08-06' is not a parsable time with format: %FT%T")
         end
 
         it 'should compel with format' do
-          schema = Compel.hash.keys({
-            birth_date: Compel.time.format('%Y-%m-%d')
-          })
+          schema = Compel.time.format('%Y-%m-%d')
+          result = Compel.run('1989-08-06', schema)
 
-          expect(Compel.run({ birth_date: '1989-08-06' }, schema).birth_date).to \
-            eq(Time.new(1989, 8, 6))
+          expect(result.valid?).to be true
+          expect(result.value).to eq(Time.new(1989, 8, 6))
         end
 
         it 'should compel by default' do
-          schema = Compel.hash.keys({
-            birth_date: Compel.time
-          })
+          schema = Compel.time
+          result = Compel.run('1989-08-06T09:00:00', schema)
 
-          expect(Compel.run({ birth_date: '1989-08-06T09:00:00' }, schema).birth_date).to \
-            eq(Time.new(1989, 8, 6, 9))
+          expect(result.valid?).to be true
+          expect(result.value).to eq(Time.new(1989, 8, 6, 9))
         end
 
         it 'should compel with iso8601 format' do
-          schema = Compel.hash.keys({
-            birth_date: Compel.time.iso8601
-          })
+          schema = Compel.time.iso8601
+          result = Compel.run('1989-08-06T09:00:00', schema)
 
-          expect(Compel.run({ birth_date: '1989-08-06T09:00:00' }, schema).birth_date).to \
-            eq(Time.new(1989, 8, 6, 9))
+          expect(result.valid?).to be true
+          expect(result.value).to eq(Time.new(1989, 8, 6, 9))
         end
 
       end
@@ -421,7 +432,10 @@ describe Compel do
           birth_date: Compel.datetime
         })
 
-        expect(Compel.run({ birth_date: '1989-08-06' }, schema).errors.birth_date).to \
+        result = Compel.run({ birth_date: '1989-08-06' }, schema)
+
+        expect(result.valid?).to be false
+        expect(result.errors[:birth_date]).to \
           include("'1989-08-06' is not a parsable datetime with format: %FT%T")
       end
 
@@ -430,8 +444,10 @@ describe Compel do
           birth_date: Compel.datetime.format('%Y-%m-%d')
         })
 
-        expect(Compel.run({ birth_date: '1989-08-06' }, schema).birth_date).to \
-          eq(DateTime.new(1989, 8, 6))
+        result = Compel.run({ birth_date: '1989-08-06' }, schema)
+
+        expect(result.valid?).to be true
+        expect(result.value[:birth_date]).to eq(DateTime.new(1989, 8, 6))
       end
 
       it 'should compel by default' do
@@ -439,8 +455,10 @@ describe Compel do
           birth_date: Compel.datetime
         })
 
-        expect(Compel.run({ birth_date: '1989-08-06T09:00:00' }, schema).birth_date).to \
-          eq(DateTime.new(1989, 8, 6, 9))
+        result = Compel.run({ birth_date: '1989-08-06T09:00:00' }, schema)
+
+        expect(result.valid?).to be true
+        expect(result.value[:birth_date]).to eq(DateTime.new(1989, 8, 6, 9))
       end
 
       it 'should compel with iso8601 format' do
@@ -448,8 +466,10 @@ describe Compel do
           birth_date: Compel.datetime.iso8601
         })
 
-        expect(Compel.run({ birth_date: '1989-08-06T09:00:00' }, schema).birth_date).to \
-          eq(DateTime.new(1989, 8, 6, 9))
+        result = Compel.run({ birth_date: '1989-08-06T09:00:00' }, schema)
+
+        expect(result.valid?).to be true
+        expect(result.value[:birth_date]).to eq(DateTime.new(1989, 8, 6, 9))
       end
 
     end
@@ -458,87 +478,80 @@ describe Compel do
 
   context 'Compel methods' do
 
-    def make_the_call(method, hash)
-      schema = Compel.hash.keys({
-        first_name: Compel.string.required,
-        last_name: Compel.string.required,
-        birth_date: Compel.datetime
-      })
-
-      Compel.send(method, hash, schema)
-    end
-
     context '#run!' do
 
-      it 'should compel' do
-        hash = {
-          first_name: 'Joaquim',
-          last_name: 'Adráz',
-          birth_date: DateTime.new(1988, 12, 24)
-        }
+      context 'Other Values' do
 
-        expect(make_the_call(:run!, hash)).to \
-          eq \
-            Hashie::Mash.new({
-              first_name: 'Joaquim',
-              last_name: 'Adráz',
-              birth_date: DateTime.new(1988, 12, 24)
-            })
-      end
+        it 'should compel valid integer' do
+          result = Compel.run!(1, Compel.integer.required)
+
+          expect(result).to eq(1)
+        end
 
-      it 'should raise InvalidHashError exception' do
-        hash = {
-          first_name: 'Joaquim'
-        }
+        it 'should not compel for invalid integer' do
+          expect{ Compel.run!('abc', Compel.integer.required) }.to \
+            raise_error Compel::InvalidObjectError, 'object has errors'
+        end
 
-        expect{ make_the_call(:run!, hash) }.to \
-          raise_error Compel::InvalidHashError, 'hash has errors'
       end
 
-      it 'should raise InvalidHashError exception with errors' do
-        hash = {
-          first_name: 'Joaquim'
-        }
+      context 'User validation example' do
 
-        expect{ make_the_call(:run!, hash) }.to raise_error do |exception|
-          expect(exception.object).to eq \
-            Hashie::Mash.new(first_name: 'Joaquim')
+        def make_the_call(method, hash)
+          schema = Compel.hash.keys({
+            first_name: Compel.string.required,
+            last_name: Compel.string.required,
+            birth_date: Compel.datetime
+          })
 
-          expect(exception.errors).to eq \
-            Hashie::Mash.new(last_name: ['is required'])
+          Compel.send(method, hash, schema)
         end
-      end
 
-      it 'should raise InvalidHashError exception for missing hash' do
-        expect{ make_the_call(:run!, {}) }.to \
-          raise_error Compel::InvalidHashError, 'hash has errors'
-      end
+        it 'should compel' do
+          hash = {
+            first_name: 'Joaquim',
+            last_name: 'Adráz',
+            birth_date: DateTime.new(1988, 12, 24)
+          }
 
-    end
+          expect(make_the_call(:run!, hash)).to \
+            eq \
+              Hashie::Mash.new({
+                first_name: 'Joaquim',
+                last_name: 'Adráz',
+                birth_date: DateTime.new(1988, 12, 24)
+              })
+        end
 
-    context '#run?' do
+        it 'should raise InvalidObjectError exception for missing required key' do
+          hash = {
+            first_name: 'Joaquim'
+          }
 
-      it 'should return true' do
-        hash = {
-          first_name: 'Joaquim',
-          last_name: 'Adráz',
-          birth_date: '1989-08-06T09:00:00'
-        }
+          expect{ make_the_call(:run!, hash) }.to \
+            raise_error Compel::InvalidObjectError, 'object has errors'
+        end
 
-        expect(make_the_call(:run?, hash)).to eq(true)
-      end
+        it 'should raise InvalidObjectError exception with errors' do
+          hash = {
+            first_name: 'Joaquim'
+          }
+
+          expect{ make_the_call(:run!, hash) }.to raise_error do |exception|
+            expect(exception.object).to eq \
+              Hashie::Mash.new(first_name: 'Joaquim', errors: { last_name: ['is required'] })
+          end
+        end
 
-      it 'should return false' do
-        hash = {
-          first_name: 'Joaquim'
-        }
+        it 'should raise InvalidObjectError exception for missing hash' do
+          expect{ make_the_call(:run!, {}) }.to \
+            raise_error Compel::InvalidObjectError, 'object has errors'
+        end
 
-        expect(make_the_call(:run?, hash)).to eq(false)
       end
 
     end
 
   end
 
-
 end