logstash-integration-rabbitmq 7.0.2-java → 7.3.0-java

data/spec/outputs/rabbitmq_spec.rb

@@ -1,8 +1,6 @@
 # encoding: UTF-8
 require "logstash/devutils/rspec/spec_helper"
-require "logstash/pipeline"
 require "logstash/outputs/rabbitmq"
-java_import java.util.concurrent.TimeoutException
 
 describe LogStash::Outputs::RabbitMQ do
   let(:klass) { LogStash::Outputs::RabbitMQ }
@@ -62,6 +60,10 @@ describe LogStash::Outputs::RabbitMQ do
       allow(connection).to receive(:on_shutdown)
       allow(connection).to receive(:on_recovery_start)
       allow(connection).to receive(:on_recovery)
+      allow(connection).to receive(:host).and_return host
+      allow(connection).to receive(:port).and_return port
+      allow(connection).to receive(:vhost).and_return nil
+      allow(connection).to receive(:user).and_return 'guest'
       allow(channel).to receive(:exchange).and_return(exchange)
 
       instance.register
@@ -84,18 +86,67 @@ describe LogStash::Outputs::RabbitMQ do
         before do
           allow(exchange).to receive(:publish).with(any_args)
           allow(event).to receive(:sprintf).with(key).and_return(sprinted_key)
-          instance.send(:publish, event, encoded_event)
         end
 
         it "should send the correct message" do
+          instance.send(:publish, event, encoded_event)
           expect(exchange).to have_received(:publish).with(encoded_event, anything)
         end
 
         it "should send the correct metadata" do
           expected_metadata = {:routing_key => sprinted_key, :properties => {:persistent => persistent }}
 
+          instance.send(:publish, event, encoded_event)
+
           expect(exchange).to have_received(:publish).with(anything, expected_metadata)
         end
+
+        context 'with message_properties' do
+          let(:rabbitmq_settings) { super().merge("message_properties" => message_properties) }
+          let(:message_properties) { Hash.new }
+          context 'priority' do
+            let(:message_properties) { super().merge("priority" => priority) }
+            context 'as literal Integer value' do
+              let(:priority) { 3 }
+              it 'publishes with the constant-value priority' do
+                instance.send(:publish, event, encoded_event)
+                expect(exchange).to have_received(:publish).with(anything, hash_including(:properties => hash_including(:priority => 3)))
+              end
+            end
+
+            context 'as literal String value' do
+              let(:priority) { "7" }
+              it 'publishes with the constant-value priority' do
+                instance.send(:publish, event, encoded_event)
+                expect(exchange).to have_received(:publish).with(anything, hash_including(:properties => hash_including(:priority => 7)))
+              end
+            end
+
+            context 'as template value' do
+              let(:priority) { "%{[@metadata][priority]}" }
+              context 'when event expands template value' do
+                before do
+                  expect(event).to receive(:sprintf).with(priority).and_return("31")
+                end
+
+                it 'publishes with the priority extracted from the event' do
+                 instance.send(:publish, event, encoded_event)
+                 expect(exchange).to have_received(:publish).with(anything, hash_including(:properties => hash_including(:priority => 31)))
+                end
+              end
+              context 'when event cannot expand template value' do
+                before do
+                  expect(event).to receive(:sprintf).with(priority).and_return(priority)
+                end
+
+                it 'publishes with the priority of zero (`0`)' do
+                 instance.send(:publish, event, encoded_event)
+                 expect(exchange).to have_received(:publish).with(anything, hash_including(:properties => hash_including(:priority => 0)))
+                end
+              end
+            end
+          end
+        end
       end
 
       context 'when an exception is encountered' do
@@ -124,7 +175,7 @@ describe LogStash::Outputs::RabbitMQ do
         end
 
         context 'when it is a TimeoutException' do
-          let(:exception) { TimeoutException.new }
+          let(:exception) { java.util.concurrent.TimeoutException.new }
           it_behaves_like 'recovers from exception gracefully'
         end
       end
@@ -133,14 +184,15 @@ describe LogStash::Outputs::RabbitMQ do
 end
 
 
-describe "with a live server", :integration => true do
+describe "LogStash::Outputs::RabbitMQ with a live server", :integration => true do
+  let(:rabbitmq_host) { ENV["RABBITMQ_HOST"] || "127.0.0.1" }
   let(:klass) { LogStash::Outputs::RabbitMQ }
   let(:exchange) { "myexchange" }
   let(:exchange_type) { "topic" }
   let(:priority) { 34 }
   let(:default_plugin_config) {
     {
-      "host" => "127.0.0.1",
+      "host" => rabbitmq_host,
       "exchange" => exchange,
       "exchange_type" => exchange_type,
       "key" => "foo",
@@ -158,7 +210,7 @@ describe "with a live server", :integration => true do
     instance.register
 
     20.times do
-      instance.connected? ? break : sleep(0.1)
+      instance.send(:connection_open?) ? break : sleep(0.1)
     end
 
     # Extra time to make sure the output can attach
@@ -190,12 +242,12 @@ describe "with a live server", :integration => true do
 
   context "using defaults" do
     it "should start, connect, and stop cleanly" do
-      expect(instance.connected?).to be_truthy
+      expect(instance.send(:connection_open?)).to be_truthy
     end
 
     it "should close cleanly" do
       instance.close
-      expect(instance.connected?).to be_falsey
+      expect(instance.send(:connection_open?)).to be_falsey
     end
 
     it 'applies per message settings' do

data/spec/plugin_mixins/rabbitmq_connection_spec.rb

@@ -14,12 +14,12 @@ end
 
 describe LogStash::PluginMixins::RabbitMQConnection do
   let(:klass) { TestPlugin }
+  let(:default_port) { 5672 }
   let(:host) { "localhost" }
-  let(:port) { 5672 }
+  let(:port) { default_port }
   let(:rabbitmq_settings) {
     {
-      "host" => host,
-      "port" => port,
+      "host" => host
     }
   }
   let(:instance) {
@@ -27,12 +27,28 @@ describe LogStash::PluginMixins::RabbitMQConnection do
   }
   let(:hare_info) { instance.instance_variable_get(:@hare_info) }
 
+  shared_examples_for 'it sets the addresses correctly' do
+    let(:file) { Stud::Temporary.file }
+    let(:path) { file.path }
+    let(:host) {%w(host01 host02 host03)}
+
+    it "should set addresses to the expected value" do
+      host.each_with_index do |each_host, index|
+        expect(instance.rabbitmq_settings[:addresses][index]).to eql("#{each_host}:#{port}")
+      end
+    end
+
+    it "should insert the correct number of address entries" do
+      expect(instance.rabbitmq_settings[:addresses].length).to eql(host.count)
+    end
+  end
+
   describe "rabbitmq_settings" do
     let(:file) { Stud::Temporary.file }
     let(:path) { file.path }
     after { File.unlink(path)}
 
-    let(:rabbitmq_settings) { super.merge({"connection_timeout" => 123,
+    let(:rabbitmq_settings) { super().merge({"connection_timeout" => 123,
                                            "heartbeat" => 456,
                                            "ssl" => true,
                                            "ssl_version" => "TLSv1.1",
@@ -40,11 +56,11 @@ describe LogStash::PluginMixins::RabbitMQConnection do
                                            "ssl_certificate_password" => "123"}) }
 
     it "should set the timeout to the expected value" do
-      expect(instance.rabbitmq_settings[:timeout]).to eql(rabbitmq_settings["connection_timeout"])
+      expect(instance.rabbitmq_settings[:connection_timeout]).to eql(rabbitmq_settings["connection_timeout"])
     end
 
     it "should set heartbeat to the expected value" do
-      expect(instance.rabbitmq_settings[:heartbeat]).to eql(rabbitmq_settings["heartbeat"])
+      expect(instance.rabbitmq_settings[:requested_heartbeat]).to eql(rabbitmq_settings["heartbeat"])
     end
 
     it "should set tls to the expected value" do
@@ -59,17 +75,18 @@ describe LogStash::PluginMixins::RabbitMQConnection do
       expect(instance.rabbitmq_settings[:tls_certificate_password]).to eql(rabbitmq_settings["ssl_certificate_password"])
     end
 
-    it "should set hosts to the expected value " do
-      expect(instance.rabbitmq_settings[:hosts][0]).to eql(host)
-    end
+    it_behaves_like 'it sets the addresses correctly'
+
+    context 'with a custom port' do
+      let(:port) { 123 }
+      let(:rabbitmq_settings) { super().merge({"port" => port})}
 
-    it "should only insert a single host entry" do
-      expect(instance.rabbitmq_settings[:hosts].length).to eql(1)
+      it_behaves_like 'it sets the addresses correctly'
     end
   end
 
   describe "ssl enabled, but no verification" do
-    let(:rabbitmq_settings) { super.merge({"connection_timeout" => 123,
+    let(:rabbitmq_settings) { super().merge({"connection_timeout" => 123,
                                            "heartbeat" => 456,
                                            "ssl" => true}) }
 
@@ -79,21 +96,25 @@ describe LogStash::PluginMixins::RabbitMQConnection do
     end
 
   end
-  describe "rabbitmq_settings multiple hosts" do
-    let(:file) { Stud::Temporary.file }
-    let(:path) { file.path }
-    after { File.unlink(path)}
 
-    let(:rabbitmq_settings) { super.merge({"host" => ["host01", "host02", "host03"]}) }
+  describe "rabbitmq_settings with multiple hosts" do
+    it_behaves_like 'it sets the addresses correctly'
+
+    context 'with a custom port'  do
+      let(:port) { 999 }
+      let(:rabbitmq_settings) { super().merge({"port" => port})}
 
-    it "should set hosts to the expected value" do
-      expect(instance.rabbitmq_settings[:hosts][0]).to eql("host01")
-      expect(instance.rabbitmq_settings[:hosts][1]).to eql("host02")
-      expect(instance.rabbitmq_settings[:hosts][2]).to eql("host03")
+      it_behaves_like 'it sets the addresses correctly'
     end
 
-    it "should insert 3 host entries" do
-      expect(instance.rabbitmq_settings[:hosts].length).to eql(3)
+    context 'when ports are set in the host definition' do
+      let(:host) { %w(host01:4444 host02:4445 host03:4446)}
+
+      it "should set the address correctly" do
+        expect(instance.rabbitmq_settings[:addresses][0]).to eql("host01:4444")
+        expect(instance.rabbitmq_settings[:addresses][1]).to eql("host02:4445")
+        expect(instance.rabbitmq_settings[:addresses][2]).to eql("host03:4446")
+      end
     end
   end
 
@@ -108,6 +129,10 @@ describe LogStash::PluginMixins::RabbitMQConnection do
       allow(connection).to receive(:on_blocked)
       allow(connection).to receive(:on_unblocked)
       allow(connection).to receive(:on_shutdown)
+      allow(connection).to receive(:host).and_return host
+      allow(connection).to receive(:port).and_return port
+      allow(connection).to receive(:vhost).and_return nil
+      allow(connection).to receive(:user).and_return 'guest'
 
       instance.register
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logstash-integration-rabbitmq
 version: !ruby/object:Gem::Version
-  version: 7.0.2
+  version: 7.3.0
 platform: java
 authors:
 - Elastic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-12-03 00:00:00.000000000 Z
+date: 2021-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -103,17 +103,17 @@ dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.0'
   name: logstash-devutils
   prerelease: false
   type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
@@ -218,7 +218,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project:
-rubygems_version: 2.6.11
+rubygems_version: 2.6.13
 signing_key:
 specification_version: 4
 summary: Integration with RabbitMQ - input and output plugins