karafka-core 2.5.11 → 2.5.13

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

@@ -1,503 +0,0 @@
-# frozen_string_literal: true
-
-describe_current do
-  subject(:decorator) { described_class.new }
-
-  let(:emitted_stats1) do
-    {
-      "string" => "value1",
-      "float" => 10.4,
-      "int" => 112,
-      "nested" => {
-        "brokers" => {
-          "localhost:9092/2" => {
-            "txbytes" => 123
-          }
-        }
-      }
-    }
-  end
-
-  let(:emitted_stats2) do
-    {
-      "string" => "value2",
-      "float" => 10.8,
-      "int" => 130,
-      "nested" => {
-        "brokers" => {
-          "localhost:9092/2" => {
-            "txbytes" => 153
-          }
-        }
-      }
-    }
-  end
-
-  let(:emitted_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(emitted_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(emitted_stats1)
-      decorator.call(emitted_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(emitted_stats1)
-      decorator.call(emitted_stats2)
-      decorator.call(emitted_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(emitted_stats1)
-      decorator.call(emitted_stats2)
-    end
-
-    before { emitted_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(emitted_stats1)
-      decorator.call(emitted_stats2)
-    end
-
-    before { emitted_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(emitted_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(emitted_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(emitted_stats1)
-      decorator.call(emitted_stats2)
-    end
-
-    before do
-      # In the first emission, txbytes is a string (unusual but defensive)
-      emitted_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(emitted_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(emitted_stats1)
-        decorator.call(emitted_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(emitted_stats1)
-      decorator.call(emitted_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(emitted_stats1)
-      decorator.call(emitted_stats2)
-    end
-
-    it { assert_equal 18, decorated["int_d"] }
-    it { assert_equal 30, decorated.dig(*broker_scope)["txbytes_d"] }
-  end
-
-  context "when only_keys are configured" do
-    let(:decorator) { described_class.new(only_keys: %w[int]) }
-
-    context "when it is a first stats emit" do
-      subject(:decorated) { decorator.call(emitted_stats1) }
-
-      it { assert_equal 0, decorated["int_d"] }
-      it { assert_predicate decorated, :frozen? }
-
-      it "does not decorate non-listed numeric keys" do
-        refute decorated.key?("float_d")
-        refute decorated.key?("float_fd")
-      end
-
-      it "preserves non-listed numeric values" do
-        assert_in_delta 10.4, decorated["float"]
-      end
-
-      it "preserves string values" do
-        assert_equal "value1", decorated["string"]
-      end
-    end
-
-    context "when it is a second stats emit" do
-      subject(:decorated) do
-        decorator.call(emitted_stats1)
-        decorator.call(emitted_stats2)
-      end
-
-      it { assert_equal 18, decorated["int_d"] }
-      it { assert_predicate decorated, :frozen? }
-
-      it "does not decorate non-listed numeric keys" do
-        refute decorated.key?("float_d")
-        refute decorated.key?("float_fd")
-      end
-    end
-
-    context "when only_keys targets a nested value" do
-      let(:decorator) { described_class.new(only_keys: %w[txbytes]) }
-
-      subject(:decorated) do
-        decorator.call(emitted_stats1)
-        decorator.call(emitted_stats2)
-      end
-
-      it "decorates matching keys in nested hashes" do
-        assert_equal 30, decorated.dig(*broker_scope)["txbytes_d"]
-      end
-
-      it "does not decorate non-listed root keys" do
-        refute decorated.key?("int_d")
-        refute decorated.key?("float_d")
-      end
-    end
-  end
-
-  context "when only_keys and excluded_keys are combined" do
-    let(:decorator) { described_class.new(excluded_keys: %w[nested], only_keys: %w[int]) }
-
-    subject(:decorated) do
-      decorator.call(emitted_stats1)
-      decorator.call(emitted_stats2)
-    end
-
-    it { assert_equal 18, decorated["int_d"] }
-    it { assert_predicate decorated, :frozen? }
-
-    it "does not decorate non-listed keys" do
-      refute decorated.key?("float_d")
-    end
-
-    it "does not recurse into excluded subtrees" do
-      refute decorated.dig(*broker_scope).key?("txbytes_d")
-    end
-  end
-
-  context "when only_keys value remains unchanged over time" do
-    subject(:decorated) do
-      decorator.call(deep_copy.call)
-      decorator.call(deep_copy.call)
-      sleep(0.01)
-      decorator.call(deep_copy.call)
-    end
-
-    let(:decorator) { described_class.new(only_keys: %w[int]) }
-    let(:deep_copy) { -> { Marshal.load(Marshal.dump(emitted_stats1)) } }
-
-    it { assert_equal 0, decorated["int_d"] }
-    it { assert_in_delta 10, decorated["int_fd"], 5 }
-
-    it "does not decorate non-listed keys" do
-      refute decorated.key?("float_d")
-      refute decorated.key?("float_fd")
-    end
-  end
-
-  context "when only_keys is used with librdkafka-like structure" do
-    let(:decorator) { described_class.new(only_keys: %w[rxmsgs txbytes consumer_lag]) }
-
-    let(:rdkafka_stats1) do
-      {
-        "rxmsgs" => 100,
-        "name" => "consumer-1",
-        "brokers" => {
-          "localhost:9092/0" => {
-            "txbytes" => 500,
-            "rxbytes" => 300,
-            "nodeid" => 0
-          }
-        },
-        "topics" => {
-          "events" => {
-            "age" => 1000,
-            "partitions" => {
-              "0" => {
-                "consumer_lag" => 50,
-                "hi_offset" => 1000,
-                "txmsgs" => 200
-              },
-              "1" => {
-                "consumer_lag" => 30,
-                "hi_offset" => 800,
-                "txmsgs" => 150
-              }
-            }
-          }
-        },
-        "cgrp" => {
-          "stateage" => 5000,
-          "rebalance_cnt" => 2
-        }
-      }
-    end
-
-    let(:rdkafka_stats2) do
-      {
-        "rxmsgs" => 150,
-        "name" => "consumer-1",
-        "brokers" => {
-          "localhost:9092/0" => {
-            "txbytes" => 700,
-            "rxbytes" => 500,
-            "nodeid" => 0
-          }
-        },
-        "topics" => {
-          "events" => {
-            "age" => 2000,
-            "partitions" => {
-              "0" => {
-                "consumer_lag" => 40,
-                "hi_offset" => 1100,
-                "txmsgs" => 250
-              },
-              "1" => {
-                "consumer_lag" => 25,
-                "hi_offset" => 900,
-                "txmsgs" => 200
-              }
-            }
-          }
-        },
-        "cgrp" => {
-          "stateage" => 6000,
-          "rebalance_cnt" => 2
-        }
-      }
-    end
-
-    subject(:decorated) do
-      decorator.call(rdkafka_stats1)
-      decorator.call(rdkafka_stats2)
-    end
-
-    it "decorates root only_keys" do
-      assert_equal 50, decorated["rxmsgs_d"]
-    end
-
-    it "does not decorate non-listed root keys" do
-      refute decorated.key?("name_d")
-    end
-
-    it "decorates broker only_keys" do
-      assert_equal 200, decorated["brokers"]["localhost:9092/0"]["txbytes_d"]
-    end
-
-    it "does not decorate non-listed broker keys" do
-      refute decorated["brokers"]["localhost:9092/0"].key?("rxbytes_d")
-    end
-
-    it "decorates partition only_keys" do
-      assert_equal(-10, decorated.dig("topics", "events", "partitions", "0")["consumer_lag_d"])
-      assert_equal(-5, decorated.dig("topics", "events", "partitions", "1")["consumer_lag_d"])
-    end
-
-    it "does not decorate non-listed partition keys" do
-      refute decorated.dig("topics", "events", "partitions", "0").key?("txmsgs_d")
-      refute decorated.dig("topics", "events", "partitions", "0").key?("hi_offset_d")
-    end
-
-    it "does not decorate non-listed topic keys" do
-      refute decorated.dig("topics", "events").key?("age_d")
-    end
-
-    it { assert_predicate decorated, :frozen? }
-  end
-
-  context "when only_keys previous value type changed to non-numeric" do
-    let(:decorator) { described_class.new(only_keys: %w[val]) }
-
-    subject(:decorated) do
-      decorator.call({ "val" => "not_numeric" })
-      decorator.call({ "val" => 10 })
-    end
-
-    it { refute decorated.key?("val_d") }
-  end
-
-  context "when a value type changed from numeric to non-numeric between emissions" do
-    subject(:decorated) do
-      decorator.call(emitted_stats1)
-      decorator.call(emitted_stats2)
-    end
-
-    before do
-      # In the second emission, txbytes changed to a string
-      emitted_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