karafka-core 2.5.10 → 2.5.12

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

@@ -1,284 +0,0 @@
-# frozen_string_literal: true
-
-describe_current do
-  subject(:decorator) { described_class.new }
-
-  let(:emited_stats1) do
-    {
-      "string" => "value1",
-      "float" => 10.4,
-      "int" => 112,
-      "nested" => {
-        "brokers" => {
-          "localhost:9092/2" => {
-            "txbytes" => 123
-          }
-        }
-      }
-    }
-  end
-
-  let(:emited_stats2) do
-    {
-      "string" => "value2",
-      "float" => 10.8,
-      "int" => 130,
-      "nested" => {
-        "brokers" => {
-          "localhost:9092/2" => {
-            "txbytes" => 153
-          }
-        }
-      }
-    }
-  end
-
-  let(:emited_stats3) do
-    {
-      "string" => "value3",
-      "float" => 11.8,
-      "int" => 10,
-      "nested" => {
-        "brokers" => {
-          "localhost:9092/2" => {
-            "txbytes" => 2
-          }
-        }
-      }
-    }
-  end
-
-  let(:broker_scope) { %w[nested brokers localhost:9092/2] }
-
-  context "when it is a first stats emit" do
-    subject(:decorated) { decorator.call(emited_stats1) }
-
-    it { assert_equal "value1", decorated["string"] }
-    it { refute decorated.key?("string_d") }
-    it { assert_equal 0, decorated["float_d"] }
-    it { assert_equal 0, decorated["int_d"] }
-    it { assert_equal 0, decorated.dig(*broker_scope)["txbytes_d"] }
-    it { assert_predicate decorated, :frozen? }
-  end
-
-  context "when it is a second stats emit" do
-    subject(:decorated) do
-      decorator.call(emited_stats1)
-      decorator.call(emited_stats2)
-    end
-
-    it { assert_equal "value2", decorated["string"] }
-    it { refute decorated.key?("string_d") }
-    it { assert_in_delta(0.4, decorated["float_d"].round(10)) }
-    it { assert_equal 18, decorated["int_d"] }
-    it { assert_equal 30, decorated.dig(*broker_scope)["txbytes_d"] }
-    it { assert_predicate decorated, :frozen? }
-  end
-
-  context "when it is a third stats emit" do
-    subject(:decorated) do
-      decorator.call(emited_stats1)
-      decorator.call(emited_stats2)
-      decorator.call(emited_stats3)
-    end
-
-    it { assert_equal "value3", decorated["string"] }
-    it { refute decorated.key?("string_d") }
-    it { refute decorated.key?("string_fd") }
-    it { assert_in_delta(1.0, decorated["float_d"].round(10)) }
-    it { assert_in_delta 0, decorated["float_fd"], 5 }
-    it { assert_equal(-120, decorated["int_d"]) }
-    it { assert_in_delta 0, decorated["int_fd"], 5 }
-    it { assert_equal(-151, decorated.dig(*broker_scope)["txbytes_d"]) }
-    it { assert_in_delta 0, decorated.dig(*broker_scope)["txbytes_fd"], 5 }
-    it { assert_predicate decorated, :frozen? }
-    it { refute decorated.key?("float_d_d") }
-  end
-
-  context "when a broker is no longer present" do
-    subject(:decorated) do
-      decorator.call(emited_stats1)
-      decorator.call(emited_stats2)
-    end
-
-    before { emited_stats2["nested"] = {} }
-
-    it { assert_equal "value2", decorated["string"] }
-    it { refute decorated.key?("string_d") }
-    it { refute decorated.key?("string_fd") }
-    it { assert_in_delta(0.4, decorated["float_d"].round(10)) }
-    it { assert_in_delta 0, decorated["float_fd"], 5 }
-    it { assert_equal 18, decorated["int_d"] }
-    it { assert_in_delta 0, decorated["int_fd"], 5 }
-    it { assert_equal({}, decorated["nested"]) }
-    it { assert_predicate decorated, :frozen? }
-    it { refute decorated.key?("float_d_d") }
-  end
-
-  context "when broker was introduced later on" do
-    subject(:decorated) do
-      decorator.call(emited_stats1)
-      decorator.call(emited_stats2)
-    end
-
-    before { emited_stats1["nested"] = {} }
-
-    it { assert_equal "value2", decorated["string"] }
-    it { refute decorated.key?("string_d") }
-    it { assert_in_delta(0.4, decorated["float_d"].round(10)) }
-    it { assert_in_delta 0, decorated["float_fd"], 5 }
-    it { assert_equal 18, decorated["int_d"] }
-    it { assert_in_delta 0, decorated["int_fd"], 5 }
-    it { assert_equal 0, decorated.dig(*broker_scope)["txbytes_d"] }
-    it { assert_in_delta 0, decorated.dig(*broker_scope)["txbytes_fd"], 5 }
-    it { assert_predicate decorated, :frozen? }
-    it { refute decorated.key?("float_d_d") }
-  end
-
-  context "when value remains unchanged over time" do
-    subject(:decorated) do
-      # First one will set initial state
-      decorator.call(deep_copy.call)
-      # Second one will build first deltas with freeze duration of zero
-      decorator.call(deep_copy.call)
-      sleep(0.01)
-      # Third one will allow for proper freeze duration computation
-      decorator.call(deep_copy.call)
-    end
-
-    let(:deep_copy) { -> { Marshal.load(Marshal.dump(emited_stats1)) } }
-
-    it { refute decorated.key?("string_d") }
-    it { refute decorated.key?("string_fd") }
-    it { assert_equal 0, decorated["float_d"] }
-    it { assert_in_delta 10, decorated["float_fd"], 5 }
-    it { assert_equal 0, decorated["int_d"] }
-    it { assert_in_delta 10, decorated["int_fd"], 5 }
-    it { assert_predicate decorated, :frozen? }
-    it { refute decorated.key?("float_d_d") }
-  end
-
-  context "when value remains unchanged over multiple occurrences and time" do
-    subject(:decorated) do
-      # First one will set initial state
-      decorator.call(deep_copy.call)
-      # Second one will build first deltas with freeze duration of zero
-      decorator.call(deep_copy.call)
-      sleep(0.01)
-      # Third one will allow for proper freeze duration computation
-      decorator.call(deep_copy.call)
-      sleep(0.01)
-      decorator.call(deep_copy.call)
-    end
-
-    let(:deep_copy) { -> { Marshal.load(Marshal.dump(emited_stats1)) } }
-
-    it { refute decorated.key?("string_d") }
-    it { refute decorated.key?("string_fd") }
-    it { assert_equal 0, decorated["float_d"] }
-    it { assert_in_delta 20, decorated["float_fd"], 5 }
-    it { assert_equal 0, decorated["int_d"] }
-    # On slow CIs this value tends to grow and crash
-    it { assert_in_delta 20, decorated["int_fd"], 15 }
-    it { assert_predicate decorated, :frozen? }
-    it { refute decorated.key?("float_d_d") }
-  end
-
-  context "when a value type changed from non-numeric to numeric between emissions" do
-    subject(:decorated) do
-      decorator.call(emited_stats1)
-      decorator.call(emited_stats2)
-    end
-
-    before do
-      # In the first emission, txbytes is a string (unusual but defensive)
-      emited_stats1["nested"]["brokers"]["localhost:9092/2"]["txbytes"] = "not_a_number"
-    end
-
-    # When previous value was non-numeric but current is numeric, no delta should be computed
-    it { refute decorated.dig(*broker_scope).key?("txbytes_d") }
-    it { refute decorated.dig(*broker_scope).key?("txbytes_fd") }
-    it { assert_equal 153, decorated.dig(*broker_scope)["txbytes"] }
-    it { assert_predicate decorated, :frozen? }
-  end
-
-  context "when excluded_keys are configured" do
-    subject(:decorator) { described_class.new(excluded_keys: %w[nested]) }
-
-    context "when it is a first stats emit" do
-      subject(:decorated) { decorator.call(emited_stats1) }
-
-      it { assert_equal 0, decorated["float_d"] }
-      it { assert_equal 0, decorated["int_d"] }
-      it { assert_predicate decorated, :frozen? }
-
-      it "does not decorate excluded subtrees" do
-        expected = { "brokers" => { "localhost:9092/2" => { "txbytes" => 123 } } }
-
-        assert_equal(expected, decorated["nested"])
-        refute decorated["nested"]["brokers"]["localhost:9092/2"].key?("txbytes_d")
-      end
-    end
-
-    context "when it is a second stats emit" do
-      subject(:decorated) do
-        decorator.call(emited_stats1)
-        decorator.call(emited_stats2)
-      end
-
-      it { assert_in_delta(0.4, decorated["float_d"].round(10)) }
-      it { assert_equal 18, decorated["int_d"] }
-      it { assert_predicate decorated, :frozen? }
-
-      it "does not decorate excluded subtrees" do
-        refute decorated["nested"]["brokers"]["localhost:9092/2"].key?("txbytes_d")
-        refute decorated["nested"]["brokers"]["localhost:9092/2"].key?("txbytes_fd")
-      end
-    end
-  end
-
-  context "when excluded_keys target a numeric key" do
-    let(:decorator) { described_class.new(excluded_keys: %w[int]) }
-
-    subject(:decorated) do
-      decorator.call(emited_stats1)
-      decorator.call(emited_stats2)
-    end
-
-    it { assert_in_delta(0.4, decorated["float_d"].round(10)) }
-    it { assert_equal 130, decorated["int"] }
-    it { refute decorated.key?("int_d") }
-    it { refute decorated.key?("int_fd") }
-    it { assert_predicate decorated, :frozen? }
-  end
-
-  context "when no excluded_keys are configured" do
-    let(:decorator) { described_class.new }
-
-    subject(:decorated) do
-      decorator.call(emited_stats1)
-      decorator.call(emited_stats2)
-    end
-
-    it { assert_equal 18, decorated["int_d"] }
-    it { assert_equal 30, decorated.dig(*broker_scope)["txbytes_d"] }
-  end
-
-  context "when a value type changed from numeric to non-numeric between emissions" do
-    subject(:decorated) do
-      decorator.call(emited_stats1)
-      decorator.call(emited_stats2)
-    end
-
-    before do
-      # In the second emission, txbytes changed to a string
-      emited_stats2["nested"]["brokers"]["localhost:9092/2"]["txbytes"] = "not_a_number"
-    end
-
-    # Non-numeric values are never decorated
-    it { refute decorated.dig(*broker_scope).key?("txbytes_d") }
-    it { refute decorated.dig(*broker_scope).key?("txbytes_fd") }
-    it { assert_equal "not_a_number", decorated.dig(*broker_scope)["txbytes"] }
-    it { assert_predicate decorated, :frozen? }
-  end
-end

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

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

data/test/lib/karafka/core/patches/rdkafka/bindings_test.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-describe_current do
-  subject(:producer) do
-    config = { "bootstrap.servers": "localhost:10092" }
-    Rdkafka::Config.new(config).producer
-  end
-
-  describe "#build_error_callback" do
-    let(:errors) { [] }
-    let(:callback) { ->(*args) { errors << args } }
-
-    before { Rdkafka::Config.error_callback.add("test", callback) }
-
-    after { Rdkafka::Config.error_callback.delete("test") }
-
-    it "expect to inject instance name to the error callback" do
-      producer.produce(topic: "test", payload: "1")
-      sleep(0.01) while errors.empty?
-
-      assert_includes errors.first.first, "rdkafka#producer"
-      assert_equal :transport, errors.first.last.code
-    end
-  end
-end

data/test/lib/karafka/core/taggable/tags_test.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-describe_current do
-  subject(:tags) { described_class.new }
-
-  it { assert_empty tags.to_a }
-
-  describe "#add" do
-    context "when few under same name" do
-      before { 3.times { |value| tags.add(:name, value) } }
-
-      it { assert_equal %w[2], tags.to_a }
-    end
-
-    context "when with different names" do
-      before do
-        tags.add(:name1, 1)
-        tags.add(:name2, 2)
-        tags.add(:name3, 3)
-      end
-
-      it { assert_equal %w[1 2 3], tags.to_a }
-    end
-
-    context "when with different names but same value" do
-      before do
-        tags.add(:name1, 1)
-        tags.add(:name2, 1)
-        tags.add(:name3, 1)
-      end
-
-      it { assert_equal %w[1], tags.to_a }
-    end
-  end
-
-  describe "#clear" do
-    before do
-      tags.add(:name, 1)
-      tags.clear
-    end
-
-    it { assert_empty tags.to_a }
-  end
-
-  describe "#delete" do
-    before do
-      tags.add(:name1, 1)
-      tags.delete(:name1)
-      tags.add(:name3, 2)
-    end
-
-    it { assert_equal %w[2], tags.to_a }
-  end
-
-  describe "#to_json" do
-    before { tags.add(:test, "abc") }
-
-    it { assert_equal %w[abc].to_json, tags.to_json }
-  end
-
-  describe "#as_json" do
-    before { tags.add(:test, "abc") }
-
-    it { assert_equal %w[abc], tags.as_json }
-  end
-end

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

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-describe_current do
-  context "when operating on an instance basis" do
-    subject(:tagged) { tagged_class.new }
-
-    let(:other_tagged) { tagged_class.new }
-    let(:tagged_class) do
-      Class.new do
-        include Karafka::Core::Taggable
-      end
-    end
-
-    it { assert_empty tagged.tags.to_a }
-    it { refute_equal other_tagged.tags, tagged.tags }
-  end
-
-  context "when operating on a class basis" do
-    subject(:tagged) { tagged_class }
-
-    let(:other_tagged) { other_tagged_class }
-    let(:tagged_class) do
-      Class.new do
-        extend Karafka::Core::Taggable
-      end
-    end
-    let(:other_tagged_class) do
-      Class.new do
-        extend Karafka::Core::Taggable
-      end
-    end
-
-    it { assert_empty tagged.tags.to_a }
-    it { refute_equal other_tagged.tags, tagged.tags }
-  end
-end

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

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-describe Karafka::Core::VERSION do
-  it { described_class }
-end

data/test/lib/karafka/core_test.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-describe_current do
-  subject(:core) { described_class }
-
-  describe "#gem_root" do
-    context "when we want to get gem root path" do
-      let(:path) { Dir.pwd }
-
-      it { assert_equal path, core.gem_root.to_path }
-    end
-  end
-end

data/test/lib/karafka-core_test.rb

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

data/test/support/class_builder.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-# Class builder helps creating anonymous classes that we can use to spec our code
-# We need co create new class instances to have an "empty" and "clear" class for each spec
-# This module acts as an interface to create classes
-module ClassBuilder
-  class << self
-    # Creates an empty class without any predefined methods
-    # @return [Class] created anonymous class
-    def build(&)
-      klass = Class.new
-
-      klass.class_eval(&) if block_given?
-      klass
-    end
-
-    # This method allows us to create a class that inherits from any other
-    # @param klass [Class] any class from which we want to inherit in our anonymous class
-    # @return [Class] new anonymous class
-    def inherit(klass, &)
-      Class.new(klass, &)
-    end
-  end
-end

data/test/support/describe_current_helper.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-# Port of Karafka::Core::Helpers::RSpecLocator for minitest/spec
-# Provides `describe_current` that auto-discovers the class under test from file path,
-# `described_class` and `subject` DSL methods.
-
-require "karafka/core/helpers/minitest_locator"
-
-extend Karafka::Core::Helpers::MinitestLocator.new(
-  File.expand_path("../test_helper.rb", __dir__)
-)
-
-# Provide `described_class` for minitest/spec — walks the desc hierarchy to find a Class/Module
-module MinitestDescribedClass
-  def described_class
-    # Walk up the describe hierarchy to find the Class/Module
-    klass = self.class
-    while klass
-      return klass.desc if klass.respond_to?(:desc) && klass.desc.is_a?(Module)
-
-      klass = klass.superclass
-    end
-    nil
-  end
-end
-
-Minitest::Spec.include MinitestDescribedClass
-
-# Provide `subject` DSL for minitest/spec
-module MinitestSubjectDSL
-  def subject(name = nil, &block)
-    if name
-      let(name, &block)
-      define_method(:subject) { send(name) }
-    else
-      let(:subject, &block)
-    end
-  end
-end
-
-Minitest::Spec.extend MinitestSubjectDSL

data/test/test_helper.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-Warning[:performance] = true if RUBY_VERSION >= "3.3"
-Warning[:deprecated] = true
-$VERBOSE = true
-
-require "warning"
-
-Warning.process do |warning|
-  next unless warning.include?(Dir.pwd)
-
-  raise "Warning in your code: #{warning}"
-end
-
-ENV["KARAFKA_ENV"] = "test"
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
-
-%w[
-  byebug
-  simplecov
-  tempfile
-  securerandom
-].each do |lib|
-  require lib
-end
-
-# Don't include unnecessary stuff into rcov
-SimpleCov.start do
-  add_filter "/vendor/"
-  add_filter "/gems/"
-  add_filter "/.bundle/"
-  add_filter "/doc/"
-  add_filter "/test/"
-  add_filter "/config/"
-  add_filter "/patches/"
-  merge_timeout 600
-end
-
-SimpleCov.minimum_coverage(98.8)
-
-require "minitest/autorun"
-require "minitest/spec"
-
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"]
-  .each { |f| require f }
-
-require "karafka-core"
-
-# Allow `context` as an alias for `describe` in minitest/spec
-Minitest::Spec.class_eval do
-  class << self
-    alias_method :context, :describe
-  end
-end