activevalidation 0.1.0 → 1.0.0

data/spec/active_validation_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe ActiveValidation do
+  it ".config method return actual Configuration" do
+    expect(subject.config).to be_a ActiveValidation::Configuration
+  end
+
+  it "setups proper default adapter" do
+    expect(subject.configuration.orm_adapter.adapter_name).to eq ENV["ORM"]
+  end
+
+  context "verifier_defaults" do
+    it "does not raise if no block provided" do
+      expect { subject.configuration.verifier_defaults }.not_to raise_error
+    end
+  end
+end

data/spec/factories/internal/internal_check.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/BlockLength
+FactoryBot.define do
+  factory(:internal_check) do
+    initialize_with { new(method_name: method_name, argument: argument, options: options) }
+    options { {} }
+
+    factory :internal_check_validate, class: "ActiveValidation::Internal::Models::Check" do
+      method_name { "validate" }
+      argument    { "my_method" }
+    end
+
+    factory :internal_check_validates, class: "ActiveValidation::Internal::Models::Check" do
+      method_name { "validates" }
+      argument    { "name" }
+      options     { { "presence" => true } }
+    end
+
+    factory :internal_check_validates_with, class: "ActiveValidation::Internal::Models::Check" do
+      transient do
+        # Generate validator for the argument
+        with_validator_klass { true }
+      end
+
+      method_name { "validates_with" }
+      argument    { "MyValidator" }
+
+      after(:build) do |record, evaluator|
+        next unless evaluator.with_validator_klass
+
+        klass = Class.new(ActiveModel::Validator) do
+          def initialize(*); end
+
+          def validate(*); end
+        end
+
+        RSpec::Mocks::ConstantMutator.stub(record.argument, klass)
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/BlockLength

data/spec/features/active_record/child_record.feature

@@ -0,0 +1,32 @@
+@active_record
+
+Feature: When the class is a child of active_validation class it should
+  preform own checks and parent checks with correct versions
+
+Background:
+    Given class Bar with active validation and superclass ActiveRecord::Base
+    And   class Foo with active validation and superclass Bar
+    And   defined versions are:
+    | klass | version |
+    |   Foo |       1 |
+    |   Foo |       2 |
+    |   Bar |       1 |
+    |   Bar |       2 |
+
+    When klass Bar have method 'parent_method'
+    And  Bar have manifest version 2 with checks:
+    | method_name | argument      | options                       |
+    |   validates | parent_method | { inclusion: { in: ['v2'] } } |
+    And  Bar have manifest version 1 with checks:
+    | method_name | argument      | options                       |
+    |   validates | parent_method | { inclusion: { in: ['v1'] } } |
+    And store Foo instance in record variable
+
+
+    Scenario: With parent validation check
+    When variable record method 'parent_method' returns 'v2'
+    Then variable record should be valid
+
+    Scenario: With out parent validation check
+    When variable record method 'parent_method' returns 'v1'
+    Then variable record should be valid

data/spec/features/active_record/new_record.feature

@@ -0,0 +1,22 @@
+@active_record
+
+Feature: New record do correct checks and store validation version
+
+  Background:
+    Given class Foo with active validation and superclass ActiveRecord::Base
+    And   defined versions are:
+      | klass | version |
+      |   Foo |       1 |
+    When klass Foo have method 'my_method'
+    And  Foo have manifest version unprovided with checks:
+      | method_name | argument  | options            |
+      |   validates | my_method | { presence: true } |
+
+  Scenario: Should use active validation xontext
+    Then class Foo instance should not be valid
+
+  Scenario: Should became valid
+    When store Foo instance in record variable
+    When variable record method 'my_method' returns something
+    Then variable record should be valid
+

data/spec/features/no_orm/install.feature

@@ -0,0 +1,19 @@
+@no_orm
+
+Feature: Manual installation is possible
+  We are able to install active validation with out any ORM
+
+  Background:
+    Given class Foo with active validation with out ORM
+
+  Scenario: With defaults and with out any Versions
+    When active validation for class Foo installed
+    Then class Foo instance should be valid
+
+  Scenario: With defaults and with defined Versions
+    When defined versions are:
+        | klass | version |
+        |   Foo |      23 |
+        |   Foo |      42 |
+    When active validation for class Foo installed
+    Then class Foo instance should be valid

data/spec/features/no_orm/validate.feature

@@ -0,0 +1,27 @@
+@no_orm
+
+Feature: Validate instance is possible
+  With manual installation we can validate the instance with
+  provided validations
+
+  Background:
+    Given class Foo with active validation with out ORM
+    And   defined versions are:
+           | klass | version |
+           |   Foo |       1 |
+    When klass Foo have method 'my_method'
+    And  Foo have manifest version unprovided with checks:
+      | method_name | argument  | options            |
+      |   validates | my_method | { presence: true } |
+    And  active validation for class Foo installed
+
+
+  Scenario: The validations from the manifest should apply on the instance with out the context
+    Then class Foo instance should not be valid
+
+  Scenario: The validations from newer manifest should apply on the instance with out the context
+    And  Foo have manifest version unprovided with checks:
+      | method_name | argument  | options             |
+      |   validates | my_method | { presence: false } |
+
+    Then class Foo instance should be valid

data/spec/features/no_orm/validate_with_multiple_manifests.feature

@@ -0,0 +1,29 @@
+@no_orm
+
+Feature: Validate instance is possible
+  With manual installation we can validate the instance with
+  provided validations, when there are a few manifests.
+
+  Background:
+    Given class Foo with active validation with out ORM
+    And   defined versions are:
+           | klass | version |
+           |   Foo |       1 |
+    When klass Foo have method 'my_method'
+    And  Foo have manifest version unprovided with checks:
+      | method_name | argument  | options            |
+      |   validates | my_method | { presence: false } |
+    And active validation for class Foo installed
+    And store Foo instance in record variable
+    And klass Foo have method 'another_method'
+    And Foo have manifest version unprovided with checks:
+      | method_name | argument       | options            |
+      |   validates | another_method | { presence: true } |
+    And active validation for class Foo installed
+
+  Scenario: The validations from the manifest should not apply on the instance with out the context
+    Then variable record should not be valid
+
+  Scenario: The validations from the manifest should apply on the instance with correct context
+    When variable record method 'another_method' returns something
+    Then variable record should be valid

data/spec/features/no_orm/validate_with_multiple_versions.feature

@@ -0,0 +1,42 @@
+@no_orm
+
+Feature: Validate instance is possible
+  With manual installation we can validate the instance with
+  provided validations, when there are a few manifests in
+  different versions.
+
+  Background:
+    Given class Foo with active validation with out ORM
+    And   defined versions are:
+           | klass | version |
+           |   Foo |       1 |
+    When klass Foo have method 'my_method'
+    And  Foo have manifest version 1 with checks:
+      | method_name | argument  | options            |
+      |   validates | my_method | { presence: true } |
+    And active validation for class Foo installed
+    And store Foo instance in record variable
+    And set variable record manifest to current
+    And defined versions are:
+      | klass | version |
+      |   Foo |       2 |
+    And klass Foo have method 'another_method'
+    And Foo have manifest version 2 with checks:
+      | method_name | argument       | options            |
+      |   validates | another_method | { presence: true } |
+    And store Foo instance in record_v2 variable
+    And set active validation version for klass Foo to 2
+    And active validation for class Foo installed
+
+
+  Scenario: Should ve validated with version 1
+    Then variable record should not be valid
+    Then variable record error message should be on my_method
+
+  Scenario: The v2 record should check only another_method and be valid
+    When variable record_v2 method 'another_method' returns something
+    Then variable record_v2 should be valid
+
+  Scenario: The v2 record should check only another_method
+    Then variable record_v2 should not be valid
+    Then variable record_v2 error message should be on another_method

data/spec/features/placeholders/be_matcher.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+placeholder :be_matcher do
+  match(/be (\w+)/) do |name|
+    "be_#{name}"
+  end
+end

data/spec/features/placeholders/klass.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+placeholder :klass do
+  match(/[\w|:]+/, &:constantize)
+end

data/spec/features/placeholders/version.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+placeholder :version do
+  match(/unprovided|none|undefined/) do
+    nil
+  end
+
+  match(/\d+/) do |version|
+    version.to_i.tap { |ver| raise("Version must be integer") if ver.zero? }
+  end
+end

data/spec/features/placeholders/whether_to.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+placeholder :whether_to do
+  match(/should not/) do
+    false
+  end
+
+  match(/should/) do
+    true
+  end
+end

data/spec/features/step_definitions/active_record_steps.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+return unless ENV["ORM"] == "active_record"
+
+step("class :string with active validation and superclass :klass") do |klass_name, super_klass|
+  define_const(klass_name, superclass: super_klass).active_validation
+end

data/spec/features/step_definitions/steps.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+step("class :string with active validation with out ORM") do |klass_name|
+  define_const klass_name do
+    include ActiveModel::Validations
+    include ActiveValidation::ModelExtensionBase
+    active_validation
+
+    attr_accessor :manifest
+  end
+end
+
+step("defined versions are:") do |table|
+  table.rows.each do |(klass_name, version)|
+    define_const "#{klass_name}::Validations::V#{version}"
+  end
+end
+
+step("active validation for class :klass installed") do |klass|
+  klass.active_validation.install
+end
+
+step("class :klass instance in context ':string' :whether_to be valid") do |klass, context, expectation|
+  expect(klass.new.valid?(context)).to eq expectation
+end
+
+step("variable :string in context ':string' :whether_to be valid") do |instance_var_name, context, expectation|
+  instance = instance_variable_get "@#{instance_var_name}"
+  expect(instance.valid?(context)).to eq expectation
+end
+
+step("class :klass instance :whether_to :be_matcher") do |klass, positive, matcher|
+  expectation = positive ? :to : :not_to
+
+  expect(klass.new).send expectation, send(matcher)
+end
+
+step("variable :string :whether_to :be_matcher") do |instance_var_name, positive, matcher|
+  expectation = positive ? :to : :not_to
+  instance = instance_variable_get "@#{instance_var_name}"
+
+  expect(instance).send expectation, send(matcher)
+end
+
+step("klass :klass have method :string") do |klass, method_name|
+  klass.send(:define_method, method_name) { nil }
+end
+
+# rubocop:disable Security/Eval
+step(":klass have manifest version :version with checks:") do |klass, version, table|
+  checks = table.rows.map do |(method_name, argument, options)|
+    { method_name: method_name, argument: argument, options: eval(options) }
+  end
+
+  klass.active_validation.add_manifest checks_attributes: checks, version: version
+end
+# rubocop:enable Security/Eval
+
+step("store :klass instance in :string variable") do |klass, variable|
+  instance_variable_set("@#{variable}", klass.new)
+end
+
+step("variable :string method ':string' returns :string") do |instance_var_name, method_name, returns|
+  variable = instance_variable_get("@#{instance_var_name}")
+  variable.define_singleton_method(method_name) { returns }
+end
+
+step("variable :string error message :whether_to be on :string") do |instance_var_name, expectation, method_name|
+  variable = instance_variable_get("@#{instance_var_name}")
+  check_method = expectation ? :to : :to_not
+
+  expect(variable.errors.messages).send(check_method, have_key(method_name.to_sym))
+end
+
+step("set active validation version for klass :klass to :version") do |klass, version|
+  klass.active_validation.version = version.to_i
+end
+
+step("set variable :string manifest to :string") do |instance_var_name, state|
+  variable = instance_variable_get("@#{instance_var_name}")
+  variable.manifest = case state
+                      when "current" then variable.class.active_validation.current_manifest
+                      when "none" then nil
+                      end
+end

data/spec/orm/active_record/db_adapters/database.mysql.yml

@@ -0,0 +1,12 @@
+default: &default
+  adapter:  mysql2
+  encoding: utf8
+  database: test
+  pool:     5
+  username: root
+  password:
+  host:     localhost
+
+test:
+  <<: *default
+  database: test

data/spec/orm/active_record/db_adapters/database.postgres.yml

@@ -0,0 +1,11 @@
+default: &default
+  adapter:  postgresql
+  username: postgres
+  password:
+  host:     localhost
+  port:     5432
+  database: test
+
+test:
+  <<: *default
+  database: test

data/spec/orm/active_record/db_adapters/database.sqlite.yml

@@ -0,0 +1,8 @@
+default: &default
+  adapter: sqlite3
+  pool: 5
+  timeout: 5000
+
+test:
+  <<: *default
+  database: ":memory:"

data/spec/orm/active_record/factories/check/check_validate.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :check_validate, class: "ActiveValidation::Check::ValidateMethod" do
+    argument { "foo_allowed" }
+    options { {} }
+  end
+end

data/spec/orm/active_record/factories/check/check_validates.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :check_validates, class: "ActiveValidation::Check::ValidatesMethod" do
+    argument { "name" }
+    options  { { presence: true } }
+  end
+end

data/spec/orm/active_record/factories/check/check_validates_with.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :check_validates_with, class: "ActiveValidation::Check::ValidatesWithMethod" do
+    transient do
+      # Generate validator for the argument
+      with_validator_klass { true }
+    end
+
+    argument { "FooValidator" }
+    options { {} }
+
+    after(:build) do |record, evaluator|
+      next unless evaluator.with_validator_klass
+
+      RSpec::Mocks::ConstantMutator.stub(record.argument, Class.new(ActiveModel::Validator))
+    end
+  end
+end