karafka-core 2.5.10 → 2.5.12

data/test/lib/karafka/core/contractable/contract_test.rb

@@ -1,241 +0,0 @@
-# frozen_string_literal: true
-
-describe_current do
-  subject(:validator_class) do
-    Class.new(described_class) do
-      configure do |config|
-        config.error_messages = YAML.safe_load_file(
-          File.join(Karafka::Core.gem_root, "config", "locales", "errors.yml")
-        ).fetch("en").fetch("validations").fetch("config")
-      end
-
-      required(:id) { |id| id.is_a?(String) }
-
-      optional(:test) { |test| test == 5 }
-      optional(:name) { |name| name == "name" }
-    end
-  end
-
-  describe "#validate!" do
-    subject(:validation) { validator_class.new.validate!(data, ArgumentError) }
-
-    context "when data is valid" do
-      let(:data) { { id: "1" } }
-
-      it { validation }
-    end
-
-    context "when data is not valid" do
-      let(:data) { { id: 1 } }
-
-      it { assert_raises(ArgumentError) { validation } }
-    end
-
-    context "when optional data is not valid" do
-      let(:data) { { id: 1, test: Time.now } }
-
-      it { assert_raises(ArgumentError) { validation } }
-    end
-
-    context "when optional name is not valid" do
-      let(:data) { { id: 1, name: Time.now } }
-
-      it { assert_raises(ArgumentError) { validation } }
-    end
-
-    context "when optional name is valid" do
-      let(:data) { { id: "1", name: "name" } }
-
-      it { validation }
-    end
-
-    context "when optional data is valid" do
-      let(:data) { { id: 1, test: nil } }
-
-      it { assert_raises(ArgumentError) { validation } }
-    end
-
-    context "when validating with extra scope details" do
-      subject(:validation) do
-        validator_class.new.validate!(data, ArgumentError, scope: [rand.to_s, rand.to_s])
-      end
-
-      context "when data is valid" do
-        let(:data) { { id: "1" } }
-
-        it { validation }
-      end
-
-      context "when data is not valid" do
-        let(:data) { { id: 1 } }
-
-        it { assert_raises(ArgumentError) { validation } }
-      end
-
-      context "when optional data is not valid" do
-        let(:data) { { id: 1, test: Time.now } }
-
-        it { assert_raises(ArgumentError) { validation } }
-      end
-
-      context "when optional name is not valid" do
-        let(:data) { { id: 1, name: Time.now } }
-
-        it { assert_raises(ArgumentError) { validation } }
-      end
-
-      context "when optional name is valid" do
-        let(:data) { { id: "1", name: "name" } }
-
-        it { validation }
-      end
-
-      context "when optional data is valid" do
-        let(:data) { { id: 1, test: nil } }
-
-        it { assert_raises(ArgumentError) { validation } }
-      end
-    end
-
-    context "when error key is not available on error" do
-      subject(:validator_class) do
-        Class.new(described_class) do
-          configure do |config|
-            config.error_messages = YAML.safe_load_file(
-              File.join(Karafka::Core.gem_root, "config", "locales", "errors.yml")
-            ).fetch("en").fetch("validations").fetch("config")
-          end
-
-          required(:na_id) { |id| id.is_a?(String) }
-        end
-      end
-
-      let(:data) { { na_id: 1 } }
-
-      it { assert_raises(KeyError) { validation } }
-    end
-  end
-
-  describe "#call" do
-    context "when interested in the errors and not raising" do
-      subject(:validation) do
-        validator_class.new.call(data, scope: scope)
-      end
-
-      let(:scope) { [rand.to_s, rand.to_s] }
-
-      context "when data is valid" do
-        let(:data) { { id: "1" } }
-
-        it { assert_equal({}, validation.errors) }
-      end
-
-      context "when data is not valid" do
-        let(:data) { { id: 1 } }
-
-        it "expect to have the path key nested with the scope" do
-          assert_includes validation.errors.keys, :"#{scope.join(".")}.id"
-        end
-      end
-    end
-  end
-
-  context "when there are nested values in a contract" do
-    let(:validator_class) do
-      Class.new(described_class) do
-        configure do |config|
-          config.error_messages = YAML.safe_load_file(
-            File.join(Karafka::Core.gem_root, "config", "locales", "errors.yml")
-          ).fetch("en").fetch("validations").fetch("test")
-        end
-
-        nested(:nested) do
-          required(:id) { |id| id.is_a?(String) }
-          optional(:id2) { |id| id.is_a?(String) }
-        end
-      end
-    end
-
-    describe "#validate!" do
-      subject(:validation) { validator_class.new.validate!(data, ArgumentError) }
-
-      context "when data is valid without optional" do
-        let(:data) { { nested: { id: "1" } } }
-
-        it { validation }
-      end
-
-      context "when data is valid with optional" do
-        let(:data) { { nested: { id: "1", id2: "2" } } }
-
-        it { validation }
-      end
-
-      context "when data is not valid with invalid optional" do
-        let(:data) { { nested: { id: "1", id2: 2 } } }
-
-        it { assert_raises(ArgumentError) { validation } }
-      end
-
-      context "when data is not valid" do
-        let(:data) { { id: 1 } }
-
-        it { assert_raises(ArgumentError) { validation } }
-      end
-    end
-  end
-
-  context "when contract has its own error reported" do
-    let(:validator_class) do
-      Class.new(described_class) do
-        virtual do
-          [[%i[id], "String error"]]
-        end
-      end
-    end
-
-    subject(:validation) { validator_class.new.validate!(data, ArgumentError) }
-
-    context "when data is valid without optional" do
-      let(:data) { { nested: { id: "1" } } }
-
-      it { assert_raises(ArgumentError) { validation } }
-    end
-  end
-
-  context "when contract has multiple nestings" do
-    subject(:validator_class) do
-      Class.new(described_class) do
-        configure do |config|
-          config.error_messages = YAML.safe_load_file(
-            File.join(Karafka::Core.gem_root, "config", "locales", "errors.yml")
-          ).fetch("en").fetch("validations").fetch("config")
-        end
-
-        nested(:a) do
-          nested(:b) do
-            nested(:c) do
-              required(:id) { |id| id.is_a?(String) }
-            end
-          end
-        end
-      end
-    end
-
-    describe "#validate!" do
-      subject(:validation) { validator_class.new.validate!(data, ArgumentError) }
-
-      context "when data is valid" do
-        let(:data) { { a: { b: { c: { id: "1" } } } } }
-
-        it { validation }
-      end
-
-      context "when data is not valid" do
-        let(:data) { { id: 1 } }
-
-        it { assert_raises(ArgumentError) { validation } }
-      end
-    end
-  end
-end

data/test/lib/karafka/core/contractable/result_test.rb

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-
-describe_current do
-  subject(:contract_class) do
-    Class.new(Karafka::Core::Contractable::Contract) do
-      configure do |config|
-        config.error_messages = YAML.safe_load_file(
-          File.join(Karafka::Core.gem_root, "config", "locales", "errors.yml")
-        ).fetch("en").fetch("validations").fetch("test")
-      end
-
-      required(:id) { |id| id.is_a?(String) }
-
-      optional(:test) { |test| test == 5 }
-    end
-  end
-
-  let(:contract) { contract_class.new }
-
-  context "when there are no errors" do
-    let(:data) { { id: "123", test: 5 } }
-    let(:result) { contract.call(data) }
-
-    it "returns success" do
-      assert_predicate result, :success?
-    end
-
-    it "has no errors" do
-      assert_empty result.errors
-    end
-  end
-
-  context "when there are errors and all keys can be mapped to messages" do
-    let(:data) { { id: 123, test: 4 } }
-    let(:result) { contract.call(data) }
-
-    it "does not return success" do
-      refute_predicate result, :success?
-    end
-
-    it "maps errors to messages" do
-      assert_equal(
-        { id: "needs to be a String", test: "needs to be 5" },
-        result.errors
-      )
-    end
-  end
-
-  context "when there are errors with nested keys" do
-    subject(:contract_class) do
-      Class.new(Karafka::Core::Contractable::Contract) do
-        configure do |config|
-          config.error_messages = YAML.safe_load_file(
-            File.join(Karafka::Core.gem_root, "config", "locales", "errors.yml")
-          ).fetch("en").fetch("validations").fetch("test")
-        end
-
-        nested(:details) do
-          required(:id) { |id| id.is_a?(String) }
-        end
-      end
-    end
-
-    let(:data) { { details: { id: 123 } } }
-    let(:result) { contract.call(data) }
-
-    it "does not return success" do
-      refute_predicate result, :success?
-    end
-
-    it "maps nested errors to messages with dot notation" do
-      assert_equal(
-        { "details.id": "needs to be a String" },
-        result.errors
-      )
-    end
-  end
-
-  context "when there are errors and key cannot be mapped to a message" do
-    subject(:contract_class) do
-      Class.new(Karafka::Core::Contractable::Contract) do
-        configure do |config|
-          config.error_messages = YAML.safe_load_file(
-            File.join(Karafka::Core.gem_root, "config", "locales", "errors.yml")
-          ).fetch("en").fetch("validations").fetch("test")
-        end
-
-        required(:id) { |id| id.is_a?(String) }
-      end
-    end
-
-    let(:data) { { id: 123 } }
-    let(:result) { contract.call(data) }
-
-    it "does not return success" do
-      refute_predicate result, :success?
-    end
-
-    it "falls back to a generic error message" do
-      assert_equal(
-        { id: "needs to be a String" },
-        result.errors
-      )
-    end
-  end
-end

data/test/lib/karafka/core/contractable/rule_test.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-describe_current do
-  it { assert_operator described_class, :<, Struct }
-end

data/test/lib/karafka/core/contractable_test.rb

@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-# Each component is tested in its own spec file.

data/test/lib/karafka/core/helpers/time_test.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-describe_current do
-  let(:timed) do
-    current = described_class
-
-    Class.new do
-      extend current
-    end
-  end
-
-  describe "#monotonic_now" do
-    it "expect to return monotonic in ms" do
-      pre = timed.monotonic_now
-      sleep(0.5)
-
-      assert_in_delta 500, timed.monotonic_now - pre, 500
-    end
-  end
-
-  describe "#float_now" do
-    it "expect to return float time in ms" do
-      pre = timed.float_now
-      sleep(0.5)
-
-      assert_in_delta 500, timed.float_now - pre, 500
-    end
-  end
-end

data/test/lib/karafka/core/instrumentation/callbacks_manager_test.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-describe_current do
-  subject(:manager) { described_class.new }
-
-  let(:id) { SecureRandom.uuid }
-  let(:changed) { [] }
-
-  describe "#call" do
-    context "when there are no callbacks added" do
-      it { manager.call }
-    end
-
-    context "when there are callbacks added" do
-      let(:changed) { [] }
-      let(:start) { [rand, rand, rand] }
-
-      before do
-        manager.add("1", ->(val1, _, _) { changed << (val1 + 1) })
-        manager.add("2", ->(_, val2, _) { changed << (val2 + 2) })
-        manager.add("3", ->(_, _, val3) { changed << (val3 + 3) })
-      end
-
-      it "expect to run each of them and pass the args" do
-        manager.call(*start)
-
-        assert_equal [start[0] + 1, start[1] + 2, start[2] + 3], changed
-      end
-    end
-  end
-
-  describe "#add" do
-    it "expect after adding to be used" do
-      manager.add(id, -> { changed << true })
-      manager.call
-
-      assert_equal [true], changed
-    end
-
-    context "when we are adding a callback but at the same time, we call callbacks" do
-      let(:added_id) { SecureRandom.uuid }
-      let(:callable) do
-        lambda do
-          changed << true
-          sleep(10)
-        end
-      end
-
-      before do
-        # This will simulate a long running callback when manager is called, so when we add new one
-        # The previous one is still running in a thread
-        manager.add(id, callable)
-        Thread.new { manager.call }
-        # This makes sure, that we wait until the thread kicks in
-        sleep(0.001) while changed.empty?
-      end
-
-      it { manager.add(added_id, callable) }
-
-      it "expect to register the new callback" do
-        manager.delete(id)
-        manager.add(added_id, -> { changed << true })
-
-        manager.call
-
-        assert_equal [true, true], changed
-      end
-    end
-  end
-
-  describe "#delete" do
-    before { manager.add(id, -> { changed << true }) }
-
-    it "expect after removal not to be used" do
-      manager.delete(id)
-      manager.call
-
-      assert_empty changed
-    end
-  end
-end

data/test/lib/karafka/core/instrumentation_test.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-describe_current do
-  subject(:instrumentation) { described_class }
-
-  describe "#statistics_callbacks" do
-    it { assert_kind_of described_class::CallbacksManager, instrumentation.statistics_callbacks }
-  end
-
-  describe "#error_callbacks" do
-    it { assert_kind_of described_class::CallbacksManager, instrumentation.error_callbacks }
-  end
-
-  describe "#oauthbearer_token_refresh_callbacks" do
-    it do
-      assert_kind_of described_class::CallbacksManager,
-        instrumentation.oauthbearer_token_refresh_callbacks
-    end
-  end
-
-  it "expect statistics_callbacks to differ from error_callbacks" do
-    refute_equal instrumentation.error_callbacks,
-      instrumentation.statistics_callbacks
-  end
-
-  it "expect error_callbacks to differ from oauthbearer_token_refresh_callbacks" do
-    refute_equal instrumentation.oauthbearer_token_refresh_callbacks,
-      instrumentation.error_callbacks
-  end
-
-  it "expect statistics_callbacks to differ from oauthbearer_token_refresh_callbacks" do
-    refute_equal instrumentation.oauthbearer_token_refresh_callbacks,
-      instrumentation.statistics_callbacks
-  end
-end

data/test/lib/karafka/core/monitoring/event_test.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-describe_current do
-  subject(:event) { described_class.new(id, payload) }
-
-  let(:id) { rand.to_s }
-  let(:payload) { { rand => rand } }
-
-  it { assert_equal id, event.id }
-  it { assert_equal payload, event.payload }
-
-  describe "#[]" do
-    context "when key is present" do
-      let(:payload) { { test: 1 } }
-
-      it "expect to return it" do
-        assert_equal 1, event[:test]
-      end
-    end
-
-    context "when key is missing" do
-      it { assert_raises(KeyError) { event[:test] } }
-    end
-  end
-end