spec/integration/schema/check_rules_spec.rb in dry-validation-0.6.0 vs spec/integration/schema/check_rules_spec.rb in dry-validation-0.7.0

@@ -1,74 +1,82 @@
 RSpec.describe Schema, 'using high-level rules' do
-  subject(:validate) { schema.new }
-
   context 'composing rules' do
-    let(:schema) do
-      Class.new(Schema) do
-        def self.messages
-          Messages.default.merge(
-            en: { errors: { destiny: 'you must select either red or blue' } }
-          )
+    subject(:schema) do
+      Dry::Validation.Schema do
+        configure do
+          def self.messages
+            Messages.default.merge(
+              en: { errors: { destiny: 'you must select either red or blue' } }
+            )
+          end
         end
 
-        optional(:red, &:filled?)
-        optional(:blue, &:filled?)
+        optional(:red).maybe
+        optional(:blue).maybe
 
-        rule(:destiny) { rule(:red) | rule(:blue) }
+        rule(destiny: [:red, :blue]) do |red, blue|
+          red.filled? | blue.filled?
+        end
       end
     end
 
     it 'passes when only red is filled' do
-      expect(validate.(red: '1')).to be_empty
+      expect(schema.(red: '1')).to be_success
     end
 
+    it 'fails when keys are missing' do
+      expect(schema.({})).to be_failure
+    end
+
     it 'fails when red and blue are not filled ' do
-      expect(validate.(red: '', blue: '').messages[:destiny]).to eql(
-        [['you must select either red or blue'], '']
+      expect(schema.(red: nil, blue: nil).messages[:destiny]).to eql(
+        ['you must select either red or blue']
       )
     end
   end
 
   context 'composing specific predicates' do
     let(:schema) do
-      Class.new(Schema) do
-        def self.messages
-          Messages.default.merge(
-            en: {
-              errors: {
-                email_presence: 'email must be present when login is set to true',
-                email_absence: 'email must not be present when login is set to false'
+      Dry::Validation.Schema do
+        configure do
+          def self.messages
+            Messages.default.merge(
+              en: {
+                errors: {
+                  email_presence: 'must be present when login is set to true',
+                  email_absence: 'must not be present when login is set to false'
+                }
               }
-            }
-          )
+            )
+          end
         end
 
-        key(:login) { |login| login.bool? }
-        key(:email) { |email| email.none? | email.filled? }
+        key(:login).required(:bool?)
+        key(:email).maybe
 
         rule(:email_presence) { value(:login).true?.then(value(:email).filled?) }
 
         rule(:email_absence) { value(:login).false?.then(value(:email).none?) }
       end
     end
 
     it 'passes when login is false and email is nil' do
-      expect(validate.(login: false, email: nil)).to be_empty
+      expect(schema.(login: false, email: nil)).to be_success
     end
 
     it 'fails when login is false and email is present' do
-      expect(validate.(login: false, email: 'jane@doe').messages[:email_absence]).to eql(
-        [['email must not be present when login is set to false'], nil]
+      expect(schema.(login: false, email: 'jane@doe').messages).to eql(
+        email_absence: ['must not be present when login is set to false']
       )
     end
 
     it 'passes when login is true and email is present' do
-      expect(validate.(login: true, email: 'jane@doe')).to be_empty
+      expect(schema.(login: true, email: 'jane@doe')).to be_success
     end
 
     it 'fails when login is true and email is not present' do
-      expect(validate.(login: true, email: nil).messages[:email_presence]).to eql(
-        [['email must be present when login is set to true'], nil]
+      expect(schema.(login: true, email: nil).messages).to eql(
+        email_presence: ['must be present when login is set to true']
       )
     end
   end
 end