activevalidation 0.1.0 → 1.0.0

data/spec/active_validation/decorators/consistent_registry_spec.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+describe ActiveValidation::Decorators::ConsistentRegistry do
+  subject { described_class.new(klass, registry) }
+
+  let(:klass) { define_const("VerifierDouble") { def initialize(_arg); end } }
+  let(:bar) { define_const "Bar" }
+
+  let(:registry) { ActiveValidation::Registry.new("Great thing") }
+  let(:inconsistent_error_class) { ActiveValidation::Errors::InconsistentRegistryError }
+
+  let(:registered_object)        { instance_double("registered object") }
+
+  context "#initialize" do
+    context "raise" do
+      it "raises an error if klass not provided" do
+        expect { described_class.new(nil, registry) }.to raise_error NameError
+      end
+
+      it "raises an error if klass argument is not a class" do
+        expect { described_class.new(:not_a_class, registry) }.to raise_error NameError
+      end
+    end
+
+    it "works if klass provided as Class" do
+      expect(subject).to be_a ActiveValidation::Registry
+    end
+
+    it "works if klass provided as String" do
+      expect(described_class.new(klass.name, registry)).to be_a ActiveValidation::Registry
+    end
+  end
+
+  it "have :klass reader" do
+    decorator = described_class.new(klass, "name")
+
+    expect(decorator.klass).to eq(klass)
+  end
+
+  context "#first_or_build" do
+    context "existed record" do
+      before { subject.register(bar.name, klass.new(bar)) }
+
+      it "find" do
+        expect(subject.find_or_build(bar.name)).to be_a klass
+      end
+
+      it "yield given block" do
+        expect { |b| subject.find_or_build(bar.name, &b) }.to yield_control
+      end
+    end
+
+    context "new record" do
+      it "if not found build a new record" do
+        expect(subject.find_or_build(klass.name)).to be_a klass
+      end
+
+      it "is not registered by registry by default" do
+        subject.find_or_build(klass.name)
+        expect(registry).not_to be_registered(klass.name)
+      end
+
+      it "yield given block on new record" do
+        klass_instance = klass.new bar
+        allow(klass).to receive(:new) do |record, &blk|
+          expect(record).to eq bar
+          expect(blk.call).to eq :passed
+          klass_instance
+        end
+
+        subject.find_or_build(bar, &-> { :passed })
+      end
+    end
+  end
+
+  context "#find_or_add" do
+    context "with existed record" do
+      before { subject.register(bar.name, klass.new(bar)) }
+
+      it "finds" do
+        expect(subject.find_or_add(bar.name)).to be_a klass
+      end
+
+      it "do not try to add record to registry" do
+        expect(registry).to include subject.find_or_add(bar.name)
+        expect(registry.count).to eq 1
+      end
+    end
+
+    context "with new record" do
+      it "finds" do
+        expect(subject.find_or_add(bar.name)).to be_a klass
+      end
+
+      it "add record to registry" do
+        expect(registry).to include subject.find_or_add(bar.name)
+        expect(registry.count).to eq 1
+      end
+    end
+  end
+
+  context "register" do
+    context "raise" do
+      it "with inconsistent value" do
+        value = define_const "Wrong"
+        expect { subject.register(bar.name, value) }.to raise_error ActiveValidation::Errors::InconsistentRegistryError
+        expect { subject.find(bar.name) }.to raise_error KeyError
+      end
+    end
+
+    it "registers the entry" do
+      value = klass.new(bar)
+      expect(subject.register(bar.name, value)).to eq value
+      expect(subject.find(bar.name)).to eq value
+    end
+  end
+end

data/spec/active_validation/decorators/disallows_duplicates_registry_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+describe ActiveValidation::Decorators::DisallowsDuplicatesRegistry do
+  subject { described_class.new(registry) }
+
+  let(:registry) { ActiveValidation::Registry.new("Great thing") }
+  let(:error_class) { ActiveValidation::Errors::DuplicateRegistryEntryError }
+
+  let(:registered_object)        { instance_double("registered object") }
+
+  it "finds a registered object" do
+    subject.register(:object_name, registered_object)
+    expect { subject.register(:object_name, registered_object) }.to raise_error error_class
+  end
+
+  it "find a registered class" do
+    define_const "Foo"
+    subject.register(:object_name, Foo)
+    expect { subject.register(:object_name, Foo) }.to raise_error error_class
+  end
+end

data/spec/active_validation/formatters/manifest_name_formatter_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+describe ActiveValidation::Formatters::ManifestNameFormatter do
+  it "formats the name" do
+    expect(described_class.call("Test")).to eq "Manifest for Test"
+  end
+end

data/spec/active_validation/formatters/validation_context_formatter_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+describe ActiveValidation::Formatters::ValidationContextFormatter do
+  context "no options" do
+    context "no name" do
+      let(:manifest) do
+        instance_double ActiveValidation::Internal::Models::Manifest, id: 23, options: {}, name: nil
+      end
+
+      it { expect(described_class.call(manifest)).to eq "active_validation_id23" }
+    end
+
+    context "with name" do
+      let(:manifest) do
+        instance_double ActiveValidation::Internal::Models::Manifest, id: 23, options: {}, name: :my_name
+      end
+
+      it { expect(described_class.call(manifest)).to eq "active_validation_id23_my_name" }
+    end
+  end
+
+  context "with `on` option" do
+    context "no name" do
+      let(:manifest) do
+        instance_double ActiveValidation::Internal::Models::Manifest, id: 23, options: { on: :new }, name: nil
+      end
+
+      it { expect(described_class.call(manifest)).to eq "active_validation_id23_on_new" }
+    end
+
+    context "with name" do
+      let(:manifest) do
+        instance_double ActiveValidation::Internal::Models::Manifest, id: 23, options: { on: :new }, name: :my_name
+      end
+
+      it { expect(described_class.call(manifest)).to eq "active_validation_id23_on_new_my_name" }
+    end
+  end
+end

data/spec/active_validation/internal/models/check_spec.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+describe ActiveValidation::Internal::Models::Check do
+  subject { described_class.new method_name: "validates", argument: "name" }
+
+  let(:registry) { ActiveValidation.config.method_name_values_registry }
+
+  %i[method_name argument options created_at].each do |m|
+    it { is_expected.to have_attr_reader m }
+  end
+
+  it "converts the method name to value object" do
+    expect(subject.method_name).to be_a ActiveValidation::Values::MethodName
+  end
+
+  it "add method name to the registry" do
+    registry.clear
+    subject
+    expect(registry.count).to eq 1
+  end
+
+  context "#to_hash" do
+    it "converts to Hash with out coercion" do
+      expect { Hash(subject) }.not_to raise_error
+    end
+  end
+
+  context "#as_json" do
+    %i[method_name argument options].each do |attr|
+      it("has '#{attr}' attribute") { expect(subject.as_json[attr]).to be_truthy }
+    end
+
+    it "works correctly with out 'only' option" do
+      expect(subject.as_json).to eq subject.to_hash
+    end
+
+    it "produce right output with 'only' option argument" do
+      expect(subject.as_json(only: [:argument])).to eq(argument: "name")
+    end
+
+    it "produce right output with 'only' option created_at" do
+      check = described_class.new method_name: "validates", argument: "name", created_at: "10AM"
+      expect(check.as_json(only: [:created_at])).to eq(created_at: "10AM")
+    end
+  end
+
+  context "#normalized_argument" do
+    %i[validate validates].each do |m|
+      it "for #{m}" do
+        check = described_class.new method_name: m, argument: "name"
+        expect(check.normalized_argument).to eq :name
+      end
+    end
+
+    it "for validates_with" do
+      define_const "MyValidator", superclass: ActiveModel::Validator
+      check = described_class.new method_name: :validates_with, argument: "MyValidator"
+      expect(check.normalized_argument).to eq MyValidator
+    end
+  end
+
+  it "is equal" do
+    check1 = described_class.new method_name: "validates", argument: "name", options: { name: "foo" }
+    check2 = described_class.new method_name: "validates", argument: "name", options: { name: "foo" }
+    expect(check1).to eq check2
+  end
+end

data/spec/active_validation/internal/models/manifest/installer_spec.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+describe ActiveValidation::Internal::Models::Manifest::Installer do
+  subject { described_class.new base_class: Bar, context: context }
+
+  let(:check_validate)       { build :internal_check_validate       }
+  let(:check_validates)      { build :internal_check_validates      }
+  let(:check_validates_with) { build :internal_check_validates_with }
+
+  let(:callbacks) { Bar._validate_callbacks.send(:chain) }
+  let(:context)   { "active_validation_1" }
+
+  before do
+    define_const("Bar") { include ActiveModel::Validations }
+  end
+
+  %i[base_class installed_callbacks checks context].each do |m|
+    it { is_expected.to have_attr_reader m }
+  end
+
+  context "#install" do
+    context "with 3 validations" do
+      before do
+        subject.checks << check_validate << check_validates << check_validates_with
+        subject.install
+      end
+
+      it "setup validations to base_klass" do
+        expect(Bar.validators).to include a_kind_of ActiveModel::Validations::PresenceValidator
+        expect(Bar.validators).to include a_kind_of MyValidator
+        expect(Bar.validators.size).to eq 2
+      end
+
+      it "setups default factories callbacks to default model" do
+        expect(callbacks.size).to eq 3
+      end
+
+      it "setups installed callbacks to default model" do
+        expect(subject.installed_callbacks.size).to eq 3
+      end
+    end
+
+    context "validations should be in the right context" do
+      let(:callback) { callbacks.last }
+      let(:bar) { Bar.new }
+
+      shared_examples "check with context" do
+        it "does not execute with out the context" do
+          bar.valid?
+          expect(validator).not_to have_received(:validate)
+        end
+
+        it "executes with the context" do
+          bar.valid?(subject.context)
+          expect(validator).to have_received(:validate)
+        end
+      end
+
+      context "validates_with" do
+        let(:validator) { instance_double MyValidator }
+
+        before do
+          subject.checks << check_validates_with
+          allow(MyValidator).to receive(:new).and_return(validator)
+          allow(validator).to receive(:validate)
+          subject.install
+        end
+
+        include_examples "check with context"
+      end
+
+      context "validates" do
+        let(:validator) { instance_double ActiveModel::Validations::PresenceValidator }
+
+        before do
+          subject.checks << check_validates
+          allow(ActiveModel::Validations::PresenceValidator).to receive(:new).and_return(validator)
+          allow(validator).to receive(:validate)
+          subject.install
+        end
+
+        include_examples "check with context"
+      end
+
+      context "validate" do
+        before do
+          define_const("Bar") do
+            include ActiveModel::Validations
+            def my_method; end
+          end
+
+          subject.checks << check_validate
+          allow(Bar).to receive(:new).and_return(bar)
+          allow(bar).to receive(:my_method)
+          subject.install
+        end
+
+        it "does not execute with out the context" do
+          bar.valid?
+          expect(bar).not_to have_received(:my_method)
+        end
+
+        it "executes with the context" do
+          bar.valid?(subject.context)
+          expect(bar).to have_received(:my_method)
+        end
+      end
+    end
+  end
+
+  context "#uninstall" do
+    let(:check_validate2)       { build :internal_check_validate       }
+    let(:check_validates2)      { build :internal_check_validates      }
+    let(:check_validates_with2) { build :internal_check_validates_with, argument: "MyValidator2" }
+
+    before do
+      define_const("Bar") { include ActiveModel::Validations }
+      subject.checks << check_validate << check_validates << check_validates_with
+      subject.install
+    end
+
+    context "should correctly remove all checks" do
+      before { subject.uninstall }
+
+      it("does not have any callback chain") { expect(callbacks).to be_empty }
+
+      it("does not contain any validators") { expect(Bar.validators).to be_empty }
+    end
+
+    context "does not affect checks from another installer on another class" do
+      let(:installer2) { described_class.new context: context, base_class: Baz }
+
+      before do
+        define_const("Baz") { include ActiveModel::Validations }
+        installer2.checks << check_validate2 << check_validates2 << check_validates_with2
+        installer2.install
+        subject.uninstall
+      end
+
+      it("does not have any callback chain") { expect(callbacks).to be_empty }
+
+      it("does not affect installer2 checks") { expect(installer2.callbacks_chain.count).to eq 3 }
+    end
+
+    context "does not other affect native checks on the base class" do
+      before do
+        subject.base_class.public_send(*check_validate2.to_validation_arguments)
+        subject.base_class.public_send(*check_validates_with2.to_validation_arguments)
+        subject.uninstall
+      end
+
+      it("has 2 callbacks in the chain") { expect(callbacks.count).to eq 2 }
+
+      it("have correct validator") { expect(Bar.validators).to all(be_a_kind_of(MyValidator2)) }
+      it("has only one validator") { expect(Bar.validators.size).to eq 1 }
+    end
+
+    context "with nested class" do
+      let(:child) { described_class.new base_class: BarChild, context: context }
+      let(:child_callbacks) { BarChild._validate_callbacks.send(:chain) }
+
+      before do
+        define_const "BarChild", superclass: Bar
+      end
+
+      it("has 3 callbacks in the chain") { expect(child_callbacks.count).to eq 3 }
+      it("has 2 validators") { expect(BarChild.validators.size).to eq 2 }
+
+      context "after uninstall on the parent" do
+        before { subject.uninstall }
+
+        it("has 0 callbacks in the chain") { expect(child_callbacks.count).to eq 0 }
+        it("has 0 validators") { expect(BarChild.validators.size).to eq 0 }
+      end
+    end
+  end
+end

data/spec/active_validation/internal/models/manifest_spec.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+describe ActiveValidation::Internal::Models::Manifest do
+  subject { described_class.new version: 1, base_klass: "Foo" }
+
+  before { define_const "Foo" }
+
+  let(:check_validate)       { build :internal_check_validate       }
+  let(:check_validates)      { build :internal_check_validates      }
+  let(:check_validates_with) { build :internal_check_validates_with }
+
+  %i[version base_klass created_at checks options other id name].each do |m|
+    it { is_expected.to have_attr_reader m }
+  end
+
+  context "#class_name" do
+    it "converts the method name to value object" do
+      expect(subject.base_class).to eq Foo
+    end
+  end
+
+  context "equality check" do
+    it "if id is equal" do
+      common = { version: 1, base_klass: "Foo", id: 42 }
+      manifest1 = described_class.new common
+      manifest2 = described_class.new common
+      expect(manifest1).to eq manifest2
+    end
+
+    it "if attributes is equal, if even id are not" do
+      common = { version: 1, base_klass: "Foo", checks: [], options: { bar: :baz } }
+      manifest1 = described_class.new common.merge id: 1
+      manifest2 = described_class.new common.merge id: 2
+      expect(manifest1).to eq manifest2
+    end
+  end
+
+  context "#to_hash" do
+    it "converts to Hash with out coercion" do
+      expect { Hash(subject) }.not_to raise_error
+    end
+  end
+
+  context "#as_json" do
+    %i[version base_klass checks name id].each do |attr|
+      it("has '#{attr}' attribute") { expect(subject.as_json).to have_key attr }
+    end
+
+    it "works correctly with out 'only' option" do
+      expect(subject.as_json).to eq subject.to_hash
+    end
+
+    it "produce right output with 'only' option base_klass" do
+      expect(subject.as_json(only: [:base_klass])).to eq(base_klass: "Foo")
+    end
+
+    context "with checks" do
+      subject { described_class.new version: 1, base_klass: "Foo", checks: [check1, check2] }
+
+      let(:check1) { build :internal_check_validates, argument: "check1" }
+      let(:check2) { build :internal_check_validate,  argument: "check2" }
+
+      it "with out options" do
+        hash = { version:    1,
+                 base_klass: "Foo",
+                 checks:     [{ method_name: "validates", argument: "check1", options: { "presence" => true } },
+                              { method_name: "validate", argument: "check2", options: {} }],
+                 name:       nil,
+                 id:         nil }
+        expect(subject.as_json).to eq hash
+      end
+
+      it "with options for manifest" do
+        hash = { version: 1,
+                 checks:  [{ method_name: "validates", argument: "check1", options: { "presence" => true } },
+                           { method_name: "validate", argument: "check2", options: {} }] }
+        expect(subject.as_json(only: %i[checks version])).to eq hash
+      end
+
+      it "with options for checks" do
+        hash = { version:    1,
+                 base_klass: "Foo",
+                 checks:     [{ argument: "check1" },
+                              { argument: "check2" }],
+                 name:       nil,
+                 id:         nil }
+        expect(subject.as_json(checks: { only: [:argument] })).to eq hash
+      end
+
+      it "with renamed checks" do
+        hash = { version:           1,
+                 base_klass:        "Foo",
+                 checks_attributes: [{ method_name: "validates", argument: "check1", options: { "presence" => true } },
+                                     { method_name: "validate", argument: "check2", options: {} }],
+                 name:              nil,
+                 id:                nil }
+        expect(subject.as_json(checks: { as: :checks_attributes })).to eq hash
+      end
+    end
+  end
+
+  context "installation" do
+    before do
+      allow(ActiveValidation::Internal::Models::Manifest::Installer).to receive(:new).and_return(installer)
+    end
+
+    let(:installer) do
+      instance_double ActiveValidation::Internal::Models::Manifest::Installer, uninstall: false, install: true
+    end
+
+    context "install" do
+      before { subject.install }
+
+      it("installs once installed") do
+        subject.install
+        expect(installer).to have_received(:install).once
+      end
+
+      it { expect(subject).to be_installed }
+    end
+
+    context "uninstall" do
+      before do
+        subject.install
+        subject.uninstall
+      end
+
+      it("uninstalls once when installed") do
+        subject.uninstall
+        expect(installer).to have_received(:uninstall).once
+      end
+
+      it { expect(subject).not_to be_installed }
+    end
+  end
+end