activevalidation 0.1.0 → 1.0.0

data/spec/active_validation/orm_plugins/active_record_plugin/models/active_validation/check_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+describe ActiveValidation::Check, type: :active_record do
+  it "return empty collection" do
+    expect(described_class.all).to be_empty
+  end
+
+  %i[update update_attribute update_attributes].each do |method|
+    it "raises on #{method}" do
+      expect { subject.send(method) }.to raise_error ActiveValidation::Errors::ImmutableError
+    end
+  end
+
+  context "#method_name" do
+    it { expect { subject.method_name }.to raise_error NotImplementedError }
+  end
+
+  context "#method_name=" do
+    it("Set correct type") do
+      subject.method_name = "foo"
+      expect(subject.type).to eq "FooMethod"
+    end
+  end
+
+  context "#to_internal_check" do
+    %i[check_validate check_validates check_validates_with].each do |type|
+      context(type) do
+        let(:subject) { build type }
+
+        it "produces right class" do
+          expect(subject.to_internal_check).to be_a ActiveValidation::Internal::Models::Check
+        end
+
+        context "has value" do
+          %w[method_name argument].each do |key|
+            it key.to_s do
+              expect(subject.to_internal_check.public_send(key)).to eq subject.public_send(key)
+            end
+
+            it "options" do
+              expect(subject.to_internal_check.options).to eq subject.options.deep_symbolize_keys
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/active_validation/orm_plugins/active_record_plugin/models/active_validation/manifest_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+describe ActiveValidation::Manifest, type: :active_record do
+  %i[update update_attribute update_attributes].each do |method|
+    it "raises on #{method}" do
+      expect { subject.send(method) }.to raise_error ActiveValidation::Errors::ImmutableError
+    end
+  end
+
+  context "with existed model" do
+    before do
+      define_const("Foo", superclass: ActiveRecord::Base)
+      define_const("FooValidator", superclass: ActiveModel::Validator)
+    end
+
+    it "accepts nested attributes for checks" do
+      described_class.create name: "foo's manifest", version: 1, base_klass: "Foo", checks_attributes: [
+        attributes_for(:check_validates),
+        attributes_for(:check_validate),
+        attributes_for(:check_validates_with)
+      ]
+
+      expect(described_class.count).to eq 1
+      expect(ActiveValidation::Check.count).to eq 3
+    end
+  end
+
+  context "factories traits" do
+    %i[validate validates validates_with].each do |trait|
+      it "accept Factory trait #{trait} and build corresponding check" do
+        expect(build(:manifest, trait).checks.size).to eq 1
+      end
+    end
+  end
+
+  context "#to_internal_manifest" do
+    let(:subject) { build :manifest, :validate }
+
+    it "produces right class" do
+      expect(subject.to_internal_manifest).to be_a ActiveValidation::Internal::Models::Manifest
+    end
+
+    context "has value" do
+      %w[name version base_klass].each do |key|
+        it key.to_s do
+          expect(subject.to_internal_manifest.public_send(key)).to eq subject.public_send(key)
+        end
+      end
+
+      context "checks" do
+        subject { build(:manifest, :validate, :validates).to_internal_manifest.checks }
+
+        let!(:wrong) { build(:manifest, :validate) }
+
+        it { is_expected.to be_a Array }
+        it { is_expected.to all a_kind_of ActiveValidation::Internal::Models::Check }
+        it { is_expected.to have_attributes length: 2 }
+      end
+    end
+  end
+end

data/spec/active_validation/orm_plugins/active_record_plugin/readme_spec.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+# At this moment there is only Active record Plugin, so it is
+# used in the Readme files for examples.
+
+# rubocop:disable RSpec/DescribeClass
+# rubocop:disable RSpec/ExampleLength
+describe "Readme" do
+  let(:manifest_with_checks) do
+    {
+      base_klass:        "Foo", # Name of the Model Class
+      version:           1, # optional, by default use locked or latest version
+      name:              "awesome-foo", # optional, some name for easier managing
+
+      # the syntax is the same with ActiveModel. For :validates_with and :validate `options` field is optional
+      checks_attributes: [
+        { method_name: "validates", argument: "my_method", options: { presence: true } },
+        { method_name: "validates_with", argument: "MyValidator" },
+        { method_name: "validate", argument: "my_validation_method" }
+      ]
+    }
+  end
+
+  let(:empty_manifest) do
+    {
+      base_klass:        "Foo", # Name of the Model Class
+      checks_attributes: []
+    }
+  end
+
+  before do
+    define_const("Foo", superclass: ActiveRecord::Base) do
+      active_validation
+
+      def my_method; end
+
+      def my_validation_method
+        errors.add(:base, "we'd called validation method")
+      end
+    end
+
+    define_const("MyValidator", superclass: ActiveModel::Validator) do
+      def validate(*); end
+    end
+
+    define_const "Foo::Validations::V1"
+  end
+
+  it "manifest manipulations" do
+    # This is how you can add the new manifest
+
+    Foo.active_validation.add_manifest(manifest_with_checks)
+
+    f = Foo.new
+
+    expect(f).not_to be_valid
+    expect(f.errors.messages).to have_key(:my_method)
+    expect(f.errors.messages).to have_key(:base)
+
+    # new manifest will be used for new records, while existed records
+    # continue using one of the previous versions
+    # the same result will be with `Foo.active_validation.add_manifest`
+    Foo.active_validation.add_manifest(empty_manifest)
+
+    expect(f).to be_valid
+
+    # get all manifests for current version
+    manifests = Foo.active_validation.find_manifests
+
+    expect(manifests.size).to eq 2
+
+    # we can specify version, if we want to
+    Foo.active_validation.find_manifests version: 42
+
+    # Get the latest manifest
+    manifest = Foo.active_validation.find_manifest
+
+    # we can con edit existed manifests, but we can easily
+    # create the new one based on the existed
+    Foo.active_validation.add_manifest(manifest.as_json.tap do |m|
+      m[:name] = "Something"
+      m[:id] = nil
+    end)
+
+    expect(Foo.active_validation.find_manifest.name).to eq "Something"
+  end
+end
+# rubocop:enable RSpec/DescribeClass
+# rubocop:enable RSpec/ExampleLength

data/spec/active_validation/registry_spec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+describe ActiveValidation::Registry do
+  subject { described_class.new("Great thing") }
+
+  let(:registered_object)        { instance_double("registered object") }
+  let(:second_registered_object) { instance_double("second registered object") }
+
+  it { is_expected.to be_kind_of(Enumerable) }
+
+  it "finds a registered object" do
+    subject.register(:object_name, registered_object)
+    expect(subject.find(:object_name)).to eq registered_object
+  end
+
+  it "finds a registered object with square brackets" do
+    subject.register(:object_name, registered_object)
+    expect(subject[:object_name]).to eq registered_object
+  end
+
+  it "raises when an object cannot be found" do
+    expect { subject.find(:object_name) }
+      .to raise_error(KeyError, "Great thing not registered: \"object_name\"")
+  end
+
+  it "adds and returns the object registered" do
+    expect(subject.register(:object_name, registered_object)).to eq registered_object
+  end
+
+  it "knows that an object is registered by symbol" do
+    subject.register(:object_name, registered_object)
+    expect(subject).to be_registered(:object_name)
+  end
+
+  it "knows that an object is registered by string" do
+    subject.register(:object_name, registered_object)
+    expect(subject).to be_registered("object_name")
+  end
+
+  it "knows when an object is not registered" do
+    expect(subject).not_to be_registered("bogus")
+  end
+
+  it "iterates registered objects" do
+    subject.register(:first_object, registered_object)
+    subject.register(:second_object, second_registered_object)
+    expect(subject.to_a).to eq [registered_object, second_registered_object]
+  end
+
+  it "does not include duplicate objects with registered under different names" do
+    subject.register(:first_object, registered_object)
+    subject.register(:second_object, registered_object)
+    expect(subject.to_a).to eq [registered_object]
+  end
+
+  it "clears registered objects" do
+    subject.register(:object_name, registered_object)
+    subject.clear
+    expect(subject.count).to be_zero
+  end
+
+  it "delete selected object" do
+    subject.register(:first_object, registered_object)
+    subject.register(:second_object, second_registered_object)
+    subject.delete :first_object
+    expect(subject.to_a).to eq [second_registered_object]
+  end
+
+  it "store object key as symbol" do
+    subject.register("first object", registered_object)
+    subject.register(42, registered_object)
+    expect(subject).to be_registered(:"first object")
+    expect(subject).to be_registered(:"42")
+    expect(subject).not_to be_registered(:not_exist)
+  end
+end

data/spec/active_validation/values/base_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+describe ActiveValidation::Values::Base do
+  subject { described_class.new("42") }
+
+  context "Set" do
+    it("value") { expect(described_class.new(1).value).to eq 1 }
+  end
+
+  context "Get" do
+    it("value") { expect(subject.value).to eq "42" }
+  end
+
+  context "raise" do
+    [nil, true, false].each do |el|
+      it("from #{el}") { expect { described_class.new(el).value }.to raise_error ArgumentError }
+    end
+  end
+
+  context "<=>" do
+    subject { %i[1 5 9 3 7].map { |n| described_class.new n } }
+
+    it("sort") { expect(subject.sort.map(&:to_s)).to eq %w[1 3 5 7 9] }
+  end
+
+  context "==" do
+    context "comarison instance vs value" do
+      let(:version1) { described_class.new 1 }
+      let(:another_version1) { described_class.new 1 }
+
+      it("is equal") { expect(version1).to eq another_version1 }
+      it("is not equal") { expect(version1).not_to eq subject }
+    end
+
+    context "comarison instance vs instance" do
+      let(:struct) { Struct.new(:foo) }
+      let(:version1) { described_class.new struct.new(foo: 42) }
+      let(:another_version1) { described_class.new struct.new(foo: 42) }
+
+      it("is equal") { expect(version1).to eq another_version1 }
+      it("is not equal") { expect(version1).not_to eq subject }
+    end
+  end
+
+  context "to_s" do
+    it("convert integer to string") { expect(described_class.new(1).to_s).to eq "1" }
+    it("convert symbol to string") { expect(described_class.new(:foo).to_s).to eq "foo" }
+  end
+
+  context "to_sym" do
+    it("convert string to symbol") { expect(described_class.new(:foo).to_sym).to eq :foo }
+  end
+
+  context "to_json" do
+    it("return only value") { expect(described_class.new(42).to_json).to eq "42" }
+  end
+
+  context "as_json" do
+    it("return only value") { expect(described_class.new(42).as_json).to eq 42 }
+  end
+end

data/spec/active_validation/values/method_name_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+describe ActiveValidation::Values::MethodName do
+  context "::new" do
+    %w[validates validates_with validate].each do |name|
+      it("generate #{name}") { expect(described_class.new(name).value).to eq name }
+      it("is a String #{name}") { expect(described_class.new(name).value).to be_a String }
+    end
+
+    context "raise" do
+      let(:error_class) { ActiveValidation::Errors::UnsupportedMethodError }
+
+      it("method is not allowed") { expect { described_class.new("bad").value }.to raise_error error_class }
+    end
+  end
+end

data/spec/active_validation/values/version_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+describe ActiveValidation::Values::Version do
+  context "::new" do
+    context 'with "V" prefix' do
+      it("from symbol") { expect(described_class.new(:V42).value).to eq 42 }
+      it("from string") { expect(described_class.new("V42").value).to eq 42 }
+    end
+
+    context 'with out "V" prefix' do
+      it("from symbol") { expect(described_class.new(:'42').value).to eq 42 }
+      it("from string") { expect(described_class.new("42").value).to eq 42 }
+    end
+
+    context "raise" do
+      [nil, true, false, "Foo1", "V55A"].each do |el|
+        it("from #{el}") { expect { described_class.new(el).value }.to raise_error ArgumentError }
+      end
+    end
+
+    it("set the value from integer") { expect(described_class.new(42).value).to eq 42 }
+
+    context "to_i" do
+      it("string to integer") { expect(described_class.new("42").to_i).to eq 42 }
+      it("symbol to integer") { expect(described_class.new("V42").to_i).to eq 42 }
+    end
+
+    context "to_json" do
+      it("return only value") { expect(described_class.new(42).to_json).to eq "42" }
+    end
+
+    context "as_json" do
+      it("return only value") { expect(described_class.new(42).as_json).to eq 42 }
+    end
+  end
+end

data/spec/active_validation/verifier_spec.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+describe ActiveValidation::Verifier do
+  subject { described_class.find_or_build "Foo" }
+
+  let(:model) { define_const("Foo") { attr_reader :manifest } }
+
+  context "class methods" do
+    subject { described_class }
+
+    it "return the global registry for verifier" do
+      expect(subject.registry).to eq ActiveValidation.config.verifiers_registry
+    end
+
+    it { is_expected.to delegate(:find_or_build).to(:registry) }
+  end
+
+  %i[failed_attempt_retry_time
+     enabled
+     observer
+     validations_module_name
+     base_klass
+     orm_adapter
+     manifest_name_formatter
+     manifest].each { |m| it { is_expected.to have_attr_reader m } }
+
+  it { is_expected.to delegate(:install).to(:observer) }
+
+  context "with fake registry" do
+    subject { described_class.find_or_build "Bar" }
+
+    let!(:bar) do
+      define_const "Bar" do
+        include ActiveValidation::ModelExtensionBase
+        active_validation
+      end
+    end
+
+    include_examples "verifiers registry"
+
+    context "orm methods" do
+      context "#add_manifest" do
+        before do
+          allow(subject.orm_adapter).to receive(:add_manifest)
+          define_const "Bar::Validations::V17"
+        end
+
+        it "calculate name and set default klass & version" do
+          subject.add_manifest
+          defaults = { base_klass: bar.to_s,
+                       version:    ActiveValidation::Values::Version.new(17),
+                       name:       "Manifest for Bar" }
+          expect(subject.orm_adapter).to have_received(:add_manifest).with(defaults)
+        end
+      end
+
+      context "#find_manifest" do
+        before { allow(subject.orm_adapter).to receive(:find_manifest) }
+
+        it "set defaults" do
+          subject.find_manifest
+          defaults = { base_klass: bar.to_s }
+          expect(subject.orm_adapter).to have_received(:find_manifest).with(defaults)
+        end
+      end
+
+      context "#find_manifests" do
+        before { allow(subject.orm_adapter).to receive(:find_manifests) }
+
+        it "set defaults" do
+          subject.find_manifests
+          defaults = { base_klass: bar.to_s }
+          expect(subject.orm_adapter).to have_received(:find_manifests).with(defaults)
+        end
+      end
+    end
+
+    context "#versions" do
+      before do
+        define_consts "Bar::Validations::V1",
+                      "Bar::Validations::V2",
+                      "Bar::Validations::V23",
+                      "Bar::Validations::V42"
+      end
+
+      it "returns correct versions in asc order" do
+        expect(subject.versions.map(&:to_i)).to eq [1, 2, 23, 42]
+      end
+
+      it "returns only value version type" do
+        expect(subject.versions).to all be_an ActiveValidation::Values::Version
+      end
+    end
+
+    context "#version" do
+      before do
+        define_consts "Bar::Validations::V300",
+                      "Bar::Validations::V301",
+                      "Bar::Validations::V302"
+      end
+
+      it "use latest version by default" do
+        expect(subject.version).to eq ActiveValidation::Values::Version.new(302)
+      end
+
+      it "set/gets version" do
+        subject.version = :V300
+        expect(subject.version).to eq ActiveValidation::Values::Version.new(300)
+      end
+    end
+
+    context "#base_class" do
+      it "return Class if base_klass as String given" do
+        expect(described_class.new(model.name).base_class).to eq model
+      end
+
+      it "return Class if base_klass as Class given" do
+        expect(described_class.new(model).base_class).to eq model
+      end
+    end
+
+    context "#descendants_with_active_validation" do
+      subject { described_class.find_or_build(foo_descendant3).descendants_with_active_validation }
+
+      let!(:should_not_be_in_the_list) { define_const "ShouldNotBeInTheList" }
+      let!(:baz) do
+        define_const("Baz", superclass: should_not_be_in_the_list) do
+          include ActiveValidation::ModelExtensionBase
+          active_validation
+        end
+      end
+
+      let(:foo) do
+        define_const("Foo", superclass: should_not_be_in_the_list) do
+          include ActiveValidation::ModelExtensionBase
+          active_validation
+          attr_reader :manifest
+        end
+      end
+
+      let(:foo_descendant1) { define_const("FooDescendant1", superclass: foo) { attr_reader :manifest } }
+      let(:foo_descendant2) { define_const("FooDescendant2", superclass: foo_descendant1) { attr_reader :manifest } }
+      let(:foo_descendant3) { define_const("FooDescendant3", superclass: foo_descendant2) }
+
+      it "returns only Foo based constants" do
+        expect(subject).to match [foo_descendant2, foo_descendant1, foo]
+      end
+
+      it "returns empty array for foo" do
+        expect(described_class.find_or_build(foo).descendants_with_active_validation).to be_empty
+      end
+    end
+
+    context "#current_manifest" do
+      let(:manifest) { ActiveValidation::Internal::Models::Manifest.new version: 1, base_klass: "Bar" }
+
+      it "return manifest, if it was set" do
+        subject.manifest = manifest
+        expect(subject.current_manifest).to eq manifest
+      end
+
+      it "call #find_manifests if manifest is not set" do
+        allow(subject).to receive(:find_manifests).and_return([]) # rubocop:disable RSpec/SubjectStub
+        define_consts "Bar::Validations::V11"
+        expect(subject.current_manifest).to be_nil
+        expect(subject).to have_received(:find_manifests)
+      end
+    end
+
+    context "#initialize" do
+      it "yield given block" do
+        expect { |b| described_class.find_or_build(bar.name, &b) }.to yield_control
+      end
+
+      it "register self in global registry" do
+        subject
+        expect(registry).to be_registered(bar.to_s)
+      end
+
+      it "invoke default config" do
+        allow(ActiveValidation.config.verifier_defaults).to receive(:call)
+        expect(ActiveValidation.config.verifier_defaults).to have_received(:call).with(subject)
+      end
+    end
+  end
+
+  context "#enabled" do
+    context "true" do
+      subject { described_class.find_or_build("Foo") { |c| c.enabled = true }.enabled? }
+
+      it { is_expected.to be true }
+    end
+
+    context "false" do
+      subject { described_class.find_or_build("Foo") { |c| c.enabled = false }.enabled? }
+
+      it { is_expected.to be false }
+    end
+  end
+
+  context "#install!" do
+    let!(:bar) { define_const("Bar", superclass: model) { attr_reader :manifest } }
+
+    before do
+      model.include ActiveValidation::ModelExtensionBase
+      allow(Foo.active_validation).to receive(:install)
+      allow(Bar.active_validation).to receive(:install)
+      described_class.find_or_build("Bar").install!
+    end
+
+    it("installs on Foo") { expect(Foo.active_validation).to have_received(:install) }
+    it("installs on Bar") { expect(Bar.active_validation).to have_received(:install) }
+  end
+end