logstash-codec-protobuf 1.0.5 → 1.2.5

data/logstash-codec-protobuf.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
 
   s.name            = 'logstash-codec-protobuf'
-  s.version         = '1.0.5'
+  s.version         = '1.2.5'
   s.licenses        = ['Apache License (2.0)']
   s.summary         = "Reads protobuf messages and converts to Logstash Events"
   s.description     = "This gem is a logstash plugin required to be installed on top of the Logstash core pipeline using $LS_HOME/bin/plugin install gemname. This gem is not a stand-alone program"
@@ -20,8 +20,8 @@ Gem::Specification.new do |s|
 
   # Gem dependencies
   s.add_runtime_dependency "logstash-core-plugin-api", ">= 1.60", "<= 2.99"
-  s.add_runtime_dependency 'google-protobuf', '3.1'
+  s.add_runtime_dependency 'google-protobuf', '3.5.0.pre'
   s.add_runtime_dependency 'ruby-protocol-buffers' # for protobuf 2
   s.add_development_dependency 'logstash-devutils'
-end
 
+end

data/spec/codecs/{protobuf_spec.rb → pb2_spec.rb}

@@ -2,30 +2,32 @@
 require "logstash/devutils/rspec/spec_helper"
 require "logstash/codecs/protobuf"
 require "logstash/event"
-require "insist"
-
 
 require 'protocol_buffers' # https://github.com/codekitchen/ruby-protocol-buffers, for protobuf2
 
+require_relative '../helpers/pb2/header/header.pb.rb'
+require_relative '../helpers/pb2/event.pb.rb'
+
 
 describe LogStash::Codecs::Protobuf do
 
+  pb_include_path = File.expand_path(".") + "/spec/helpers"
 
+  context "#test1" do
 
-  context "#decodePB2" do
 
 
     #### Test case 1: Decode simple protobuf bytes for unicorn ####################################################################################################################
-    let(:plugin_unicorn) { LogStash::Codecs::Protobuf.new("class_name" => "Animal::Unicorn", "include_path" => ['spec/helpers/pb2/unicorn.pb.rb'])  }
+    let(:plugin_unicorn) { LogStash::Codecs::Protobuf.new("class_name" => "Animal::Unicorn", "include_path" => [pb_include_path + '/pb2/unicorn.pb.rb'])  }
     before do
-        plugin_unicorn.register      
+        plugin_unicorn.register
     end
 
     it "should return an event from protobuf encoded data" do
-    
+
       data = {:colour => 'rainbow', :horn_length => 18, :last_seen => 1420081471, :has_wings => true}
       unicorn = Animal::Unicorn.new(data)
-        
+
       plugin_unicorn.decode(unicorn.serialize_to_string) do |event|
         expect(event.get("colour") ).to eq(data[:colour] )
         expect(event.get("horn_length") ).to eq(data[:horn_length] )
@@ -34,34 +36,34 @@ describe LogStash::Codecs::Protobuf do
       end
     end # it
 
-
+  end
 
     #### Test case 2: Decode complex protobuf bytes for human #####################################################################################################################
 
+  context "#test2" do
 
-  
- 
-    let(:plugin_human) { LogStash::Codecs::Protobuf.new("class_name" => "Animal::Human", "include_path" => ['spec/helpers/pb2/human.pb.rb'])  }
+
+    let(:plugin_human) { LogStash::Codecs::Protobuf.new("class_name" => "Animal::Human", "include_path" => [pb_include_path + '/pb2/human.pb.rb'])  }
     before do
-        plugin_human.register      
+        plugin_human.register
     end
 
     it "should return an event from complex nested protobuf encoded data" do
-    
+
       data_gm = {:first_name => 'Elisabeth', :last_name => "Oliveoil", :middle_names => ["Maria","Johanna"], :vegetarian=>true}
       grandmother = Animal::Human.new(data_gm)
       data_m = {:first_name => 'Annemarie', :last_name => "Smørebrød", :mother => grandmother}
       mother = Animal::Human.new(data_m)
       data_f = {:first_name => 'Karl', :middle_names => ["Theodor-Augustin"], :last_name => "Falkenstein"}
       father = Animal::Human.new(data_f)
-      data = {:first_name => 'Hugo', :middle_names => ["Heinz", "Peter"], :last_name => "Smørebrød",:father => father, :mother => mother}  
+      data = {:first_name => 'Hugo', :middle_names => ["Heinz", "Peter"], :last_name => "Smørebrød",:father => father, :mother => mother}
       hugo = Animal::Human.new(data)
-       
+
       plugin_human.decode(hugo.serialize_to_string) do |event|
         expect(event.get("first_name") ).to eq(data[:first_name] )
         expect(event.get("middle_names") ).to eq(data[:middle_names] )
         expect(event.get("last_name") ).to eq(data[:last_name] )
-        expect(event.get("[mother][first_name]") ).to eq(data_m[:first_name] ) 
+        expect(event.get("[mother][first_name]") ).to eq(data_m[:first_name] )
         expect(event.get("[father][first_name]") ).to eq(data_f[:first_name] )
         expect(event.get("[mother][last_name]") ).to eq(data_m[:last_name] )
         expect(event.get("[mother][mother][last_name]") ).to eq(data_gm[:last_name] )
@@ -72,28 +74,25 @@ describe LogStash::Codecs::Protobuf do
         expect(event.get("[father][middle_names]") ).to eq(data_f[:middle_names] )
       end
     end # it
-
-
-
-
+  end # context
 
 
     #### Test case 3: Decoder test for enums #####################################################################################################################
 
+  context "#test3" do
 
-  
- 
-    let(:plugin_col) { LogStash::Codecs::Protobuf.new("class_name" => "ColourProtoTest", "include_path" => ['spec/helpers/pb2/ColourTestcase.pb.rb'])  }
+
+    let(:plugin_col) { LogStash::Codecs::Protobuf.new("class_name" => "ColourProtoTest", "include_path" => [pb_include_path + '/pb2/ColourTestcase.pb.rb'])  }
     before do
-        plugin_col.register      
+        plugin_col.register
     end
 
     it "should return an event from protobuf encoded data with enums" do
-    
+
       data = {:least_liked => ColourProtoTest::Colour::YELLOW, :favourite_colours => \
-        [ColourProtoTest::Colour::BLACK, ColourProtoTest::Colour::BLUE], :booleantest => [true, false, true]}  
+        [ColourProtoTest::Colour::BLACK, ColourProtoTest::Colour::BLUE], :booleantest => [true, false, true]}
       pb = ColourProtoTest.new(data)
-       
+
       plugin_col.decode(pb.serialize_to_string) do |event|
         expect(event.get("least_liked") ).to eq(data[:least_liked] )
         expect(event.get("favourite_colours") ).to eq(data[:favourite_colours] )
@@ -102,31 +101,28 @@ describe LogStash::Codecs::Protobuf do
     end # it
 
 
-  end # context decodePB2
-
-
-
+  end # context test3
 
 
   #### Test case 4: Encode simple protobuf bytes for unicorn ####################################################################################################################
 
   context "#encodePB2-a" do
     subject do
-      next LogStash::Codecs::Protobuf.new("class_name" => "Animal::UnicornEvent", "include_path" => ['spec/helpers/pb2/unicorn_event.pb.rb']) 
+      next LogStash::Codecs::Protobuf.new("class_name" => "Animal::UnicornEvent", "include_path" => [pb_include_path + '/pb2/unicorn_event.pb.rb'])
     end
 
-    event = LogStash::Event.new("colour" => "pink", "horn_length" => 12, "last_seen" => 1410081999, "has_wings" => true)    
+    event = LogStash::Event.new("colour" => "pink", "horn_length" => 12, "last_seen" => 1410081999, "has_wings" => true)
 
     it "should return protobuf encoded data from a simple event" do
       subject.on_event do |event, data|
-        insist { data.is_a? String }
-        unicorn = Animal::UnicornEvent.parse(data) 
-    
+        expect(data).to be_a(String)
+        unicorn = Animal::UnicornEvent.parse(data)
+
         expect(unicorn.colour ).to eq(event.get("colour") )
         expect(unicorn.horn_length ).to eq(event.get("horn_length") )
         expect(unicorn.last_seen ).to eq(event.get("last_seen") )
         expect(unicorn.has_wings ).to eq(event.get("has_wings") )
-      
+
       end # subject.on_event
       subject.encode(event)
     end # it
@@ -136,23 +132,23 @@ describe LogStash::Codecs::Protobuf do
 
 
   #### Test case 5: encode complex protobuf bytes for human #####################################################################################################################
-  
-  
+
+
   context "#encodePB2-b" do
     subject do
-      next LogStash::Codecs::Protobuf.new("class_name" => "Animal::Human", "include_path" => ['spec/helpers/pb2/human.pb.rb']) 
+      next LogStash::Codecs::Protobuf.new("class_name" => "Animal::Human", "include_path" => [pb_include_path + '/pb2/human.pb.rb'])
     end
 
     event = LogStash::Event.new("first_name" => "Jimmy", "middle_names" => ["Bob", "James"], "last_name" => "Doe" \
       , "mother" => {"first_name" => "Jane", "middle_names" => ["Elizabeth"], "last_name" => "Doe" , "age" => 83, "vegetarian"=> false} \
-      , "father" => {"first_name" => "John", "last_name" => "Doe", "@email" => "character_replacement_test@nothing" })    
+      , "father" => {"first_name" => "John", "last_name" => "Doe", "@email" => "character_replacement_test@nothing" })
 
     it "should return protobuf encoded data from a complex event" do
 
       subject.on_event do |event, data|
-        insist { data.is_a? String }
-        jimmy = Animal::Human.parse(data) 
-        
+        expect(data).to be_a(String)
+        jimmy = Animal::Human.parse(data)
+
         expect(jimmy.first_name ).to eq(event.get("first_name") )
         expect(jimmy.middle_names ).to eq(event.get("middle_names") )
         expect(jimmy.last_name ).to eq(event.get("last_name") )
@@ -164,7 +160,7 @@ describe LogStash::Codecs::Protobuf do
         expect(jimmy.father.last_name ).to eq(event.get("[father][last_name]") )
         expect(jimmy.father.email ).to eq(event.get("[father][@email]") ) # recursion test for keys
         expect(jimmy.mother.last_name ).to eq(event.get("[mother][last_name]") )
-      
+
       end # subject.on_event
       subject.encode(event)
     end # it
@@ -175,35 +171,66 @@ describe LogStash::Codecs::Protobuf do
 
 
   #### Test case 6: encode enums #########################################################################################################################
-  
 
- 
+
+
   context "#encodePB2-c" do
     subject do
-      next LogStash::Codecs::Protobuf.new("class_name" => "ColourProtoTest", "include_path" => ['spec/helpers/pb2/ColourTestcase.pb.rb'])
+      next LogStash::Codecs::Protobuf.new("class_name" => "ColourProtoTest", "include_path" => [pb_include_path + '/pb2/ColourTestcase.pb.rb'])
     end
 
-    require 'spec/helpers/pb2/ColourTestcase.pb.rb' # otherwise we cant use the colour enums in the next line
+    require_relative '../helpers/pb2/ColourTestcase.pb.rb' # otherwise we cant use the colour enums in the next line
+    # ^ this import is run from the spec directory, $LOGSTASH_DIR/spec/codecs/
+
     event = LogStash::Event.new("booleantest" =>  [false, false, true], "least_liked" => ColourProtoTest::Colour::YELLOW,  "favourite_colours" => \
-       [ColourProtoTest::Colour::BLACK, ColourProtoTest::Colour::BLUE] )    
+       [ColourProtoTest::Colour::BLACK, ColourProtoTest::Colour::BLUE] )
 
     it "should return protobuf encoded data from a complex event with enums" do
 
       subject.on_event do |event, data|
-        insist { data.is_a? String }
+        expect(data).to be_a(String)
+
+        colpref = ColourProtoTest.parse(data)
 
-        colpref = ColourProtoTest.parse(data) 
-        
         expect(colpref.booleantest ).to eq(event.get("booleantest") )
         expect(colpref.least_liked ).to eq(event.get("least_liked") )
         expect(colpref.favourite_colours ).to eq(event.get("favourite_colours") )
 
-      
+
       end # subject.on_event
       subject.encode(event)
     end # it
   end # context
 
+  #### Test case 7: decode a message automatically loading the dependencies ######################################################################################
+
+  context "#test4" do
+    let(:plugin) { LogStash::Codecs::Protobuf.new(
+      "class_name" => "Logging::Event",
+      "class_file" => [ 'event.pb.rb' ],
+      "protobuf_root_directory" => pb_include_path + '/pb2/')
+    }
+
+    before do
+      plugin.register
+    end
+
+    it "should return an event from protobuf encoded data loading the dependencies" do
+      header = Grpc::Header.new(:protocol => 'https')
+
+      data = {
+        :name => "Test",
+        :header => header,
+      }
+
+      pb = Logging::Event.new(data)
+
+      plugin.decode(pb.serialize_to_string) do |event|
+        expect(event.get("name") ).to eq(data[:name])
+        expect(event.get("header") ).to eq({"protocol"=>"https"})
+      end
+    end # it
+  end # context test4
 
 
 end # describe

data/spec/codecs/pb3_decode_spec.rb

@@ -0,0 +1,445 @@
+# encoding: utf-8
+require "logstash/devutils/rspec/spec_helper"
+require "logstash/codecs/protobuf"
+require "logstash/event"
+
+require 'google/protobuf' # for protobuf3
+
+# absolute path to the protobuf helpers directory
+pb_include_path = File.expand_path(".") + "/spec/helpers"
+
+require pb_include_path + '/pb3/unicorn_pb.rb'
+unicorn_class = Google::Protobuf::DescriptorPool.generated_pool.lookup("Unicorn").msgclass
+
+describe LogStash::Codecs::Protobuf do
+
+  context ".reloadable?" do
+    subject do
+      next LogStash::Codecs::Protobuf.new(
+        "class_name" => "Unicorn",
+        "include_path" => [pb_include_path + '/pb3/unicorn_pb.rb'],
+        "protobuf_version" => 3
+      )
+    end
+
+    it "returns false" do
+      expect(subject.reloadable?).to be_falsey
+    end
+  end
+
+  context "config" do
+    context "using class_file and include_path" do
+      let(:plugin) {
+        LogStash::Codecs::Protobuf.new(
+          "class_name" => "Unicorn",
+          "include_path" => [pb_include_path + '/pb3/unicorn_pb.rb'],
+          "class_file" => pb_include_path + '/pb3/unicorn_pb.rb',
+          "protobuf_version" => 3
+        )
+      }
+
+      it "should fail to register the plugin with ConfigurationError" do
+        expect {plugin.register}.to raise_error(LogStash::ConfigurationError, /`include_path` and `class_file`/)
+      end # it
+    end
+
+    context "not using class_file or include_path" do
+      let(:plugin) {
+        LogStash::Codecs::Protobuf.new("class_name" => "Unicorn")
+      }
+
+      it "should fail to register the plugin with ConfigurationError" do
+        expect {plugin.register}.to raise_error(LogStash::ConfigurationError, /`include_path` or `class_file`/)
+      end # it
+    end
+
+    RSpec::Expectations.configuration.on_potential_false_positives = :nothing
+
+    context "re-registering the plugin with a valid configuration" do
+      let(:plugin) { LogStash::Codecs::Protobuf.new(
+        "class_name" => "A.MessageA",
+        "class_file" => [ pb_include_path + '/pb3/messageA_pb.rb' ],
+        "protobuf_version" => 3,
+        "protobuf_root_directory" => File.expand_path(File.dirname(__FILE__) + pb_include_path + '/pb3/'))
+      }
+
+      it "should not fail" do
+        expect {
+          # this triggers the `register()` method of the plugin multiple times
+          plugin.register
+          plugin.register
+        }.not_to raise_error(RuntimeError)
+      end # it
+    end
+  end # context
+
+  context "#pb3decoder_test1" do
+
+
+    #### Test case 1: Decode simple protobuf ####################################################################################################################
+    let(:plugin_unicorn) { LogStash::Codecs::Protobuf.new(
+      "class_name" => "Unicorn", "include_path" => [pb_include_path + '/pb3/unicorn_pb.rb'], "protobuf_version" => 3)
+    }
+
+    it "should return an event from protobuf data" do
+
+      unicorn_class = Google::Protobuf::DescriptorPool.generated_pool.lookup("Unicorn").msgclass
+      data = {:name => 'Pinkie', :age => 18, :is_pegasus => false, :favourite_numbers => [4711,23], :fur_colour => Colour::PINK,
+      :favourite_colours => [Colour::GREEN, Colour::BLUE]
+      }
+
+      unicorn_object = unicorn_class.new(data)
+      bin = unicorn_class.encode(unicorn_object)
+      plugin_unicorn.decode(bin) do |event|
+        expect(event.get("name") ).to eq(data[:name] )
+        expect(event.get("age") ).to eq(data[:age])
+        expect(event.get("fur_colour") ).to eq("PINK")
+        expect(event.get("favourite_numbers") ).to eq(data[:favourite_numbers])
+        expect(event.get("favourite_colours") ).to eq(["GREEN","BLUE"])
+        expect(event.get("is_pegasus") ).to eq(data[:is_pegasus] )
+      end
+    end # it
+  end # context
+
+  context "#pb3decoder_test2" do
+
+    #### Test case 2: decode nested protobuf ####################################################################################################################
+    let(:plugin_unicorn) { LogStash::Codecs::Protobuf.new("class_name" => "Unicorn", "include_path" => [pb_include_path + '/pb3/unicorn_pb.rb'], "protobuf_version" => 3)  }
+
+    it "should return an event from protobuf data with nested classes" do
+      father = unicorn_class.new({:name=> "Sparkle", :age => 50, :fur_colour => 3 })
+      data = {:name => 'Glitter', :fur_colour => Colour::GLITTER, :father => father}
+
+      unicorn_object = unicorn_class.new(data)
+      bin = unicorn_class.encode(unicorn_object)
+      plugin_unicorn.decode(bin) do |event|
+        expect(event.get("name") ).to eq(data[:name] )
+        expect(event.get("fur_colour") ).to eq("GLITTER" )
+        expect(event.get("father")["name"] ).to eq(data[:father][:name] )
+        expect(event.get("father")["age"] ).to eq(data[:father][:age] )
+        expect(event.get("father")["fur_colour"] ).to eq("SILVER")
+
+      end
+    end # it
+
+  end # context
+
+  context "#pb3decoder_test3" do
+
+    #### Test case 3: decode ProbeResult ####################################################################################################################
+    let(:plugin_3) { LogStash::Codecs::Protobuf.new("class_name" => "ProbeResult", "include_path" => [pb_include_path + '/pb3/ProbeResult_pb.rb'], "protobuf_version" => 3)  }
+
+    before do
+        plugin_3.register
+    end
+
+    it "should return an event from protobuf data with nested classes" do
+
+      probe_result_class = Google::Protobuf::DescriptorPool.generated_pool.lookup("ProbeResult").msgclass
+      ping_result_class = Google::Protobuf::DescriptorPool.generated_pool.lookup("PingIPv4Result").msgclass
+
+      ping_result_data = {:status=> PingIPv4Result::Status::ERROR,
+        :latency => 50, :ip => "8.8.8.8", :probe_ip => "127.0.0.1", :geolocation => "New York City" }
+      ping_result_object = ping_result_class.new(ping_result_data)
+
+      probe_result_data = {:UUID => '12345678901233456789', :TaskPingIPv4Result => ping_result_object}
+      probe_result_object = probe_result_class.new(probe_result_data)
+      bin = probe_result_class.encode(probe_result_object)
+      plugin_3.decode(bin) do |event|
+        expect(event.get("UUID") ).to eq(probe_result_data[:UUID] )
+        expect(event.get("TaskPingIPv4Result")["status"] ).to eq("ERROR")
+        expect(event.get("TaskPingIPv4Result")["latency"] ).to eq(ping_result_data[:latency] )
+        expect(event.get("TaskPingIPv4Result")["ip"] ).to eq(ping_result_data[:ip] )
+        expect(event.get("TaskPingIPv4Result")["probe_ip"] ).to eq(ping_result_data[:probe_ip] )
+        expect(event.get("TaskPingIPv4Result")["geolocation"] ).to eq(ping_result_data[:geolocation] )
+      end
+    end # it
+  end # context
+
+  context "#pb3decoder_test4" do
+
+    #### Test case 4: decode PBDNSMessage ####################################################################################################################
+    let(:plugin_4) { LogStash::Codecs::Protobuf.new("class_name" => "PBDNSMessage", "include_path" => [pb_include_path + '/pb3/dnsmessage_pb.rb'], "protobuf_version" => 3)  }
+
+    before do
+        plugin_4.register
+    end
+
+    it "should return an event from protobuf data with nested classes" do
+
+
+      pbdns_message_class = Google::Protobuf::DescriptorPool.generated_pool.lookup("PBDNSMessage").msgclass
+      dns_question_class  = Google::Protobuf::DescriptorPool.generated_pool.lookup("PBDNSMessage.DNSQuestion").msgclass
+      dns_response_class  = Google::Protobuf::DescriptorPool.generated_pool.lookup("PBDNSMessage.DNSResponse").msgclass
+      dns_rr_class        = Google::Protobuf::DescriptorPool.generated_pool.lookup("PBDNSMessage.DNSResponse.DNSRR").msgclass
+
+      dns_question_data = {:qName => "Foo", :qType => 12345, :qClass => 67890 }
+      dns_question_object = dns_question_class.new(dns_question_data)
+
+      dns_response_data = {:rcode => 12345, :appliedPolicy => "baz", :tags => ["a","b","c"],
+        :queryTimeSec => 123, :queryTimeUsec => 456,
+        :appliedPolicyType => PBDNSMessage::PolicyType::NSIP}
+
+      dns_rr_data = [
+        {:name => "abc", :type => 9000, :class => 8000, :ttl => 20, :rdata => "300"},
+        {:name => "def", :type => 19000, :class => 18000, :ttl => 120, :rdata => "1300"}
+      ]
+
+      dns_response_data[:rrs] = dns_rr_data.map { | d | d = dns_rr_class.new(d) }
+      dns_response_object = dns_response_class.new(dns_response_data)
+
+      pbdns_message_data = {
+        # :UUID => '12345678901233456789', :TaskPingIPv4Result => ping_result_object
+        :type => PBDNSMessage::Type::DNSIncomingResponseType,
+        :messageId => "15",
+        :serverIdentity => "16",
+        :socketFamily => PBDNSMessage::SocketFamily::INET6,
+        :socketProtocol => PBDNSMessage::SocketProtocol::TCP,
+        :from => "17",
+        :to => "18",
+        :inBytes => 70000,
+        :timeSec => 80000,
+        :timeUsec => 90000,
+        :id => 20000,
+        :question => dns_question_object,
+        :response => dns_response_object,
+        :originalRequestorSubnet => "19",
+        :requestorId => "Bar",
+        :initialRequestId => "20",
+        :deviceId => "21",
+        }
+      pbdns_message_object = pbdns_message_class.new(pbdns_message_data)
+      bin = pbdns_message_class.encode(pbdns_message_object)
+      plugin_4.decode(bin) do |event|
+
+        ['messageId', 'serverIdentity','from','to','inBytes','timeUsec','timeSec','id', 'originalRequestorSubnet', 'requestorId' ,'initialRequestId','deviceIdf'].each { |n|
+          expect(event.get(n)).to eq(pbdns_message_data[n.to_sym] ) }
+
+        # enum test:
+        expect(event.get("type") ).to eq("DNSIncomingResponseType" )
+        expect(event.get("socketFamily") ).to eq("INET6" )
+        expect(event.get("socketProtocol") ).to eq("TCP" )
+
+        expect(event.get("question")["qName"] ).to eq(dns_question_data[:qName] )
+        expect(event.get("question")["qType"] ).to eq(dns_question_data[:qType] )
+        expect(event.get("question")["qClass"] ).to eq(dns_question_data[:qClass] )
+
+        ['rcode', 'appliedPolicy','tags','queryTimeSec','queryTimeUsec'].each { |n|   expect(event.get('response')[n]).to eq(dns_response_data[n.to_sym] )   }
+        expect(event.get("response")['appliedPolicyType'] ).to eq("NSIP" )
+
+        dns_rr_data.each_with_index { | data, index |
+          found = event.get("response")['rrs'][index]
+          ['name', 'type','class','ttl','rdata'].each { |n|   expect(found[n]).to eq(data[n.to_sym])   }
+        }
+
+      end
+    end # it
+
+  end # context
+
+  context "#pb3decoder_test5" do
+
+    #### Test case 5: decode test case for github issue 17 ####################################################################################################################
+    let(:plugin_5) { LogStash::Codecs::Protobuf.new("class_name" => "com.foo.bar.IntegerTestMessage", "include_path" => [pb_include_path + '/pb3/integertest_pb.rb'], "protobuf_version" => 3)  }
+
+    before do
+      plugin_5.register
+    end
+
+    it "should return an event from protobuf data with nested classes" do
+      integertest_class = Google::Protobuf::DescriptorPool.generated_pool.lookup("com.foo.bar.IntegerTestMessage").msgclass
+      integertest_object = integertest_class.new({:response_time => 500})
+      bin = integertest_class.encode(integertest_object)
+      plugin_5.decode(bin) do |event|
+        expect(event.get("response_time") ).to eq(500)
+      end
+    end # it
+
+
+  end # context
+
+  context "#pb3decoder_test6" do
+
+
+    let(:execution_context) { double("execution_context")}
+    let(:pipeline_id) {rand(36**8).to_s(36)}
+
+    # Test case 6: decode a message automatically loading the dependencies ##############################################################################
+    let(:plugin) { LogStash::Codecs::Protobuf.new(
+      "class_name" => "A.MessageA",
+      "class_file" => [ 'messageA_pb.rb' ],
+      "protobuf_version" => 3,
+      "protobuf_root_directory" => pb_include_path + '/pb3/')
+    }
+
+    before do
+      allow(plugin).to receive(:execution_context).and_return(execution_context)
+      allow(execution_context).to receive(:pipeline_id).and_return(pipeline_id)
+
+      # this is normally done on the input plugins we "mock" it here to avoid
+      # instantiating a dummy input plugin. See
+      # https://github.com/ph/logstash/blob/37551a89b8137c1dc6fa4fbd992584c363a36065/logstash-core/lib/logstash/inputs/base.rb#L108
+      plugin.execution_context = execution_context
+    end
+
+    it "should return an event from protobuf data" do
+
+      header_class = Google::Protobuf::DescriptorPool.generated_pool.lookup("Header").msgclass
+      header_data = {:name => {'a' => 'b'}}
+      header_object = header_class.new(header_data)
+
+      message_class = Google::Protobuf::DescriptorPool.generated_pool.lookup("A.MessageA").msgclass
+      data = {:name => "Test name", :header => header_object}
+
+      message_object = message_class.new(data)
+      bin = message_class.encode(message_object)
+
+      plugin.decode(bin) do |event|
+        expect(event.get("name") ).to eq(data[:name] )
+        expect(event.get("header")['name'] ).to eq(header_data[:name])
+      end
+    end # it
+  end # context
+
+
+
+
+
+
+  context "#pb3decoder_test7" do
+
+    #### Test case 6: decode test case for github issue 17 ####################################################################################################################
+    let(:plugin_7) { LogStash::Codecs::Protobuf.new("class_name" => "RepeatedEvents", "include_path" => [pb_include_path + '/pb3/events_pb.rb'], "protobuf_version" => 3)  }
+    before do
+        plugin_7.register
+    end
+
+    it "should return an event from protobuf data with repeated top level objects" do
+      event_class = Google::Protobuf::DescriptorPool.generated_pool.lookup("RepeatedEvent").msgclass # TODO this shouldnt be necessary because the classes are already
+      # specified at the end of the _pb.rb files
+      events_class = Google::Protobuf::DescriptorPool.generated_pool.lookup("RepeatedEvents").msgclass
+      test_a = event_class.new({:id => "1", :msg => "a"})
+      test_b = event_class.new({:id => "2", :msg => "b"})
+      test_c = event_class.new({:id => "3", :msg => "c"})
+      event_obj = events_class.new({:repeated_events=>[test_a, test_b, test_c]})
+      bin = events_class.encode(event_obj)
+      plugin_7.decode(bin) do |event|
+        expect(event.get("repeated_events").size ).to eq(3)
+        expect(event.get("repeated_events")[0]["id"] ).to eq("1")
+        expect(event.get("repeated_events")[2]["id"] ).to eq("3")
+        expect(event.get("repeated_events")[0]["msg"] ).to eq("a")
+        expect(event.get("repeated_events")[2]["msg"] ).to eq("c")
+      end
+    end # it
+
+
+  end # context pb3decoder_test7
+
+
+  context "#pb3decoder_test8a" do
+
+    ########################################################################################################################
+    let(:plugin_8a) { LogStash::Codecs::Protobuf.new("class_name" => "FantasyHorse", "class_file" => 'pb3/FantasyHorse_pb.rb',
+      "protobuf_root_directory" => pb_include_path, "protobuf_version" => 3, "pb3_set_oneof_metainfo" => true)  }
+    before do
+        plugin_8a.register
+    end
+
+    it "should add meta information on oneof fields" do
+      pegasus_data = {:wings_length => 100}
+      horsey = FantasyPegasus.new(pegasus_data)
+
+      braid_data = {:braid_thickness => 10, :braiding_style => "french"}
+      tail_data = {:tail_length => 80, :braided => BraidedHorseTail.new(braid_data) }
+      tail = FantasyHorseTail.new(tail_data)
+
+      data = {:name=>"Reinhold", :pegasus => horsey, :tail => tail}
+      pb_obj = FantasyHorse.new(data)
+      bin = FantasyHorse.encode(pb_obj)
+      plugin_8a.decode(bin) do |event|
+
+        expect(event.get("name") ).to eq(data[:name])
+        expect(event.get("pegasus")["wings_length"] ).to eq(pegasus_data[:wings_length])
+        expect(event.get("tail")['tail_length'] ).to eq(tail_data[:tail_length])
+        expect(event.get("tail")['braided']['braiding_style'] ).to eq(braid_data[:braiding_style])
+        expect(event.get("@metadata")["pb_oneof"]["horse_type"] ).to eq("pegasus")
+        expect(event.get("@metadata")["pb_oneof"]["tail"]["hair_type"] ).to eq("braided")
+
+      end
+    end # it
+
+
+  end # context pb3decoder_test8a
+
+
+
+
+  context "#pb3decoder_test8b" do
+
+    ########################################################################################################################
+    let(:plugin_8b) { LogStash::Codecs::Protobuf.new("class_name" => "FantasyHorse", "class_file" => 'pb3/FantasyHorse_pb.rb',
+      "protobuf_root_directory" => pb_include_path, "protobuf_version" => 3, "pb3_set_oneof_metainfo" => false)  }
+    before do
+        plugin_8b.register
+    end
+
+    it "should not add meta information on oneof fields" do
+      pegasus_data = {:wings_length => 100}
+      horsey = FantasyPegasus.new(pegasus_data)
+
+      braid_data = {:braid_thickness => 10, :braiding_style => "french"}
+      tail_data = {:tail_length => 80, :braided => BraidedHorseTail.new(braid_data) }
+      tail = FantasyHorseTail.new(tail_data)
+
+      data = {:name=>"Winfried", :pegasus => horsey, :tail => tail}
+      pb_obj = FantasyHorse.new(data)
+      bin = FantasyHorse.encode(pb_obj)
+      plugin_8b.decode(bin) do |event|
+        expect(event.get("name") ).to eq(data[:name])
+        expect(event.get("pegasus")["wings_length"] ).to eq(pegasus_data[:wings_length])
+        expect(event.get("tail")['tail_length'] ).to eq(tail_data[:tail_length])
+        expect(event.get("tail")['braided']['braiding_style'] ).to eq(braid_data[:braiding_style])
+        expect(event.get("@metadata")["pb_oneof"]).to be_nil
+
+      end
+    end # it
+
+
+  end # context pb3decoder_test8b
+
+
+  context "#pb3decoder_test8c" do # same test as 8a just with different one_of options selected
+
+    ########################################################################################################################
+    let(:plugin_8c) { LogStash::Codecs::Protobuf.new("class_name" => "FantasyHorse", "class_file" => 'pb3/FantasyHorse_pb.rb',
+      "protobuf_root_directory" => pb_include_path, "protobuf_version" => 3, "pb3_set_oneof_metainfo" => true)  }
+    before do
+        plugin_8c.register
+    end
+
+    it "should add meta information on oneof fields" do
+      unicorn_data = {:horn_length => 30}
+      horsey = FantasyUnicorn.new(unicorn_data)
+
+      natural_data = {:wavyness => "B"}
+      tail_data = {:tail_length => 80, :natural => NaturalHorseTail.new(natural_data) }
+      tail = FantasyHorseTail.new(tail_data)
+
+      data = {:name=>"Hubert", :unicorn => horsey, :tail => tail}
+      pb_obj = FantasyHorse.new(data)
+      bin = FantasyHorse.encode(pb_obj)
+      plugin_8c.decode(bin) do |event|
+        expect(event.get("name") ).to eq(data[:name])
+        expect(event.get("unicorn")["horn_length"] ).to eq(unicorn_data[:horn_length])
+        expect(event.get("tail")['tail_length'] ).to eq(tail_data[:tail_length])
+        expect(event.get("tail")['natural']['wavyness'] ).to eq(natural_data[:wavyness])
+        expect(event.get("@metadata")["pb_oneof"]["horse_type"] ).to eq("unicorn")
+        expect(event.get("@metadata")["pb_oneof"]["tail"]["hair_type"] ).to eq("natural")
+
+      end
+    end # it
+
+
+  end # context pb3decoder_test8c
+
+end # describe