activevalidation 0.1.0 → 1.0.0

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

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+describe ActiveValidation::Internal::Observers::Manifest do
+  subject { described_class.new verifier }
+
+  let(:manifest_id) { 42 }
+  let(:manifest) { instance_double ActiveValidation::Internal::Models::Manifest }
+  let(:verifier) { instance_double ActiveValidation::Verifier, enabled?: true }
+
+  %i[manifest failed_attempt_retry_time enabled?].each do |m|
+    it { is_expected.to delegate(m).to(:verifier) }
+  end
+
+  context "#current_manifest" do
+    let(:verifier) { instance_double ActiveValidation::Verifier, current_manifest: manifest }
+
+    context "no raise" do
+      before do
+        allow(manifest).to receive(:to_internal_manifest).and_return(manifest)
+      end
+
+      it("return current manifest") { expect(subject.current_manifest).to eq manifest }
+    end
+
+    context "raise" do
+      let(:error) { StandardError }
+      let(:time)  { Time.now }
+
+      before do
+        allow(manifest).to receive(:to_internal_manifest).and_raise(error)
+        allow(Time).to receive(:now).and_return(time)
+      end
+
+      it("error is not raised and nil returned") { expect { subject.current_manifest }.not_to raise_error }
+      it("last_failed_attempt_time set") do
+        subject.current_manifest
+        expect(subject.last_failed_attempt_time).to eq time
+      end
+
+      it("returns nil") { expect(subject.current_manifest).to be_nil }
+    end
+  end
+
+  context "#reset_last_failed_attempt_time" do
+    it("resets the variable") do
+      subject.instance_variable_set("@last_failed_attempt_time", "some_value")
+      expect(subject.reset_last_failed_attempt_time).to be_nil
+    end
+  end
+
+  # rubocop:disable RSpec/SubjectStub
+  context "#install" do
+    context "not enabled" do
+      let(:verifier) { instance_double ActiveValidation::Verifier, enabled?: false }
+
+      it("returns status") { expect(subject.install).to eq described_class::DISABLED_VERIFIER }
+    end
+
+    context "attempt_to_was_failed_recently?" do
+      before do
+        allow(subject).to receive(:attempt_to_was_failed_recently?).and_return(true)
+      end
+
+      it("returns status") { expect(subject.install).to eq described_class::RECENT_FAILURE }
+    end
+
+    context "with not found manifest" do
+      before do
+        allow(subject).to receive(:current_manifest)
+      end
+
+      it("returns status") { expect(subject.install).to eq described_class::NOT_FOUND }
+    end
+
+    context "with found manifest" do
+      context "already_installed" do
+        context "found" do
+          let(:manifest) do
+            instance_double ActiveValidation::Internal::Models::Manifest, installed?: true, id: manifest_id
+          end
+
+          before do
+            subject.installed_manifests << manifest
+          end
+
+          it("returns status") do
+            expect(subject.install(manifest_id: manifest_id)).to eq described_class::ALREADY_INSTALLED
+          end
+        end
+
+        context "current" do
+          let(:another_manifest) { instance_double ActiveValidation::Internal::Models::Manifest, installed?: true }
+
+          before do
+            allow(subject).to receive(:current_manifest).and_return(another_manifest)
+          end
+
+          it("returns status") { expect(subject.install).to eq described_class::ALREADY_INSTALLED }
+        end
+      end
+
+      context "required to be installed" do
+        before do
+          allow(subject).to receive(:install!)
+        end
+
+        context "found" do
+          let(:manifest) do
+            instance_double ActiveValidation::Internal::Models::Manifest, installed?: false, id: manifest_id
+          end
+
+          before do
+            subject.installed_manifests << manifest
+          end
+
+          it("returns status") do
+            subject.install(manifest_id: manifest_id)
+            expect(subject).to have_received :install!
+          end
+        end
+
+        context "current" do
+          let(:another_manifest) { instance_double ActiveValidation::Internal::Models::Manifest, installed?: false }
+
+          before do
+            allow(subject).to receive(:current_manifest).and_return(another_manifest)
+          end
+
+          it("returns status") do
+            subject.install
+            expect(subject).to have_received :install!
+          end
+        end
+      end
+    end
+  end
+
+  context "private #install!" do
+    context "already installed" do
+      let(:manifest) do
+        instance_double ActiveValidation::Internal::Models::Manifest, installed?: true, id: manifest_id
+      end
+
+      it("returns status") do
+        subject.installed_manifests << manifest
+        expect(subject.install!(internal_manifest: manifest)).to eq described_class::ALREADY_INSTALLED
+      end
+    end
+
+    context "new installation" do
+      let(:manifest) do
+        instance_double ActiveValidation::Internal::Models::Manifest, installed?: false, id: manifest_id, install: nil
+      end
+
+      it "installed manifest include the manifest" do
+        subject.install!(internal_manifest: manifest)
+        expect(subject.installed_manifests).to include manifest
+      end
+
+      it "run install method in the manifest" do
+        subject.install!(internal_manifest: manifest)
+        expect(manifest).to have_received(:install)
+      end
+
+      it("returns status") do
+        expect(subject.install!(internal_manifest: manifest)).to eq described_class::INSTALLED
+      end
+    end
+  end
+  # rubocop:enable RSpec/SubjectStub
+
+  context "uninstall" do
+    context "with not found manifest" do
+      it("returns status") { expect(subject.uninstall(manifest_id: manifest_id)).to eq described_class::NOT_FOUND }
+    end
+
+    context "found" do
+      let(:manifest) do
+        instance_double ActiveValidation::Internal::Models::Manifest, installed?: true, id: manifest_id, uninstall: nil
+      end
+
+      before do
+        subject.installed_manifests << manifest
+      end
+
+      it("returns status") do
+        expect(subject.uninstall(manifest_id: manifest_id)).to eq described_class::UNINSTALLED
+      end
+
+      it "run uninstall method in the manifest" do
+        subject.uninstall(manifest_id: manifest_id)
+        expect(manifest).to have_received(:uninstall)
+      end
+
+      it "installed manifest include the manifest" do
+        subject.uninstall(manifest_id: manifest_id)
+        expect(subject.installed_manifests).to be_empty
+      end
+    end
+  end
+end

data/spec/active_validation/model_extension_base_spec.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+describe ActiveValidation::ModelExtensionBase do
+  let(:klass) { Class.new { include ActiveValidation::ModelExtensionBase } }
+
+  context "::active_validation" do
+    it { expect(klass).to respond_to :active_validation }
+
+    it "pass forward the block" do
+      expect { |b| klass.active_validation(&b) }.to yield_control
+    end
+
+    it "proxies self as an argument" do
+      allow(::ActiveValidation::Verifier).to receive(:find_or_build).with(klass)
+      klass.active_validation
+      expect(::ActiveValidation::Verifier).to have_received(:find_or_build)
+    end
+
+    context "register_active_validation_relations" do
+      before do
+        allow(::ActiveValidation::Verifier).to receive(:find_or_build)
+        allow(klass).to receive(:register_active_validation_relations)
+      end
+
+      it "registers relations" do
+        allow(::ActiveValidation::Verifier.registry).to receive(:registered?).and_return(false)
+        klass.active_validation
+        expect(klass).to have_received(:register_active_validation_relations)
+      end
+
+      it "does not register relations" do
+        allow(::ActiveValidation::Verifier.registry).to receive(:registered?).and_return(true)
+        klass.active_validation
+        expect(klass).not_to have_received(:register_active_validation_relations)
+      end
+    end
+  end
+
+  context "#process_active_validation" do
+    let(:verifier) { instance_double ::ActiveValidation::Verifier }
+
+    before do
+      allow(::ActiveValidation::Verifier).to receive(:find_or_build).with(klass).and_return(verifier)
+      allow(verifier).to receive(:install!)
+    end
+
+    context "with manifest_id" do
+      before do
+        klass.send(:define_method, :manifest_id) { 42 }
+      end
+
+      it "installs the manifest" do
+        klass.new.send(:process_active_validation)
+        expect(::ActiveValidation::Verifier).to have_received(:find_or_build)
+        expect(verifier).to have_received(:install!).with(manifest_id: 42)
+      end
+    end
+
+    context "with out manifest_id" do
+      before do
+        klass.send(:define_method, :manifest_id) { nil }
+      end
+
+      it "installs the manifest" do
+        klass.new.send(:process_active_validation)
+        expect(::ActiveValidation::Verifier).to have_received(:find_or_build)
+        expect(verifier).to have_received(:install!).with(manifest_id: nil)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+describe ActiveValidation::OrmPlugins::ActiveRecordPlugin::Adapter do
+  context "global configuration" do
+    subject { ActiveValidation.config }
+
+    it "is in the registry" do
+      expect(subject.orm_adapters_registry).to be_registered(:active_record_plugin)
+    end
+  end
+
+  context "default" do
+    it "is not abstract" do
+      expect(described_class.abstract).to be_falsey
+    end
+
+    it "does not contain '(abstract)' suffix" do
+      expect(described_class.to_s).not_to match(/\(abstract\)\z/)
+    end
+
+    it "is initialised after setup" do
+      described_class.initialised = false
+      described_class.new
+      expect(described_class.initialised).to be_truthy
+    end
+
+    it "includes current ORM adapter by default" do
+      expect(described_class.adapter_name).to eq ENV["ORM"]
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+describe ActiveValidation::OrmPlugins::ActiveRecordPlugin::Adapter, type: :active_record do
+  let(:manifest) { ActiveValidation::Internal::Models::Manifest.new version: 1, base_klass: "Foo", name: "subject" }
+  let(:check_validates) do
+    ActiveValidation::Internal::Models::Check.new method_name: "validates",
+                                                  argument:    "name",
+                                                  options:     { presence: true }
+  end
+  let(:check_validate) do
+    ActiveValidation::Internal::Models::Check.new method_name: "validate", argument: "my_method"
+  end
+
+  let(:check_validates_with) do
+    define_const "MyValidator", superclass: ActiveModel::Validator
+    ActiveValidation::Internal::Models::Check.new method_name: "validates_with", argument: "MyValidator"
+  end
+
+  it "has right plugin name" do
+    expect(described_class.plugin_name).to eq "active_record_plugin"
+  end
+
+  it "has right adapter name" do
+    expect(described_class.adapter_name).to eq "active_record"
+  end
+
+  context "#add_manifest" do
+    it "Add manifest with out checks" do
+      expect(subject.add_manifest(manifest)).to eq manifest
+      expect(ActiveValidation::Manifest.count).to eq 1
+    end
+
+    it "Add manifest with checks" do
+      manifest.checks << check_validate
+      manifest.checks << check_validates
+      manifest.checks << check_validates_with
+      expect(subject.add_manifest(manifest)).to eq manifest
+      expect(ActiveValidation::Manifest.count).to eq 1
+      expect(ActiveValidation::Check.count).to eq 3
+    end
+  end
+
+  context "search" do
+    let!(:ar_manifest1) { create :manifest }
+    let!(:ar_manifest2) { create :manifest, name: "subject" }
+    let!(:ar_manifest3) { create :manifest }
+    let!(:ar_manifest4) { create :manifest, version: 2 }
+
+    context "#find_manifest" do
+      it "find correct manifest" do
+        expect(subject.find_manifest(name: "subject")).to eq ar_manifest2
+      end
+
+      it "find correct manifest with checks" do
+        create :check_validates, manifest: ar_manifest2
+        create :check_validate, manifest: ar_manifest2, argument: "my_method"
+        manifest.checks << check_validates
+        manifest.checks << check_validate
+        expect(subject.find_manifest(name: "subject")).to eq manifest
+      end
+
+      it "raise NotFound error id nothing found" do
+        expect { subject.find_manifest(name: "not_exist") }.to raise_error ActiveRecord::RecordNotFound
+      end
+    end
+
+    context "#find_manifests" do
+      let!(:ar_manifest5) { create :manifest, base_klass: "Bar" }
+      let(:json_options) { { include: { checks: { methods: %i[method_name] } }, root: false } }
+
+      it "find correct manifests" do
+        result = [ar_manifest1, ar_manifest2, ar_manifest3].map do |record|
+          ActiveValidation::Internal::Models::Manifest.new record.as_json(json_options).to_options!
+        end
+        expect(subject.find_manifests(version: 1, base_klass: "Foo")).to match_array result
+      end
+
+      it "return array with 1 element if only 1 record found" do
+        result = ActiveValidation::Internal::Models::Manifest.new ar_manifest5.as_json(json_options).to_options!
+        expect(subject.find_manifests(base_klass: "Bar")).to match_array result
+      end
+    end
+  end
+end

data/spec/active_validation/orm_plugins/active_record_plugin/models/active_validation/check/validate_method_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+describe ActiveValidation::Check::ValidateMethod, type: :active_record do
+  include_examples "check attributes check"
+
+  it("contains field type") { expect(subject.attributes).to have_key("type") }
+
+  context "validate the method invocation" do
+    before do
+      define_const("Foo", superclass: ActiveRecord::Base) do
+        def foo_allowed; end
+
+        def foo_not_allowed; end
+      end
+    end
+
+    it "invokes allowed method" do
+      expect(build(:check_validate, argument: "foo_allowed")).to be_valid
+    end
+
+    it "does not invoke globally restricted method" do
+      manifest = build :manifest, base_klass: "Foo"
+      expect(build(:check_validate, argument: "delete", manifest: manifest)).not_to be_valid
+    end
+  end
+end

data/spec/active_validation/orm_plugins/active_record_plugin/models/active_validation/check/validates_method_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+describe ActiveValidation::Check::ValidatesMethod, type: :active_record do
+  include_examples "check attributes check"
+
+  it("contains field type") { expect(subject.attributes).to have_key("type") }
+
+  context "validate the method invocation" do
+    before do
+      define_const("Foo", superclass: ActiveRecord::Base) do
+        def foo_allowed; end
+
+        def foo_not_allowed; end
+      end
+    end
+
+    it "invokes allowed method" do
+      expect(build(:check_validates, argument: "foo_allowed")).to be_valid
+    end
+
+    it "does not invoke globally restricted method" do
+      manifest = build :manifest, base_klass: "Foo"
+      expect(build(:check_validates, argument: "delete", manifest: manifest)).not_to be_valid
+    end
+  end
+end

data/spec/active_validation/orm_plugins/active_record_plugin/models/active_validation/check/validates_with_method_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+describe ActiveValidation::Check::ValidatesWithMethod, type: :active_record do
+  include_examples "check attributes check"
+
+  it("contains field type") { expect(subject.attributes).to have_key("type") }
+
+  context "simple validator" do
+    before do
+      define_const("FooValidator", superclass: ActiveModel::Validator) { def validate(*); true; end }
+    end
+
+    it "is valid record with correct validator" do
+      expect(build(:check_validates_with, argument: "FooValidator")).to be_valid
+    end
+
+    it "is not valid record with incorrect validator" do
+      record = build(:check_validates_with, argument: "NotExist", with_validator_klass: false)
+      expect(record).not_to be_valid
+      expect(record.errors[:argument].size).to eq 1
+    end
+
+    it "is not valid record without validator" do
+      record = build(:check_validates_with, argument: "", with_validator_klass: false)
+      expect(record).not_to be_valid
+      expect(record.errors[:argument].size).to eq 1
+    end
+
+    it "is valid with nested record with correct validator" do
+      define_const("NestedValidator", superclass: FooValidator)
+      expect(build(:check_validates_with, argument: "NestedValidator")).to be_valid
+    end
+  end
+end