logstash-core-event 2.2.4.snapshot1

data/spec/logstash/timestamp_spec.rb

@@ -0,0 +1,109 @@
+# encoding: utf-8
+require "spec_helper"
+require "logstash/timestamp"
+
+describe LogStash::Timestamp do
+
+  it "should parse its own iso8601 output" do
+    t = Time.now
+    ts = LogStash::Timestamp.new(t)
+    expect(LogStash::Timestamp.parse_iso8601(ts.to_iso8601).to_i).to eq(t.to_i)
+  end
+
+  it "should coerce iso8601 string" do
+    t = Time.now
+    ts = LogStash::Timestamp.new(t)
+    expect(LogStash::Timestamp.coerce(ts.to_iso8601).to_i).to eq(t.to_i)
+  end
+
+  it "should coerce Time" do
+    t = Time.now
+    expect(LogStash::Timestamp.coerce(t).to_i).to eq(t.to_i)
+  end
+
+  it "should coerce Timestamp" do
+    t = LogStash::Timestamp.now
+    expect(LogStash::Timestamp.coerce(t).to_i).to eq(t.to_i)
+  end
+
+  it "should raise on invalid string coerce" do
+    expect{LogStash::Timestamp.coerce("foobar")}.to raise_error LogStash::TimestampParserError
+  end
+
+  it "should return nil on invalid object coerce" do
+    expect(LogStash::Timestamp.coerce(:foobar)).to be_nil
+  end
+
+  it "should support to_json" do
+    expect(LogStash::Timestamp.parse_iso8601("2014-09-23T00:00:00-0800").to_json).to eq("\"2014-09-23T08:00:00.000Z\"")
+  end
+
+  it "should support to_json and ignore arguments" do
+    expect(LogStash::Timestamp.parse_iso8601("2014-09-23T00:00:00-0800").to_json(:some => 1, :argumnents => "test")).to eq("\"2014-09-23T08:00:00.000Z\"")
+  end
+
+  it "should support timestamp comparaison" do
+   current = LogStash::Timestamp.new(Time.now) 
+   future = LogStash::Timestamp.new(Time.now + 100)
+
+   expect(future > current).to eq(true)
+   expect(future < current).to eq(false)
+   expect(current == current).to eq(true)
+
+   expect(current <=> current).to eq(0)
+   expect(current <=> future).to eq(-1)
+   expect(future <=> current).to eq(1)
+  end
+
+  it "should allow unary operation +" do
+    current = Time.now
+    t = LogStash::Timestamp.new(current) + 10
+    expect(t).to eq(current + 10)
+  end
+
+  describe "subtraction" do
+    it "should work on a timestamp object" do
+      t = Time.now
+      current = LogStash::Timestamp.new(t)
+      future = LogStash::Timestamp.new(t + 10)
+      expect(future - current).to eq(10)
+    end
+
+    it "should work on with time object" do
+      current = Time.now
+      t = LogStash::Timestamp.new(current + 10)
+      expect(t - current).to eq(10)
+    end
+
+    it "should work with numeric value" do
+      current = Time.now
+      t = LogStash::Timestamp.new(current + 10)
+      expect(t - 10).to eq(current)
+    end
+  end
+
+  context "identity methods" do
+    subject { LogStash::Timestamp.new }
+
+    it "should support utc" do
+      expect(subject.utc).to eq(subject)
+    end
+
+    it "should support gmtime" do
+      expect(subject.gmtime).to eq(subject)
+    end
+  end
+
+  context "numeric casting methods" do
+    let (:now) {Time.now}
+    subject { LogStash::Timestamp.new(now) }
+
+    it "should support to_i" do
+      expect(subject.to_i).to eq(now.to_i)
+    end
+
+    it "should support to_f" do
+      expect(subject.to_f).to eq(now.to_f)
+    end
+  end
+end

data/spec/logstash/util/accessors_spec.rb

@@ -0,0 +1,179 @@
+# encoding: utf-8
+require "spec_helper"
+
+# this is to skip specs when running agains an alternate logstash-core-event implementation
+# that does not define the Accessors class. For example, in logstash-core-event-java
+# the Accessors class does not exists in the Ruby namespace.
+class_exists = begin
+  require "logstash/util/accessors"
+  true
+rescue LoadError
+  false
+end
+
+describe "LogStash::Util::Accessors", :if => class_exists do
+
+  context "using simple field" do
+
+    it "should get value of word key" do
+      str = "hello"
+      data = { "hello" => "world" }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.get(str)).to eq(data[str])
+    end
+
+    it "should get value of key with spaces" do
+      str = "hel lo"
+      data = { "hel lo" => "world" }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.get(str)).to eq(data[str])
+    end
+
+    it "should get value of numeric key string" do
+      str = "1"
+      data = { "1" => "world" }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.get(str)).to eq(data[str])
+    end
+
+    it "should handle delete" do
+      str = "simple"
+      data = { "simple" => "things" }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.del(str)).to eq("things")
+      expect(data).to be_empty
+    end
+
+    it "should handle delete on non-existent field" do
+      str = "[foo][bar]"
+      data = { "hello" => "world" }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.del(str)).to be_nil
+      expect(data).not_to be_empty
+      # assert no side effects
+      expect(accessors.get("foo")).to be_nil
+      expect(accessors.get("hello")).to eq("world")
+    end
+
+    it "should set string value" do
+      str = "simple"
+      data = {}
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.set(str, "things")).to eq("things")
+      expect(data).to eq({ "simple" => "things" })
+    end
+
+    it "should set array value" do
+      str = "simple"
+      data = {}
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.set(str, ["foo", "bar"])).to eq(["foo", "bar"])
+      expect(data).to eq({ "simple" => ["foo", "bar"]})
+    end
+  end
+
+  context "using field path" do
+
+    it "should get shallow string value of word key" do
+      str = "[hello]"
+      data = { "hello" =>  "world" }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.get(str)).to eq("world")
+    end
+
+    it "should get shallow string value of key with spaces" do
+      str = "[hel lo]"
+      data = { "hel lo" =>  "world" }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.get(str)).to eq("world")
+    end
+
+    it "should get shallow string value of numeric key string" do
+      str = "[1]"
+      data = { "1" =>  "world" }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.get(str)).to eq("world")
+    end
+
+    it "should get deep string value" do
+      str = "[hello][world]"
+      data = { "hello" => { "world" => "foo", "bar" => "baz" } }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.get(str)).to eq(data["hello"]["world"])
+    end
+
+    it "should return nil when getting a non-existant field (with no side-effects on original data)" do
+      str = "[hello][world]"
+      data = {}
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.get(str)).to be_nil
+      expect(data).to  be_empty
+      expect(accessors.set(str, "foo")).to eq("foo")
+      expect(data).to eq({ "hello" => {"world" => "foo"} })
+    end
+
+    it "should handle delete" do
+      str = "[hello][world]"
+      data = { "hello" => { "world" => "foo", "bar" => "baz" } }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.del(str)).to eq("foo")
+
+      # Make sure the "world" key is removed.
+      expect(data["hello"]).to eq({ "bar" => "baz" })
+    end
+
+    it "should set shallow string value" do
+      str = "[hello]"
+      data = {}
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.set(str, "foo")).to eq("foo")
+      expect(data).to eq({ "hello" => "foo" })
+    end
+
+    it "should set deep string value" do
+      str = "[hello][world]"
+      data = {}
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.set(str, "foo")).to eq("foo")
+      expect(data).to eq({ "hello" => { "world" => "foo" } })
+    end
+
+    it "should set deep array value" do
+      str = "[hello][world]"
+      data = {}
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.set(str, ["foo", "bar"])).to eq(["foo", "bar"])
+      expect(data).to eq({ "hello" => { "world" => ["foo", "bar"] } })
+    end
+
+    it "should set element within array value" do
+      str = "[hello][0]"
+      data = {"hello" => ["foo", "bar"]}
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.set(str, "world") ).to eq("world")
+      expect(data).to eq({"hello" => ["world", "bar"]})
+    end
+
+    it "should retrieve array item" do
+      data = { "hello" => { "world" => ["a", "b"], "bar" => "baz" } }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.get("[hello][world][0]")).to eq(data["hello"]["world"][0])
+      expect(accessors.get("[hello][world][1]")).to eq(data["hello"]["world"][1])
+    end
+
+    it "should retrieve array item containing hash" do
+      data = { "hello" => { "world" => [ { "a" => 123 }, { "b" => 345 } ], "bar" => "baz" } }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.get("[hello][world][0][a]")).to eq(data["hello"]["world"][0]["a"])
+      expect(accessors.get("[hello][world][1][b]")).to eq(data["hello"]["world"][1]["b"])
+    end
+
+    it "should handle delete of array element" do
+      str = "[geocoords][0]"
+      data = { "geocoords" => [4, 2] }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.del(str)).to eq(4)
+      expect(data).to eq({ "geocoords" => [2] })
+    end
+  end
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: logstash-core-event
+version: !ruby/object:Gem::Version
+  version: 2.2.4.snapshot1
+platform: ruby
+authors:
+- Elastic
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-04-06 00:00:00.000000000 Z
+dependencies: []
+description: The core event component of logstash, the scalable log and event management
+  tool
+email:
+- info@elastic.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/logstash-core-event.rb
+- lib/logstash-core-event/logstash-core-event.rb
+- lib/logstash-core-event/version.rb
+- lib/logstash/event.rb
+- lib/logstash/string_interpolation.rb
+- lib/logstash/timestamp.rb
+- lib/logstash/util/accessors.rb
+- logstash-core-event.gemspec
+- spec/logstash/event_spec.rb
+- spec/logstash/timestamp_spec.rb
+- spec/logstash/util/accessors_spec.rb
+homepage: http://www.elastic.co/guide/en/logstash/current/index.html
+licenses:
+- Apache License (2.0)
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: logstash-core-event - The core event component of logstash
+test_files:
+- spec/logstash/event_spec.rb
+- spec/logstash/timestamp_spec.rb
+- spec/logstash/util/accessors_spec.rb