kafka_command 0.0.1

data/spec/models/kafka_command/topic_spec.rb

@@ -0,0 +1,311 @@
+# frozen_string_literal: true
+
+RSpec.describe KafkaCommand::Topic do
+  let(:topic_name) { "test-#{SecureRandom.hex(12)}" }
+  let(:num_partitions) { 5 }
+  let(:replication_factor) { 1 }
+  let(:topic_creation_kwargs) do
+    {
+      num_partitions: num_partitions, replication_factor: replication_factor
+    }
+  end
+
+  let(:topic) do
+    KafkaCommand::Cluster.all.first.topics.find { |t| t.name == topic_name }
+  end
+
+  before { create_topic(topic_name, **topic_creation_kwargs) }
+
+  describe '#new' do
+    it 'initializes Kafka::Topic with name, replication_factor, and partitions' do
+      expect(topic.name).to eq(topic_name)
+      expect(topic.replication_factor).to eq(1)
+      expect(topic.partitions.count).to eq(5)
+      expect(topic.partitions.first).to be_an_instance_of(KafkaCommand::Partition)
+    end
+  end
+
+  describe '#destroy' do
+    it 'deletes the topic' do
+      topic.destroy
+      expect(topic_exists?(topic_name)).to eq(false)
+    end
+
+    context 'consumer offsets topic' do
+      before do
+        allow(topic).to receive(:name).and_return(described_class::CONSUMER_OFFSET_TOPIC)
+      end
+
+      it 'raises' do
+        expect { topic.destroy }.to raise_error(described_class::DeletionError)
+      end
+    end
+  end
+
+  describe '#set_partitions!' do
+    describe 'api not supported' do
+      before do
+        allow_any_instance_of(KafkaCommand::Client).to receive(:supports_api?).and_return(false)
+      end
+
+      it 'raises' do
+        expect do
+          topic.set_partitions!(num_partitions + 1)
+        end.to raise_error(KafkaCommand::UnsupportedApiError)
+      end
+    end
+
+    describe 'num_partitions > current num_partitions' do
+      it 'increases partitions' do
+        topic.set_partitions!(num_partitions + 1)
+        sleep_if_necessary
+        topic.refresh!
+        expect(topic.partitions.count).to eq(num_partitions + 1)
+        expect(partitions_for(topic_name)).to eq(num_partitions + 1)
+      end
+    end
+
+    describe 'num_partitions == current num_partitions' do
+      it 'raises an error and stays the same' do
+        expect { topic.set_partitions!(num_partitions) }.to raise_error(Kafka::InvalidPartitions)
+        expect(topic.partitions.count).to eq(num_partitions)
+        expect(partitions_for(topic_name)).to eq(num_partitions)
+      end
+    end
+
+    describe 'num_partitions < current num_partitions' do
+      it 'raises an error and stays the same' do
+        expect { topic.set_partitions!(num_partitions - 1) }.to raise_error(Kafka::InvalidPartitions)
+        expect(topic.partitions.count).to eq(num_partitions)
+        expect(partitions_for(topic_name)).to eq(num_partitions)
+      end
+    end
+  end
+
+  describe '#set_configs!' do
+    context 'max message bytes' do
+      describe 'greater than 0' do
+        let(:max_message_bytes) { 1024 }
+
+        it 'works' do
+          topic.set_configs!(max_message_bytes: max_message_bytes)
+          expect(topic.max_message_bytes).to eq(max_message_bytes)
+        end
+      end
+
+      describe 'is 0' do
+        let(:max_message_bytes) { 0 }
+
+        it 'works' do
+          topic.set_configs!(max_message_bytes: max_message_bytes)
+          expect(topic.max_message_bytes).to eq(max_message_bytes)
+        end
+      end
+
+      describe 'less than 0' do
+        let(:max_message_bytes) { -1 }
+
+        it 'errors' do
+          expect { topic.set_configs!(max_message_bytes: max_message_bytes) }.to raise_error(Kafka::InvalidRequest)
+        end
+      end
+    end
+
+    context 'retention ms' do
+      describe 'greater than 0' do
+        let(:retention_ms) { 102400000 }
+
+        it 'works' do
+          topic.set_configs!(retention_ms: retention_ms)
+          expect(topic.retention_ms).to eq(retention_ms)
+        end
+      end
+
+      describe 'equal to 0' do
+        let(:retention_ms) { 0 }
+
+        it 'works' do
+          topic.set_configs!(retention_ms: retention_ms)
+          expect(topic.retention_ms).to eq(retention_ms)
+        end
+      end
+
+      describe 'less than 0' do
+        let(:retention_ms) { -1 }
+
+        it 'works' do
+          topic.set_configs!(retention_ms: retention_ms)
+          expect(topic.retention_ms).to eq(retention_ms)
+        end
+      end
+    end
+
+    context 'retention bytes' do
+      describe 'greater than 0' do
+        let(:retention_bytes) { 102400000 }
+
+        it 'works' do
+          topic.set_configs!(retention_bytes: retention_bytes)
+          expect(topic.retention_bytes).to eq(retention_bytes)
+        end
+      end
+
+      describe 'equal to 0' do
+        let(:retention_bytes) { 0 }
+
+        it 'works' do
+          topic.set_configs!(retention_bytes: retention_bytes)
+          expect(topic.retention_bytes).to eq(retention_bytes)
+        end
+      end
+
+      describe 'less than 0' do
+        let(:retention_bytes) { -1 }
+
+        it 'works' do
+          topic.set_configs!(retention_bytes: retention_bytes)
+          expect(topic.retention_bytes).to eq(retention_bytes)
+        end
+      end
+    end
+  end
+
+  describe '#refresh!' do
+    it 'reloads the topic metadata' do
+      create_partitions_for(topic_name, num_partitions: num_partitions + 1)
+      topic.refresh!
+      expect(topic.partitions.count).to eq(num_partitions + 1)
+    end
+  end
+
+  describe '#offset_for' do
+    let(:partition) { double(partition_id: 0) }
+    let(:offset) { topic.offset_for(partition) }
+
+    describe 'no messsages' do
+      it 'returns 0' do
+        expect(offset).to eq(0)
+      end
+    end
+
+    describe 'messages' do
+      let(:num_messages) { 2 }
+      before do
+        num_messages.times { deliver_message('test', topic: topic_name, partition: partition.partition_id) }
+      end
+
+      it 'returns the latest offset' do
+        expect(offset).to eq(num_messages)
+      end
+    end
+  end
+
+  describe '#as_json' do
+    let(:partition_json) { topic.partitions.sort_by(&:partition_id).map(&:as_json) }
+
+    context 'including the config' do
+      let(:expected_json) do
+        {
+          name: topic_name,
+          replication_factor: replication_factor,
+          partitions: partition_json,
+          config: {
+            max_message_bytes: described_class::DEFAULT_MAX_MESSAGE_BYTES,
+            retention_ms: described_class::DEFAULT_RETENTION_MS,
+            retention_bytes: described_class::DEFAULT_RETENTION_BYTES
+          },
+        }.to_json
+      end
+
+      it 'equals the expected payload' do
+        expect(topic.as_json(include_config: true).to_json).to eq(expected_json)
+      end
+    end
+
+    context 'not including the config' do
+      let(:expected_json) do
+        {
+          name: topic_name,
+          replication_factor: replication_factor,
+          partitions: partition_json
+        }.to_json
+      end
+
+      it 'equals the expected payload' do
+        expect(topic.as_json.to_json).to eq(expected_json)
+      end
+    end
+  end
+
+  describe '#brokers_spread' do
+    let(:broker_doubles) do
+      [
+        double(:broker),
+        double(:broker),
+        double(:broker),
+        double(:broker),
+        double(:broker)
+      ]
+    end
+
+    before do
+      allow(topic).to receive(:replication_factor).and_return(replication_factor_double)
+      allow_any_instance_of(KafkaCommand::Client).to receive(:brokers).and_return(broker_doubles)
+    end
+
+    context '100%' do
+      let(:replication_factor_double) { broker_doubles.count }
+
+      it 'returns 100' do
+        expect(topic.brokers_spread).to eq(100)
+      end
+    end
+
+    context 'less than 20%' do
+      let(:replication_factor_double) { 1 }
+
+      it 'returns 20' do
+        expect(topic.brokers_spread).to eq(20)
+      end
+    end
+  end
+
+  describe '#groups' do
+    let(:group_id_1) { "test-group-#{SecureRandom.hex(12)}" }
+
+    context 'group consuming' do
+      it 'returns a list containing the group' do
+        run_consumer_group(topic_name, group_id_1) do
+          expect(topic.groups.map(&:group_id)).to include(group_id_1)
+        end
+      end
+    end
+
+    context 'group not consuming' do
+      it 'returns a list not containing the group' do
+        run_consumer_group(topic_name, group_id_1)
+        expect(topic.groups.map(&:group_id)).to_not include(group_id_1)
+      end
+    end
+  end
+
+  describe '#consumer_offset_topic?' do
+    context 'when consumer offset topic' do
+      let(:consumer_offset_topic) { described_class::CONSUMER_OFFSET_TOPIC }
+
+      before do
+        allow(topic).to receive(:name).and_return(consumer_offset_topic)
+      end
+
+      it 'returns true' do
+        expect(topic.consumer_offset_topic?).to eq(true)
+      end
+    end
+
+    context 'normal topic' do
+      it 'returns false' do
+        expect(topic.consumer_offset_topic?).to eq(false)
+      end
+    end
+  end
+end

data/spec/rails_helper.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+# This file is copied to spec/ when you run 'rails generate rspec:install'
+require 'spec_helper'
+require 'support/kafka_helper'
+ENV['RAILS_ENV'] ||= 'test'
+require File.expand_path('../dummy/config/environment', __FILE__)
+# Prevent database truncation if the environment is production
+abort('The Rails environment is running in production mode!') if Rails.env.production?
+Dotenv.load
+require 'rspec/rails'
+# Add additional requires below this line. Rails is not loaded until this point!
+require 'support/json_helper'
+
+# Requires supporting ruby files with custom matchers and macros, etc, in
+# spec/support/ and its subdirectories. Files matching `spec/**/*_spec.rb` are
+# run as spec files by default. This means that files in spec/support that end
+# in _spec.rb will both be required and run as specs, causing the specs to be
+# run twice. It is recommended that you do not name files matching this glob to
+# end with _spec.rb. You can configure this pattern with the --pattern
+# option on the command line or in ~/.rspec, .rspec or `.rspec-local`.
+#
+# The following line is provided for convenience purposes. It has the downside
+# of increasing the boot-up time by auto-requiring all files in the support
+# directory. Alternatively, in the individual `*_spec.rb` files, manually
+# require only the support files necessary.
+#
+# Dir[Rails.root.join('spec/support/**/*.rb')].each { |f| require f }
+
+# Checks for pending migrations and applies them before tests are run.
+# If you are not using ActiveRecord, you can remove this line.
+ActiveRecord::Migration.maintain_test_schema!
+
+RSpec.configure do |config|
+  # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
+  config.fixture_path = "#{::Rails.root}/spec/fixtures"
+
+  # If you're not using ActiveRecord, or you'd prefer not to run each of your
+  # examples within a transaction, remove the following line or assign false
+  # instead of true.
+  config.use_transactional_fixtures = true
+
+  # RSpec Rails can automatically mix in different behaviours to your tests
+  # based on their file location, for example enabling you to call `get` and
+  # `post` in specs under `spec/controllers`.
+  #
+  # You can disable this behaviour by removing the line below, and instead
+  # explicitly tag your specs with their type, e.g.:
+  #
+  #     RSpec.describe UsersController, :type => :controller do
+  #       # ...
+  #     end
+  #
+  # The different available types are documented in the features, such as in
+  # https://relishapp.com/rspec/rspec-rails/docs
+  config.infer_spec_type_from_file_location!
+
+  # Filter lines from Rails gems in backtraces.
+  config.filter_rails_from_backtrace!
+  # arbitrary gems may also be filtered via:
+  # config.filter_gems_from_backtrace("gem name")
+  #
+end

data/spec/requests/json/brokers_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe 'Brokers Api', type: :request do
+  let(:cluster) { KafkaCommand::Cluster.all.first }
+  let(:broker) { cluster.brokers.first }
+  let(:uri_base) { '/clusters' }
+
+  describe 'listing all brokers' do
+    let(:broker_obj) { double(:broker_obj, node_id: 0, host: 'localhost', port: '9092') }
+    let(:broker_obj_two) { double(:broker_obj, node_id: 1, host: 'localhost2', port: '9092') }
+    let(:broker) { KafkaCommand::Broker.new(broker_obj) }
+    let(:broker_two) { KafkaCommand::Broker.new(broker_obj_two) }
+
+    before do
+      allow_any_instance_of(KafkaCommand::Cluster).to receive(:brokers).and_return(
+        [
+          broker,
+          broker_two
+        ]
+      )
+    end
+
+    it 'lists' do
+      get "#{uri_base}/#{cluster.name}/brokers.json"
+      expect(response.status).to eq(200)
+      expect(json['data']).to be_an_instance_of(Array)
+      expect(json['data'].map { |d| d['id'] }).to eq([broker.node_id, broker_two.node_id])
+    end
+  end
+
+  describe 'showing a single broker' do
+    context 'broker exists' do
+      it 'shows' do
+        get "#{uri_base}/#{cluster.name}/brokers/#{broker.node_id}.json"
+        expect(response.status).to eq(200)
+        expect(json['id']).to eq(broker.node_id)
+        expect(json['host']).to eq("#{broker.host}:#{broker.port}")
+      end
+    end
+
+    context 'broker does not exist' do
+      it 'returns 404' do
+        get "#{uri_base}/#{cluster.name}/brokers/doesnotexist.json"
+        expect(response.status).to eq(404)
+      end
+    end
+  end
+end

data/spec/requests/json/clusters_spec.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe 'Clusters Api', type: :request do
+  let!(:cluster) { KafkaCommand::Cluster.all.first }
+
+  describe 'listing all clusters' do
+    let!(:cluster_two) { KafkaCommand::Cluster.new(seed_brokers: ['localhost:9092'], name: 'cluster_two') }
+
+    before do
+      allow(KafkaCommand::Cluster).to receive(:all).and_return([cluster, cluster_two])
+    end
+
+    it 'lists' do
+      get '/clusters.json'
+      expect(response.status).to eq(200)
+      expect(json['data']).to be_an_instance_of(Array)
+      expect(json['data'].map { |d| d['name'] }).to eq([cluster.name, cluster_two.name])
+    end
+
+    context 'filtering' do
+      it 'filters by name' do
+        get "/clusters.json?name=#{cluster.name}"
+        expect(response.status).to eq(200)
+        expect(json['data']).to be_an_instance_of(Array)
+        expect(json['data'].map { |d| d['name'] }).to include(cluster.name)
+        expect(json['data'].map { |d| d['name'] }).to_not include(cluster_two.name)
+      end
+
+      it 'filters by name' do
+        get '/clusters.json?name=unknown'
+        expect(response.status).to eq(200)
+        expect(json['data']).to be_an_instance_of(Array)
+        expect(json['data']).to be_empty
+      end
+    end
+  end
+
+  describe 'showing a single cluster' do
+    context 'cluster exists' do
+      it 'shows' do
+        get "/clusters/#{cluster.name}.json"
+        expect(response.status).to eq(200)
+        expect(json['name']).to eq(cluster.name)
+        expect(json['version']).to eq(cluster.version)
+        expect(json['description']).to eq(cluster.description)
+      end
+    end
+
+    context 'cluster does not exist' do
+      it 'returns 404' do
+        get '/clusters/doesnotexist.json'
+        expect(response.status).to eq(404)
+      end
+    end
+  end
+end

data/spec/requests/json/consumer_groups_spec.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe 'Consumer Groups Api', type: :request do
+  let(:cluster) { KafkaCommand::Cluster.all.first }
+  let(:topic_name) { "test-#{SecureRandom.hex(12)}" }
+  let(:group_id_1) { "test-group-#{SecureRandom.hex(12)}" }
+  let(:group_id_2) { "test-group-#{SecureRandom.hex(12)}" }
+  let(:uri_base) { "/clusters/#{cluster.id}/" }
+  let(:expected_json_group_1_running) do
+    {
+      group_id: group_id_1,
+      state: 'Stable',
+      topics: [
+        {
+          name: topic_name,
+          partitions: [
+            {
+              partition_id: 0,
+              lag: nil,
+              offset: nil
+            }
+          ]
+        }
+      ]
+    }.with_indifferent_access
+  end
+
+  let(:expected_json_group_1_empty) do
+    {
+      group_id: group_id_1,
+      topics: [],
+      state: 'Empty'
+    }.with_indifferent_access
+  end
+
+  let(:expected_json_group_2_empty) do
+    {
+      group_id: group_id_2,
+      topics: [],
+      state: 'Empty'
+    }.with_indifferent_access
+  end
+
+  before { create_topic(topic_name) }
+
+  describe 'listing all consumer groups' do
+    describe 'dormant' do
+      before do
+        run_consumer_group(topic_name, group_id_1)
+        run_consumer_group(topic_name, group_id_2)
+      end
+
+      it 'returns empty groups' do
+        get "#{uri_base}/consumer_groups.json"
+        expect(response.status).to eq(200)
+        expect(json['data']).to be_an_instance_of(Array)
+        expect(json['data']).to include(expected_json_group_1_empty)
+        expect(json['data']).to include(expected_json_group_2_empty)
+      end
+
+      context 'filtering' do
+        it 'filters by group id' do
+          get "#{uri_base}/consumer_groups.json?group_id=#{group_id_1}"
+          expect(response.status).to eq(200)
+          expect(json['data']).to be_an_instance_of(Array)
+          expect(json['data']).to include(expected_json_group_1_empty)
+          expect(json['data']).to_not include(expected_json_group_2_empty)
+        end
+
+        it 'filters by group id' do
+          get "#{uri_base}/consumer_groups.json?group_id=unknown"
+          expect(response.status).to eq(200)
+          expect(json['data']).to be_an_instance_of(Array)
+          expect(json['data']).to be_empty
+        end
+      end
+    end
+
+    describe 'running ' do
+      let(:expected_json) do
+        {
+          group_id: group_id_1,
+          state: 'Stable',
+          topics: [
+            {
+              name: topic_name,
+              partitions: [
+                {
+                  partition_id: 0,
+                  lag: nil,
+                  offset: nil
+                }
+              ]
+            }
+          ]
+        }.with_indifferent_access
+      end
+
+      it 'returns non empty groups' do
+        run_consumer_group(topic_name, group_id_1) do
+          get "#{uri_base}/consumer_groups.json"
+          expect(json['data']).to include(expected_json)
+        end
+      end
+    end
+  end
+
+  describe 'showing a consumer group' do
+    context 'dormant' do
+      before { run_consumer_group(topic_name, group_id_1) }
+
+      it 'returns an empty group' do
+        get "#{uri_base}/consumer_groups/#{group_id_1}.json"
+        expect(response.status).to eq(200)
+        expect(json).to eq(expected_json_group_1_empty)
+      end
+    end
+
+    context 'running' do
+      it 'returns an empty group' do
+        run_consumer_group(topic_name, group_id_1) do
+          get "#{uri_base}/consumer_groups/#{group_id_1}.json"
+          expect(response.status).to eq(200)
+          expect(json).to eq(expected_json_group_1_running)
+        end
+      end
+    end
+
+    context 'not found' do
+      it 'returns 404' do
+        get "#{uri_base}/consumer_groups/doesnotexists.json"
+        expect(response.status).to eq(404)
+        expect(response.body).to eq('Consumer group not found')
+      end
+    end
+  end
+end