RubyGems - dry-validation - Versions diffs - 0.7.4 → 0.8.0 - Mend

dry-validation 0.7.4 → 0.8.0

Files changed (143) hide show

checksums.yaml +4 -4
data/.gitignore +1 -0
data/.travis.yml +9 -6
data/CHANGELOG.md +58 -0
data/Gemfile +3 -3
data/benchmarks/benchmark_form_invalid.rb +64 -0
data/benchmarks/benchmark_form_valid.rb +64 -0
data/benchmarks/profile_schema_call_invalid.rb +20 -0
data/benchmarks/profile_schema_call_valid.rb +20 -0
data/benchmarks/profile_schema_definition.rb +14 -0
data/benchmarks/profile_schema_messages_invalid.rb +20 -0
data/benchmarks/suite.rb +5 -0
data/config/errors.yml +12 -5
data/dry-validation.gemspec +2 -2
data/examples/basic.rb +2 -2
data/examples/form.rb +2 -2
data/examples/json.rb +2 -2
data/examples/nested.rb +6 -6
data/lib/dry/validation.rb +22 -3
data/lib/dry/validation/deprecations.rb +23 -0
data/lib/dry/validation/error_compiler.rb +31 -11
data/lib/dry/validation/error_compiler/input.rb +44 -57
data/lib/dry/validation/hint_compiler.rb +15 -7
data/lib/dry/validation/input_processor_compiler.rb +13 -6
data/lib/dry/validation/input_processor_compiler/form.rb +2 -0
data/lib/dry/validation/input_processor_compiler/sanitizer.rb +1 -1
data/lib/dry/validation/messages/abstract.rb +9 -1
data/lib/dry/validation/predicate_registry.rb +101 -0
data/lib/dry/validation/result.rb +8 -1
data/lib/dry/validation/schema.rb +110 -44
data/lib/dry/validation/schema/check.rb +4 -2
data/lib/dry/validation/schema/deprecated.rb +31 -0
data/lib/dry/validation/schema/dsl.rb +18 -11
data/lib/dry/validation/schema/form.rb +1 -0
data/lib/dry/validation/schema/json.rb +1 -0
data/lib/dry/validation/schema/key.rb +23 -10
data/lib/dry/validation/schema/rule.rb +81 -20
data/lib/dry/validation/schema/value.rb +110 -25
data/lib/dry/validation/version.rb +1 -1
data/spec/fixtures/locales/en.yml +1 -0
data/spec/fixtures/locales/pl.yml +1 -1
data/spec/integration/custom_error_messages_spec.rb +2 -2
data/spec/integration/custom_predicates_spec.rb +98 -15
data/spec/integration/error_compiler_spec.rb +111 -96
data/spec/integration/form/predicates/array_spec.rb +243 -0
data/spec/integration/form/predicates/empty_spec.rb +263 -0
data/spec/integration/form/predicates/eql_spec.rb +327 -0
data/spec/integration/form/predicates/even_spec.rb +455 -0
data/spec/integration/form/predicates/excluded_from_spec.rb +455 -0
data/spec/integration/form/predicates/excludes_spec.rb +391 -0
data/spec/integration/form/predicates/false_spec.rb +455 -0
data/spec/integration/form/predicates/filled_spec.rb +467 -0
data/spec/integration/form/predicates/format_spec.rb +454 -0
data/spec/integration/form/predicates/gt_spec.rb +519 -0
data/spec/integration/form/predicates/gteq_spec.rb +519 -0
data/spec/integration/form/predicates/included_in_spec.rb +455 -0
data/spec/integration/form/predicates/includes_spec.rb +391 -0
data/spec/integration/form/predicates/key_spec.rb +75 -0
data/spec/integration/form/predicates/lt_spec.rb +519 -0
data/spec/integration/form/predicates/lteq_spec.rb +519 -0
data/spec/integration/form/predicates/max_size_spec.rb +391 -0
data/spec/integration/form/predicates/min_size_spec.rb +391 -0
data/spec/integration/form/predicates/none_spec.rb +265 -0
data/spec/integration/form/predicates/not_eql_spec.rb +327 -0
data/spec/integration/form/predicates/odd_spec.rb +455 -0
data/spec/integration/form/predicates/size/fixed_spec.rb +399 -0
data/spec/integration/form/predicates/size/range_spec.rb +398 -0
data/spec/integration/form/predicates/true_spec.rb +455 -0
data/spec/integration/form/predicates/type_spec.rb +391 -0
data/spec/integration/hints_spec.rb +90 -4
data/spec/integration/injecting_rules_spec.rb +2 -2
data/spec/integration/localized_error_messages_spec.rb +2 -2
data/spec/integration/messages/i18n_spec.rb +3 -3
data/spec/integration/optional_keys_spec.rb +3 -3
data/spec/integration/schema/array_schema_spec.rb +49 -13
data/spec/integration/schema/check_rules_spec.rb +6 -6
data/spec/integration/schema/check_with_nested_el_spec.rb +3 -3
data/spec/integration/schema/check_with_nth_el_spec.rb +1 -1
data/spec/integration/schema/each_with_set_spec.rb +3 -3
data/spec/integration/schema/extending_dsl_spec.rb +27 -0
data/spec/integration/schema/form/explicit_types_spec.rb +182 -0
data/spec/integration/schema/form_spec.rb +90 -18
data/spec/integration/schema/hash_schema_spec.rb +47 -0
data/spec/integration/schema/inheriting_schema_spec.rb +4 -4
data/spec/integration/schema/input_processor_spec.rb +8 -8
data/spec/integration/schema/json/explicit_types_spec.rb +157 -0
data/spec/integration/schema/json_spec.rb +18 -18
data/spec/integration/schema/macros/confirmation_spec.rb +1 -1
data/spec/integration/schema/macros/each_spec.rb +177 -43
data/spec/integration/schema/macros/{required_spec.rb → filled_spec.rb} +34 -6
data/spec/integration/schema/macros/input_spec.rb +21 -0
data/spec/integration/schema/macros/maybe_spec.rb +39 -2
data/spec/integration/schema/macros/value_spec.rb +105 -0
data/spec/integration/schema/macros/when_spec.rb +28 -8
data/spec/integration/schema/nested_values_spec.rb +11 -8
data/spec/integration/schema/not_spec.rb +2 -2
data/spec/integration/schema/numbers_spec.rb +1 -1
data/spec/integration/schema/option_with_default_spec.rb +1 -1
data/spec/integration/schema/predicate_verification_spec.rb +9 -0
data/spec/integration/schema/predicates/array_spec.rb +295 -0
data/spec/integration/schema/predicates/custom_spec.rb +103 -0
data/spec/integration/schema/predicates/empty_spec.rb +263 -0
data/spec/integration/schema/predicates/eql_spec.rb +327 -0
data/spec/integration/schema/predicates/even_spec.rb +455 -0
data/spec/integration/schema/predicates/excluded_from_spec.rb +455 -0
data/spec/integration/schema/predicates/excludes_spec.rb +391 -0
data/spec/integration/schema/predicates/filled_spec.rb +467 -0
data/spec/integration/schema/predicates/format_spec.rb +455 -0
data/spec/integration/schema/predicates/gt_spec.rb +519 -0
data/spec/integration/schema/predicates/gteq_spec.rb +519 -0
data/spec/integration/schema/predicates/hash_spec.rb +69 -0
data/spec/integration/schema/predicates/included_in_spec.rb +455 -0
data/spec/integration/schema/predicates/includes_spec.rb +391 -0
data/spec/integration/schema/predicates/key_spec.rb +88 -0
data/spec/integration/schema/predicates/lt_spec.rb +520 -0
data/spec/integration/schema/predicates/lteq_spec.rb +519 -0
data/spec/integration/schema/predicates/max_size_spec.rb +391 -0
data/spec/integration/schema/predicates/min_size_spec.rb +391 -0
data/spec/integration/schema/predicates/none_spec.rb +265 -0
data/spec/integration/schema/predicates/not_eql_spec.rb +391 -0
data/spec/integration/schema/predicates/odd_spec.rb +455 -0
data/spec/integration/schema/predicates/size/fixed_spec.rb +401 -0
data/spec/integration/schema/predicates/size/range_spec.rb +399 -0
data/spec/integration/schema/predicates/type_spec.rb +391 -0
data/spec/integration/schema/reusing_schema_spec.rb +4 -4
data/spec/integration/schema/using_types_spec.rb +24 -6
data/spec/integration/schema/xor_spec.rb +2 -2
data/spec/integration/schema_builders_spec.rb +15 -0
data/spec/integration/schema_spec.rb +37 -12
data/spec/shared/predicate_helper.rb +13 -0
data/spec/spec_helper.rb +10 -0
data/spec/support/matchers.rb +38 -0
data/spec/support/predicates_integration.rb +7 -0
data/spec/unit/hint_compiler_spec.rb +10 -8
data/spec/unit/input_processor_compiler/form_spec.rb +45 -43
data/spec/unit/input_processor_compiler/json_spec.rb +37 -35
data/spec/unit/predicate_registry_spec.rb +34 -0
data/spec/unit/schema/key_spec.rb +12 -14
data/spec/unit/schema/rule_spec.rb +4 -2
data/spec/unit/schema/value_spec.rb +38 -121
metadata +150 -16
data/lib/dry/validation/schema/attr.rb +0 -15
data/spec/integration/attr_spec.rb +0 -122

data/spec/integration/schema/predicates/size/fixed_spec.rb ADDED Viewed

@@ -0,0 +1,401 @@
+RSpec.describe 'Predicates: Size' do
+  context 'Fixed (integer)' do
+    context 'with required' do
+      subject(:schema) do
+        Dry::Validation.Schema do
+          required(:foo) { size?(3) }
+        end
+      end
+      context 'with valid input' do
+        let(:input) { { foo: [1, 2, 3] } }
+        it 'is successful' do
+          expect(result).to be_successful
+        end
+      end
+      context 'with missing input' do
+        let(:input) { {} }
+        it 'is not successful' do
+          expect(result).to be_failing ['is missing', 'size must be 3']
+        end
+      end
+      context 'with nil input' do
+        let(:input) { { foo: nil } }
+        it 'is raises error' do
+          expect { result }.to raise_error(NoMethodError)
+        end
+      end
+      context 'with blank input' do
+        let(:input) { { foo: '' } }
+        #see: https://github.com/dry-rb/dry-validation/issues/121
+        xit 'is not successful' do
+          expect(result).to be_failing ['length must be 3']
+        end
+      end
+      context 'with invalid input' do
+        let(:input) { { foo: { a: 1, b: 2, c: 3, d: 4 } } }
+        it 'is not successful' do
+          expect(result).to be_failing ['size must be 3']
+        end
+      end
+    end
+    context 'with optional' do
+      subject(:schema) do
+        Dry::Validation.Schema do
+          optional(:foo) { size?(3) }
+        end
+      end
+      context 'with valid input' do
+        let(:input) { { foo: [1, 2, 3] } }
+        it 'is successful' do
+          expect(result).to be_successful
+        end
+      end
+      context 'with missing input' do
+        let(:input) { {} }
+        it 'is successful' do
+          expect(result).to be_successful
+        end
+      end
+      context 'with nil input' do
+        let(:input) { { foo: nil } }
+        it 'is raises error' do
+          expect { result }.to raise_error(NoMethodError)
+        end
+      end
+      context 'with blank input' do
+        let(:input) { { foo: '' } }
+        #see: https://github.com/dry-rb/dry-validation/issues/121
+        xit 'is not successful' do
+          expect(result).to be_failing ['length must be 3']
+        end
+      end
+      context 'with invalid input' do
+        let(:input) { { foo: { a: 1, b: 2, c: 3, d: 4 } } }
+        it 'is not successful' do
+          expect(result).to be_failing ['size must be 3']
+        end
+      end
+    end
+    context 'as macro' do
+      context 'with required' do
+        context 'with value' do
+          subject(:schema) do
+            Dry::Validation.Schema do
+              required(:foo).value(size?: 3)
+            end
+          end
+          context 'with valid input' do
+            let(:input) { { foo: [1, 2, 3] } }
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+          context 'with missing input' do
+            let(:input) { {} }
+            it 'is not successful' do
+              expect(result).to be_failing ['is missing', 'size must be 3']
+            end
+          end
+          context 'with nil input' do
+            let(:input) { { foo: nil } }
+            it 'is raises error' do
+              expect { result }.to raise_error(NoMethodError)
+            end
+          end
+          context 'with blank input' do
+            let(:input) { { foo: '' } }
+            #see: https://github.com/dry-rb/dry-validation/issues/121
+            xit 'is not successful' do
+              expect(result).to be_failing ['length must be 3']
+            end
+          end
+          context 'with invalid input' do
+            let(:input) { { foo: { a: 1, b: 2, c: 3, d: 4 } } }
+            it 'is not successful' do
+              expect(result).to be_failing ['size must be 3']
+            end
+          end
+        end
+        context 'with filled' do
+          subject(:schema) do
+            Dry::Validation.Schema do
+              required(:foo).filled(size?: 3)
+            end
+          end
+          context 'with valid input' do
+            let(:input) { { foo: [1, 2, 3] } }
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+          context 'with missing input' do
+            let(:input) { {} }
+            it 'is not successful' do
+              expect(result).to be_failing ['is missing', 'size must be 3']
+            end
+          end
+          context 'with nil input' do
+            let(:input) { { foo: nil } }
+            it 'is not successful' do
+              expect(result).to be_failing ['must be filled', 'size must be 3']
+            end
+          end
+          context 'with blank input' do
+            let(:input) { { foo: '' } }
+            #see: https://github.com/dry-rb/dry-validation/issues/121
+            xit 'is not successful' do
+              expect(result).to be_failing ['must be filled', 'length must be 3']
+            end
+          end
+          context 'with invalid input' do
+            let(:input) { { foo: { a: 1, b: 2, c: 3, d: 4 } } }
+            it 'is not successful' do
+              expect(result).to be_failing ['size must be 3']
+            end
+          end
+        end
+        context 'with maybe' do
+          subject(:schema) do
+            Dry::Validation.Schema do
+              required(:foo).maybe(size?: 3)
+            end
+          end
+          context 'with valid input' do
+            let(:input) { { foo: [1, 2, 3] } }
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+          context 'with missing input' do
+            let(:input) { {} }
+            it 'is not successful' do
+              expect(result).to be_failing ['is missing', 'size must be 3']
+            end
+          end
+          context 'with nil input' do
+            let(:input) { { foo: nil } }
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+          context 'with blank input' do
+            let(:input) { { foo: '' } }
+            #see: https://github.com/dry-rb/dry-validation/issues/121
+            xit 'is not successful' do
+              expect(result).to be_failing ['length must be 3']
+            end
+          end
+          context 'with invalid input' do
+            let(:input) { { foo: { a: 1, b: 2, c: 3, d: 4 } } }
+            it 'is not successful' do
+              expect(result).to be_failing ['size must be 3']
+            end
+          end
+        end
+      end
+      context 'with optional' do
+        context 'with value' do
+          subject(:schema) do
+            Dry::Validation.Schema do
+              optional(:foo).value(size?: 3)
+            end
+          end
+          context 'with valid input' do
+            let(:input) { { foo: [1, 2, 3] } }
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+          context 'with missing input' do
+            let(:input) { {} }
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+          context 'with nil input' do
+            let(:input) { { foo: nil } }
+            it 'is raises error' do
+              expect { result }.to raise_error(NoMethodError)
+            end
+          end
+          context 'with blank input' do
+            let(:input) { { foo: '' } }
+            #see: https://github.com/dry-rb/dry-validation/issues/121
+            xit 'is not successful' do
+              expect(result).to be_failing ['length must be 3']
+            end
+          end
+          context 'with invalid input' do
+            let(:input) { { foo: { a: 1, b: 2, c: 3, d: 4 } } }
+            it 'is not successful' do
+              expect(result).to be_failing ['size must be 3']
+            end
+          end
+        end
+        context 'with filled' do
+          subject(:schema) do
+            Dry::Validation.Schema do
+              optional(:foo).filled(size?: 3)
+            end
+          end
+          context 'with valid input' do
+            let(:input) { { foo: [1, 2, 3] } }
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+          context 'with missing input' do
+            let(:input) { {} }
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+          context 'with nil input' do
+            let(:input) { { foo: nil } }
+            it 'is not successful' do
+              expect(result).to be_failing ['must be filled', 'size must be 3']
+            end
+          end
+          context 'with blank input' do
+            let(:input) { { foo: '' } }
+            #see: https://github.com/dry-rb/dry-validation/issues/121
+            xit 'is not successful' do
+              expect(result).to be_failing ['must be filled', 'length must be 3']
+            end
+          end
+          context 'with invalid input' do
+            let(:input) { { foo: { a: 1, b: 2, c: 3, d: 4 } } }
+            it 'is not successful' do
+              expect(result).to be_failing ['size must be 3']
+            end
+          end
+        end
+        context 'with maybe' do
+          subject(:schema) do
+            Dry::Validation.Schema do
+              optional(:foo).maybe(size?: 3)
+            end
+          end
+          context 'with valid input' do
+            let(:input) { { foo: [1, 2, 3] } }
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+          context 'with missing input' do
+            let(:input) { {} }
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+          context 'with nil input' do
+            let(:input) { { foo: nil } }
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+          context 'with blank input' do
+            let(:input) { { foo: '' } }
+            #see: https://github.com/dry-rb/dry-validation/issues/121
+            xit 'is not successful' do
+              expect(result).to be_failing ['length must be 3']
+            end
+          end
+          context 'with invalid input' do
+            let(:input) { { foo: { a: 1, b: 2, c: 3, d: 4 } } }
+            it 'is not successful' do
+              expect(result).to be_failing ['size must be 3']
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/integration/schema/predicates/size/range_spec.rb ADDED Viewed

@@ -0,0 +1,399 @@
+RSpec.describe 'Predicates: Size' do
+  context 'Range' do
+    context 'with required' do
+      subject(:schema) do
+        Dry::Validation.Schema do
+          required(:foo) { size?(2..3) }
+        end
+      end
+      context 'with valid input' do
+        let(:input) { { foo: [1, 2, 3] } }
+        it 'is successful' do
+          expect(result).to be_successful
+        end
+      end
+      context 'with missing input' do
+        let(:input) { {} }
+        it 'is not successful' do
+          expect(result).to be_failing ['is missing', 'size must be within 2 - 3']
+        end
+      end
+      context 'with nil input' do
+        let(:input) { { foo: nil } }
+        it 'is raises error' do
+          expect { result }.to raise_error(NoMethodError)
+        end
+      end
+      context 'with blank input' do
+        let(:input) { { foo: '' } }
+        #see: https://github.com/dry-rb/dry-validation/issues/121
+        xit 'is not successful' do
+          expect(result).to be_failing ['length must be within 2 - 3']
+        end
+      end
+      context 'with invalid input' do
+        let(:input) { { foo: { a: 1, b: 2, c: 3, d: 4 } } }
+        it 'is not successful' do
+          expect(result).to be_failing ['size must be within 2 - 3']
+        end
+      end
+    end
+    context 'with optional' do
+      subject(:schema) do
+        Dry::Validation.Schema do
+          optional(:foo) { size?(2..3) }
+        end
+      end
+      context 'with valid input' do
+        let(:input) { { foo: [1, 2, 3] } }
+        it 'is successful' do
+          expect(result).to be_successful
+        end
+      end
+      context 'with missing input' do
+        let(:input) { {} }
+        it 'is successful' do
+          expect(result).to be_successful
+        end
+      end
+      context 'with nil input' do
+        let(:input) { { foo: nil } }
+        it 'is raises error' do
+          expect { result }.to raise_error(NoMethodError)
+        end
+      end
+      context 'with blank input' do
+        let(:input) { { foo: '' } }
+        #see: https://github.com/dry-rb/dry-validation/issues/121
+        xit 'is not successful' do
+          expect(result).to be_failing ['length must be within 2 - 3']
+        end
+      end
+      context 'with invalid input' do
+        let(:input) { { foo: { a: 1, b: 2, c: 3, d: 4 } } }
+        it 'is not successful' do
+          expect(result).to be_failing ['size must be within 2 - 3']
+        end
+      end
+    end
+    context 'as macro' do
+      context 'with required' do
+        context 'with value' do
+          subject(:schema) do
+            Dry::Validation.Schema do
+              required(:foo).value(size?: 2..3)
+            end
+          end
+          context 'with valid input' do
+            let(:input) { { foo: [1, 2, 3] } }
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+          context 'with missing input' do
+            let(:input) { {} }
+            it 'is not successful' do
+              expect(result).to be_failing ['is missing', 'size must be within 2 - 3']
+            end
+          end
+          context 'with nil input' do
+            let(:input) { { foo: nil } }
+            it 'is raises error' do
+              expect { result }.to raise_error(NoMethodError)
+            end
+          end
+          context 'with blank input' do
+            let(:input) { { foo: '' } }
+            it 'is not successful' do
+              expect(result).to be_failing ['length must be within 2 - 3']
+            end
+          end
+          context 'with invalid input' do
+            let(:input) { { foo: { a: 1, b: 2, c: 3, d: 4 } } }
+            it 'is not successful' do
+              expect(result).to be_failing ['size must be within 2 - 3']
+            end
+          end
+        end
+        context 'with filled' do
+          subject(:schema) do
+            Dry::Validation.Schema do
+              required(:foo).filled(size?: 2..3)
+            end
+          end
+          context 'with valid input' do
+            let(:input) { { foo: [1, 2, 3] } }
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+          context 'with missing input' do
+            let(:input) { {} }
+            it 'is not successful' do
+              expect(result).to be_failing ['is missing', 'size must be within 2 - 3']
+            end
+          end
+          context 'with nil input' do
+            let(:input) { { foo: nil } }
+            it 'is not successful' do
+              expect(result).to be_failing ['must be filled', 'size must be within 2 - 3']
+            end
+          end
+          context 'with blank input' do
+            let(:input) { { foo: '' } }
+            #see: https://github.com/dry-rb/dry-validation/issues/121
+            xit 'is not successful' do
+              expect(result).to be_failing ['must be filled', 'length must be within 2 - 3']
+            end
+          end
+          context 'with invalid input' do
+            let(:input) { { foo: { a: 1, b: 2, c: 3, d: 4 } } }
+            it 'is not successful' do
+              expect(result).to be_failing ['size must be within 2 - 3']
+            end
+          end
+        end
+        context 'with maybe' do
+          subject(:schema) do
+            Dry::Validation.Schema do
+              required(:foo).maybe(size?: 2..3)
+            end
+          end
+          context 'with valid input' do
+            let(:input) { { foo: [1, 2, 3] } }
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+          context 'with missing input' do
+            let(:input) { {} }
+            it 'is not successful' do
+              expect(result).to be_failing ['is missing', 'size must be within 2 - 3']
+            end
+          end
+          context 'with nil input' do
+            let(:input) { { foo: nil } }
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+          context 'with blank input' do
+            let(:input) { { foo: '' } }
+            it 'is not successful' do
+              expect(result).to be_failing ['length must be within 2 - 3']
+            end
+          end
+          context 'with invalid input' do
+            let(:input) { { foo: { a: 1, b: 2, c: 3, d: 4 } } }
+            it 'is not successful' do
+              expect(result).to be_failing ['size must be within 2 - 3']
+            end
+          end
+        end
+      end
+      context 'with optional' do
+        context 'with value' do
+          subject(:schema) do
+            Dry::Validation.Schema do
+              optional(:foo).value(size?: 2..3)
+            end
+          end
+          context 'with valid input' do
+            let(:input) { { foo: [1, 2, 3] } }
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+          context 'with missing input' do
+            let(:input) { {} }
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+          context 'with nil input' do
+            let(:input) { { foo: nil } }
+            it 'is raises error' do
+              expect { result }.to raise_error(NoMethodError)
+            end
+          end
+          context 'with blank input' do
+            let(:input) { { foo: '' } }
+            #see: https://github.com/dry-rb/dry-validation/issues/121
+            xit 'is not successful' do
+              expect(result).to be_failing ['length must be within 2 - 3']
+            end
+          end
+          context 'with invalid input' do
+            let(:input) { { foo: { a: 1, b: 2, c: 3, d: 4 } } }
+            it 'is not successful' do
+              expect(result).to be_failing ['size must be within 2 - 3']
+            end
+          end
+        end
+        context 'with filled' do
+          subject(:schema) do
+            Dry::Validation.Schema do
+              optional(:foo).filled(size?: 2..3)
+            end
+          end
+          context 'with valid input' do
+            let(:input) { { foo: [1, 2, 3] } }
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+          context 'with missing input' do
+            let(:input) { {} }
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+          context 'with nil input' do
+            let(:input) { { foo: nil } }
+            it 'is not successful' do
+              expect(result).to be_failing ['must be filled', 'size must be within 2 - 3']
+            end
+          end
+          context 'with blank input' do
+            let(:input) { { foo: '' } }
+            #see: https://github.com/dry-rb/dry-validation/issues/121
+            xit 'is not successful' do
+              expect(result).to be_failing ['must be filled', 'length must be within 2 - 3']
+            end
+          end
+          context 'with invalid input' do
+            let(:input) { { foo: { a: 1, b: 2, c: 3, d: 4 } } }
+            it 'is not successful' do
+              expect(result).to be_failing ['size must be within 2 - 3']
+            end
+          end
+        end
+        context 'with maybe' do
+          subject(:schema) do
+            Dry::Validation.Schema do
+              optional(:foo).maybe(size?: 2..3)
+            end
+          end
+          context 'with valid input' do
+            let(:input) { { foo: [1, 2, 3] } }
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+          context 'with missing input' do
+            let(:input) { {} }
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+          context 'with nil input' do
+            let(:input) { { foo: nil } }
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+          context 'with blank input' do
+            let(:input) { { foo: '' } }
+            #see: https://github.com/dry-rb/dry-validation/issues/121
+            xit 'is not successful' do
+              expect(result).to be_failing ['length must be within 2 - 3']
+            end
+          end
+          context 'with invalid input' do
+            let(:input) { { foo: { a: 1, b: 2, c: 3, d: 4 } } }
+            it 'is not successful' do
+              expect(result).to be_failing ['size must be within 2 - 3']
+            end
+          end
+        end
+      end
+    end
+  end
+end