splunk-sdk-ruby 0.1.0 → 0.8.1

data/test/test_atomfeed.rb

@@ -1,6 +1,8 @@
 require_relative "test_helper"
 require "splunk-sdk-ruby"
 
+require 'json'
+
 include Splunk
 
 # URI's classes compare by object identity, which is exactly what we
@@ -37,33 +39,42 @@ class TestAtomFeed < Test::Unit::TestCase
     puts "Nokogiri not installed. Skipping."
   end
 
-  test_cases = eval(open("test/atom_test_data.rb").read())
+  test_cases = JSON::parse(open("test/data/atom_test_data.json").read())
 
   xml_libraries.each do |xml_library|
     test_cases.each_entry do |filename, expected|
       define_method("test_#{xml_library}_#{filename}".intern()) do
         file = File.open("test/data/atom/#{filename}.xml")
+        Splunk::require_xml_library(xml_library)
         feed = Splunk::AtomFeed.new(file)
 
+        # In the assert statements below, the output of the code is first,
+        # the expected data second, which is breaking convention, but has
+        # to be this way since we need to match URLs which are URI objects
+        # in the output of the code to URLs which are strings in the expected
+        # data from the JSON file. URI has been patched to make this
+        # work...but only if the == method is called on the URI object,
+        # not the string. == is not commutative.
+
         # To make debugging easy, test the metadata a key at
         # a time, since Test::Unit doesn't display diffs.
         # Then test the whole thing at the end to make sure it all matches.
-        expected[:metadata].each_entry do |key, value|
-          assert_equal([filename, key, value],
-                       [filename, key, feed.metadata[key]])
+        expected["metadata"].each_entry do |key, value|
+          assert_equal([filename, key, feed.metadata[key]],
+                       [filename, key, value])
         end
-        assert_equal(expected[:metadata], feed.metadata)
+        assert_equal(feed.metadata, expected["metadata"])
 
         # To make debugging easy, test each key of each entry
         # separately, since Test::Unit doesn't display diffs.
         # Then test the whole thing at the end to make sure it all matches.
-        expected[:entries].each_with_index do |entry, index|
+        expected["entries"].each_with_index do |entry, index|
           entry.each_entry do |key, value|
-            assert_equal([filename, index, key, value],
-                         [filename, index, key, feed.entries[index][key]])
+            assert_equal([filename, index, key, feed.entries[index][key]],
+                         [filename, index, key, value])
           end
         end
-        assert_equal(expected[:entries], feed.entries)
+        assert_equal(feed.entries, expected["entries"])
       end
     end
   end

data/test/test_configuration_file.rb

@@ -68,6 +68,28 @@ class ConfigurationFileTestCase < TestCaseWithSplunkConnection
     assert_equal(created_conf.name, bracket_fetched_conf.name)
   end
 
+  ##
+  # Check that fetching nonexistent configuration files returns nil.
+  #
+  def test_fetch_nonexistent
+    nonexistent_name = temporary_name()
+
+    assert_nil(@confs[nonexistent_name])
+    assert_nil(@confs.fetch(nonexistent_name))
+  end
+
+  ##
+  # Check that server errors during fetch are encapsulated sensibly.
+  #
+  def test_error_from_fetch
+    new_service = Splunk::Service.new(@splunkrc)
+    new_confs = new_service.confs()
+    new_service.logout()
+    assert_raise(SplunkHTTPError) do
+      new_confs[temporary_name()]
+    end
+  end
+
   def test_each_and_values
     each_names = []
     @confs.each() { |entity| each_names << entity.name }

data/test/test_context.rb

@@ -97,7 +97,7 @@ class TestContext < TestCaseWithSplunkConnection
 
   def test_server_accepting_connections?
     values = @splunkrc.clone()
-    values[:port] = 10253
+    values[:port] = 8000
     service = Context.new(values)
     assert_false(service.server_accepting_connections?)
 

data/test/test_helper.rb

@@ -79,14 +79,24 @@ class TestCaseWithSplunkConnection < Test::Unit::TestCase
       fail("Test left server in a state requiring restart.")
     end
 
+    # Are we on Windows or Unix? We need this below.
+    splunk_home = @service.settings["SPLUNK_HOME"]
+    is_windows = splunk_home.include?("\\") == true
+
     if @service.splunk_version[0..1] != [4,2]
       @installed_apps.each() do |app_name|
-        @service.apps.delete(app_name)
-        assert_eventually_true() do
-          !@service.apps.has_key?(app_name)
-        end
-        if @service.server_requires_restart?
-          clear_restart_message(@service)
+        # There is a bug in Python on Windows which results in the
+        # sleep_command not deleting properly because there are still
+        # hung jobs that haven't terminated when we reach this point.
+        # We skip deleting the sleep_command app on Windows.
+        if app_name != 'sleep_command' or !is_windows
+          @service.apps.delete(app_name)
+          assert_eventually_true() do
+            !@service.apps.has_key?(app_name)
+          end
+          if @service.server_requires_restart?
+            clear_restart_message(@service)
+          end
         end
       end
     end
@@ -113,13 +123,15 @@ class TestCaseWithSplunkConnection < Test::Unit::TestCase
   end
 
   def assert_not_logged_in(service)
-    begin
-      service.request(:method=>:GET,
-                      :resource=>["data", "indexes"])
-    rescue SplunkHTTPError => err
-      assert_equal(401, err.code, "Expected HTTP status code 401, found: #{err.code}")
-    else
-      fail("Context is logged in.")
+    if service.server_accepting_connections?
+      begin
+        service.request(:method=>:GET,
+                        :resource=>["data", "indexes"])
+      rescue SplunkHTTPError => err
+        assert_equal(401, err.code, "Expected HTTP status code 401, found: #{err.code}")
+      else
+        fail("Context is logged in.")
+      end
     end
   end
 
@@ -143,7 +155,7 @@ class TestCaseWithSplunkConnection < Test::Unit::TestCase
     end
   end
 
-  def has_app_collection?(service)
+  def has_test_data?(service)
     collection_name = 'sdk-app-collection'
     return service.apps.has_key?(collection_name)
   end
@@ -247,4 +259,4 @@ class TestCaseWithSplunkConnection < Test::Unit::TestCase
   def unchecked_restart(service)
     service.restart(DEFAULT_RESTART_TIMEOUT)
   end
-end
+end

data/test/test_index.rb

@@ -74,9 +74,8 @@ class IndexTestCase < TestCaseWithSplunkConnection
   end
 
   def test_upload
-    if !has_app_collection?(@service)
-        print "Test requires sdk-app-collection. Skipping."
-        return
+    if not has_test_data?(@service)
+        fail("Install the SDK test data to test uploads.")
     end
 
     install_app_from_collection("file_to_upload")

data/test/test_inputs.rb

@@ -0,0 +1,211 @@
+require_relative 'test_helper'
+require 'splunk-sdk-ruby'
+
+include Splunk
+
+class InputsTest < TestCaseWithSplunkConnection
+  def setup
+    super
+    @ports_to_delete = []
+  end
+
+  def teardown
+    @ports_to_delete.each do |spec|
+      resource, name = spec
+      inputs = @service.inputs
+      resource.each do |r|
+        inputs = inputs[r]
+      end
+      if inputs.has_key?(name)
+        inputs.delete(name)
+      end
+      assert !inputs.has_key?(name)
+    end
+  end
+
+  def get_free_port(input_collection)
+    port_names = input_collection.map() {|ent| ent.name}
+    proper_port_names = port_names.select() {|name| name != nil}
+    ports = proper_port_names.map() do |name|
+      if name.include?(":")
+        name.split(":")[1]
+      else
+        name
+      end
+    end
+    highest_existing_port = ports.map() {|p| Integer(p)}.max()
+
+    if highest_existing_port == nil
+      port = "10000"
+    else
+      port = (highest_existing_port + 1).to_s()
+    end
+  end
+
+  def test_create_and_delete_tcp_raw
+    tcp_inputs = @service.inputs["tcp"]["raw"]
+    all_inputs = @service.inputs["all"]
+
+    port = get_free_port(tcp_inputs)
+    @ports_to_delete << [["tcp", "raw"], port]
+
+    input = tcp_inputs.create(port)
+    assert_equal(port, input.name)
+    assert_true(tcp_inputs.has_key?(port))
+    if @service.splunk_version[0] >= 5
+      assert_true(all_inputs.has_key?(port))
+    end
+
+    tcp_inputs.delete(port)
+    assert_false(tcp_inputs.has_key?(port))
+    if @service.splunk_version[0] >= 5
+      assert_false(all_inputs.has_key?(port))
+    end
+  end
+
+  ##
+  # Check that fetching with namespaces provided works.
+  #
+  def test_fetch_with_namespaces
+    user_ns = Splunk::namespace(
+        :sharing => "user",
+        :app => "search",
+        :owner => @splunkrc[:username]
+    )
+    begin
+      user_udp_inputs = @service.inputs.fetch("udp", namespace=user_ns)
+      port = get_free_port(user_udp_inputs)
+      user_udp_inputs.create(port.to_s, :namespace => user_ns)
+      user_udp_inputs.fetch(port.to_s, namespace=user_ns)
+    ensure
+      @service.inputs.fetch("udp", namespace=user_ns).delete(port.to_s)
+    end
+  end
+
+  ##
+  # Check that fetching a nonexistent input kind returns nil.
+  #
+  def test_fetch_nonexistent_input_kind
+    assert_nil(@service.inputs[temporary_name()])
+  end
+
+  ##
+  # Test that fetch resulting in server error raises SplunkHTTPError.
+  def test_fetch_with_server_error
+    new_service = Splunk::Service.new(@splunkrc)
+    new_inputs = new_service.inputs()
+    new_service.logout()
+    assert_raise(SplunkHTTPError) do
+      new_inputs["tcp"]
+    end
+  end
+
+  def test_create_and_delete_tcp_raw_with_restrictToHost
+    tcp_inputs = @service.inputs["tcp"]["raw"]
+
+    port = get_free_port(tcp_inputs)
+    name = "localhost:" + port
+    @ports_to_delete << [["tcp", "raw"], name]
+
+    input = tcp_inputs.create(port, :restrictToHost => "localhost")
+    assert_equal(name, input.name)
+    assert_equal("localhost", input["restrictToHost"])
+    assert_true(tcp_inputs.has_key?(name))
+    assert_false(tcp_inputs.has_key?(port))
+
+    if @service.splunk_version[0] >= 5
+      all_inputs = @service.inputs["all"]
+      assert_true(all_inputs.has_key?(name))
+      assert_false(all_inputs.has_key?(port))
+
+    end
+
+    tcp_inputs.delete(name)
+
+    assert_false(tcp_inputs.has_key?(name))
+    if @service.splunk_version[0] >= 5
+      assert_false(all_inputs.has_key?(name))
+    end
+  end
+
+  def test_update_on_restrictToHost_does_not_clear
+    tcp_inputs = @service.inputs["tcp"]["raw"]
+
+    port = get_free_port(tcp_inputs)
+    name = "localhost:" + port
+    @ports_to_delete << [["tcp", "raw"], name]
+
+    input = tcp_inputs.create(port, :restrictToHost => "localhost")
+
+    input.update({:sourcetype => "boris"})
+    input.refresh()
+    assert_equal("localhost", input["restrictToHost"])
+    assert_true(tcp_inputs.has_key?(name))
+
+    if @service.splunk_version[0] >= 5
+      all_inputs = @service.inputs["all"]
+      assert_true(all_inputs.has_key?(name))
+    end
+  end
+
+  def test_create_and_delete_udp
+    udp_inputs = @service.inputs["udp"]
+
+    port = get_free_port(udp_inputs)
+    @ports_to_delete << [["udp"], port]
+
+    input = udp_inputs.create(port)
+    assert_equal(port, input.name)
+    assert_true(udp_inputs.has_key?(port))
+
+    if @service.splunk_version[0] >= 5
+      all_inputs = @service.inputs["all"]
+      assert_true(all_inputs.has_key?(port))
+    end
+
+    udp_inputs.delete(port)
+    assert_false(udp_inputs.has_key?(port))
+
+    if @service.splunk_version[0] >= 5
+      assert_false(all_inputs.has_key?(port))
+    end
+  end
+
+  def test_oneshot_input
+    if not has_test_data?(@service)
+      fail("Install the SDK test data to test oneshot inputs.")
+      return
+    end
+
+    install_app_from_collection("file_to_upload")
+
+    index_name = temporary_name()
+    index = @service.indexes.create(index_name)
+    begin
+      assert_eventually_true do
+        index.refresh()
+        index["disabled"] == "0"
+      end
+
+      event_count = Integer(index['totalEventCount'])
+      path = path_in_app("file_to_upload", ["log.txt"])
+      @service.inputs["oneshot"].create(path, :index => index_name)
+
+      assert_eventually_true do
+        index.refresh()
+        Integer(index['totalEventCount']) == event_count + 4
+      end
+    ensure
+      if @service.splunk_version[0] >= 5
+        index.delete()
+      end
+    end
+  end
+
+  def test_oneshot_on_nonexistant_file
+    name = temporary_name()
+    assert_raises(Splunk::SplunkHTTPError) do
+      @service.inputs["oneshot"].create(name)
+    end
+  end
+end

data/test/test_jobs.rb

@@ -27,9 +27,9 @@ class JobsTestCase < TestCaseWithSplunkConnection
   # There is a convenience method on service to create an asynchronous
   # search job. Test it the same way.
   #
-  def service_create_and_idempotent_cancel
+  def test_service_create_and_idempotent_cancel
     jobs = @service.jobs
-    job = @service.create(QUERY)
+    job = @service.create_search(QUERY)
     assert_true(jobs.has_key?(job.sid))
     job.cancel()
     assert_eventually_true() { !jobs.has_key?(job.sid) }
@@ -102,6 +102,77 @@ class JobsTestCase < TestCaseWithSplunkConnection
     assert_true(3 >= results.length())
   end
 
+  ##
+  # Test that oneshot jobs have no <sg> elements in the XML they return
+  # by default.
+  #
+  def test_oneshot_has_no_segmentation_by_default
+    omit_if(@service.splunk_version[0] == 4)
+    stream = @service.create_oneshot("search index=_internal GET | head 3")
+    assert_false(stream.include?("<sg"))
+  end
+
+  ##
+  # Are <sg> elements returned in the XML from a oneshot job when we pass
+  # the option segmentation=raw?
+  #
+  def test_oneshot_has_forced_segmentation
+    omit_if(@service.splunk_version[0] == 4)
+    stream = @service.create_oneshot("search index=_internal GET | head 3",
+                                     :segmentation => "raw")
+    assert_true(stream.include?("<sg"))
+  end
+
+  ##
+  # Test that export jobs have no <sg> elements in the XML they return by
+  # default.
+  #
+  def test_export_has_no_segmentation_by_default
+    omit_if(@service.splunk_version[0] == 4)
+    stream = @service.create_export("search index=_internal GET | head 3")
+    assert_false(stream.include?("<sg"))
+  end
+
+  ##
+  # Export jobs should have <sg> elements in the XML they return when a
+  # value is passed to the segmentation argument to make it so.
+  #
+  def test_export_has_forced_segmentation
+    omit_if(@service.splunk_version[0] == 4)
+
+    stream = @service.create_export("search index=_internal GET | head 3",
+                                     :segmentation => "raw")
+    assert_true(stream.include?("<sg"))
+  end
+
+  ##
+  # Results and preview on a search job should have no segmentation
+  # by default.
+  #
+  def test_asynchronous_job_has_no_segmentation_by_default
+    omit_if(@service.splunk_version[0] == 4)
+    job = @service.jobs.create("search index=_internal GET | head 3")
+    until job.is_done?()
+      sleep(0.1)
+    end
+    assert_false(job.events().include?("<sg"))
+    assert_false(job.preview().include?("<sg"))
+  end
+
+  ##
+  # Results and preview on a search job should have segmentation when
+  # it is forced.
+  #
+  def test_asynchronous_job_has_segmentation_when_forced
+    omit_if(@service.splunk_version[0] == 4)
+    job = @service.jobs.create("search index=_internal GET | head 3")
+    until job.is_done?()
+      sleep(0.1)
+    end
+    assert_true(job.events(:segmentation => "raw").include?("<sg"))
+    assert_true(job.preview(:segmentation => "raw").include?("<sg"))
+  end
+
   def test_each_and_values
     jobs = Jobs.new(@service)