splunk-sdk-ruby 0.1.0

data/test/test_messages.rb

@@ -0,0 +1,17 @@
+require_relative 'test_helper'
+require 'splunk-sdk-ruby'
+
+include Splunk
+
+class MessagesTestCase < TestCaseWithSplunkConnection
+  def test_message
+    messages = @service.messages
+    messages.create("sdk_message", :value => "Moose on the roof")
+    assert_true(messages.has_key?("sdk_message"))
+    message = messages.fetch("sdk_message")
+    assert_equal("sdk_message", message.name)
+    assert_equal("Moose on the roof", message.value)
+    messages.delete("sdk_message")
+    assert_false(messages.has_key?("sdk_message"))
+  end
+end

data/test/test_namespace.rb

@@ -0,0 +1,188 @@
+require_relative 'test_helper'
+require 'splunk-sdk-ruby/namespace'
+
+include Splunk
+
+class TestNamespaces < Test::Unit::TestCase
+  def test_incorrect_constructors
+    assert_raises(ArgumentError) { Splunk::namespace(:sharing => "boris") }
+    assert_raises(ArgumentError) { Splunk::namespace(:sharing => "app") }
+    assert_raises(ArgumentError) { Splunk::namespace(:sharing => "user") }
+    assert_raises(ArgumentError) { Splunk::namespace(:sharing => "user",
+                                                     :app => "search") }
+    assert_raises(ArgumentError) { Splunk::namespace() }
+  end
+
+  def test_equality
+    assert_equal(Splunk::namespace(:sharing => "global"),
+                 Splunk::namespace(:sharing => "global"))
+    assert_equal(Splunk::namespace(:sharing => "system"),
+                 Splunk::namespace(:sharing => "system"))
+    assert_equal(Splunk::namespace(:sharing => "default"),
+                 Splunk::namespace(:sharing => "default"))
+    assert_equal(Splunk::namespace(:sharing => "user",
+                                   :app => "search",
+                                   :owner => "boris"),
+                 Splunk::namespace(:sharing => "user",
+                                   :app => "search",
+                                   :owner => "boris"))
+    assert_equal(Splunk::namespace(:sharing => "app",
+                                   :app => "search"),
+                 Splunk::namespace(:sharing => "app",
+                                   :app => "search"))
+  end
+
+  def test_inequality
+    assert_not_equal(Splunk::namespace(:sharing => "global"),
+                     Splunk::namespace(:sharing => "system"))
+    assert_not_equal(Splunk::namespace(:sharing => "app", :app => "search"),
+                     Splunk::namespace(:sharing => "app", :app => "gettingstarted"))
+    assert_not_equal(Splunk::namespace(:sharing => "user",
+                                       :app => "search",
+                                       :owner => "boris"),
+                     Splunk::namespace(:sharing => "app",
+                                       :app => "search"))
+    assert_not_equal(Splunk::namespace(:sharing => "default"),
+                     Splunk::namespace(:sharing => "system"))
+    assert_not_equal(Splunk::namespace(:sharing => "user",
+                                       :app => "search",
+                                       :owner => "boris"),
+                     Splunk::namespace(:sharing => "user",
+                                       :app => "search",
+                                       :owner => "hilda"))
+  end
+
+  def test_types
+    assert_true(Splunk::namespace(:sharing => "global").is_a?(GlobalNamespace))
+    assert_true(Splunk::namespace(:sharing => "global").is_a?(Namespace))
+
+    assert_true(Splunk::namespace(:sharing => "system").is_a?(SystemNamespace))
+    assert_true(Splunk::namespace(:sharing => "system").is_a?(Namespace))
+
+    assert_true(Splunk::namespace(:sharing => "app",
+                                  :app => "search").is_a?(AppNamespace))
+    assert_true(Splunk::namespace(:sharing => "app",
+                                  :app => "search").is_a?(Namespace))
+
+    assert_true(Splunk::namespace(:sharing => "app",
+                                  :app => "").is_a?(AppReferenceNamespace))
+    assert_true(Splunk::namespace(:sharing => "app",
+                                  :app => "").is_a?(Namespace))
+
+    assert_true(Splunk::namespace(:sharing => "user",
+                                  :app => "search",
+                                  :owner => "boris").is_a?(UserNamespace))
+    assert_true(Splunk::namespace(:sharing => "user",
+                                  :app => "search",
+                                  :owner => "boris").is_a?(Namespace))
+
+    assert_true(Splunk::namespace(:sharing => "default").is_a?(DefaultNamespace))
+    assert_true(Splunk::namespace(:sharing => "default").is_a?(Namespace))
+  end
+
+  def test_throws_without_enough_information
+    assert_raise ArgumentError do
+      Splunk::namespace(:sharing => "user")
+    end
+
+    assert_raise ArgumentError do
+      Splunk::namespace(:sharing => "user", :app => "boris")
+    end
+
+    assert_raise ArgumentError do
+      Splunk::namespace(:sharing => "app")
+    end
+  end
+
+  def test_propriety
+    assert_true(Splunk::namespace(:sharing => "global").is_exact?)
+    assert_true(Splunk::namespace(:sharing => "system").is_exact?)
+    assert_true(Splunk::namespace(:sharing => "default").is_exact?)
+    assert_true(Splunk::namespace(:sharing => "app", :app => "search").is_exact?)
+    assert_false(Splunk::namespace(:sharing => "app", :app => "-").is_exact?)
+    assert_true(Splunk::namespace(:sharing => "app", :app => "").is_exact?)
+    assert_true(Splunk::namespace(:sharing => "user", :app => "search",
+                                  :owner => "boris").is_exact?)
+    assert_false(Splunk::namespace(:sharing => "user", :app => "-",
+                                   :owner => "boris").is_exact?)
+    assert_false(Splunk::namespace(:sharing => "user", :app => "search",
+                                   :owner => "-").is_exact?)
+    assert_false(Splunk::namespace(:sharing => "user", :app => "-",
+                                   :owner => "-").is_exact?)
+  end
+
+  def test_path_segments
+    assert_equal(["services"], Splunk::namespace(:sharing => "default").to_path_fragment())
+    assert_equal(["servicesNS", "nobody", "system"],
+                 Splunk::namespace(:sharing => "global").to_path_fragment)
+    assert_equal(["servicesNS", "nobody", "system"],
+                 Splunk::namespace(:sharing => "system").to_path_fragment)
+    assert_equal(["servicesNS", "nobody", "search"],
+                 Splunk::namespace(:sharing => "app", :app => "search").to_path_fragment)
+    assert_equal(["servicesNS", "nobody", "-"],
+                 Splunk::namespace(:sharing => "app", :app => "-").to_path_fragment)
+    assert_equal(["services"], Splunk::namespace(:sharing => "app",
+                                                 :app => "").to_path_fragment)
+    assert_equal(["servicesNS", "boris", "search"],
+                 Splunk::namespace(:sharing => "user",
+                                   :app => "search",
+                                   :owner => "boris").to_path_fragment)
+  end
+
+  def test_eai_acl_to_namespace
+    data = {
+        Splunk::namespace(:sharing => "app", :app => "system") => {
+            "app" => "system",
+            "can_change_perms" => "1",
+            "can_list" => "1",
+            "can_share_app" => "1",
+            "can_share_global" => "1",
+            "can_share_user" => "0",
+            "can_write" => "1",
+            "modifiable" => "1",
+            "owner" => "nobody",
+            "perms" => {
+                "read" => ["*"],
+                "write" => ["power"]
+            },
+            "removable" => "0",
+            "sharing" => "app"
+        },
+        Splunk::namespace(:sharing => "global") => {
+            "perms" => {
+                "read" => ["admin"],
+                "write" => ["admin"],
+            },
+            "owner" => "admin",
+            "modifiable" => "1",
+            "sharing" => "global",
+            "app" => "search",
+            "can_write" => "1"
+        },
+        Splunk::namespace(:sharing => "app", :app => "") => {
+            "app" => "",
+            "can_change_perms" => "1",
+            "can_list" => "1",
+            "can_share_app" => "1",
+            "can_share_global" => "1",
+            "can_share_user" => "0",
+            "can_write" => "1",
+            "modifiable" => "1",
+            "owner" => "system",
+            "perms" => {
+                "read" => ["*"],
+                "write" => ["power"]
+            },
+            "removable" => "0",
+            "sharing" => "app",
+        }
+    }
+    data.each_entry do |expected_namespace, eai_acl|
+      found_namespace = Splunk::eai_acl_to_namespace(eai_acl)
+      assert_equal(expected_namespace, found_namespace)
+    end
+  end
+end
+
+
+

data/test/test_restarts.rb

@@ -0,0 +1,49 @@
+require_relative "test_helper"
+require "splunk-sdk-ruby"
+
+include Splunk
+
+class TestRestarts < TestCaseWithSplunkConnection
+  def test_restart_with_long_timeout
+    service = Context.new(@splunkrc).login()
+    begin
+      service.restart(2000)
+    rescue TimeoutError
+      while !service.server_accepting_connections? ||
+          service.server_requires_restart?
+        sleep(0.3)
+      end
+    end
+
+    assert_logged_in(service)
+  end
+
+  def test_restart_with_short_timeout
+    service = Context.new(@splunkrc).login()
+    begin
+      service.restart(0.1)
+    rescue TimeoutError
+      # Wait for it to come back up
+      while !service.server_accepting_connections? ||
+          service.server_requires_restart?
+        sleep(0.3)
+      end
+      assert_logged_in(service)
+    else
+      fail("Somehow Splunk managed to restart in 100ms...")
+    end
+  end
+
+  def test_restart_with_no_timeout
+    service = Context.new(@splunkrc).login()
+    service.restart()
+    assert_not_logged_in(service)
+
+    # Wait for it to come back up
+    while !service.server_accepting_connections? ||
+        service.server_requires_restart?
+      sleep(0.3)
+    end
+    assert_logged_in(service)
+  end
+end

data/test/test_resultsreader.rb

@@ -0,0 +1,106 @@
+require_relative 'test_helper'
+require 'splunk-sdk-ruby'
+require 'json'
+
+include Splunk
+
+class TestResultsReader < Test::Unit::TestCase
+  if nokogiri_available?
+    xml_libraries = [:nokogiri, :rexml]
+  else
+    xml_libraries = [:rexml]
+    puts "Nokogiri not installed. Skipping."
+  end
+
+  def assert_results_reader_equals(expected, reader)
+    assert_equal(expected["is_preview"], reader.is_preview?)
+    assert_equal(expected["fields"], reader.fields)
+
+    n_results = 0
+    reader.each_with_index do |result, index|
+      n_results += 1
+      # The assert of the full data structure below works, but
+      # by default Test::Unit doesn't print the diff of large
+      # data structures, so for debugging purposes it's much
+      # nicer to have each key checked individually as well.
+      expected["results"][index].each_entry do |key, value|
+        assert_equal([index, key, value],
+                     [index, key, result[key]])
+      end
+      assert_equal(expected["results"][index], result)
+    end
+    assert_equal(expected["results"].length, n_results)
+  end
+
+  test_data = JSON::parse(open("test/resultsreader_test_data.json").read())
+  export_data = JSON::parse(open("test/export_test_data.json").read())
+
+  xml_libraries.each do |xml_library|
+    test_data.each_entry do |version, tests|
+      tests.each_entry do |name, expected|
+        test_name = "test_#{xml_library}_#{version.gsub(/\./, "_")}_#{name}"
+        define_method(test_name.intern()) do
+          Splunk::require_xml_library(xml_library)
+          file = File.open("test/data/results/#{version}/#{name}.xml")
+          reader = ResultsReader.new(file)
+          assert_results_reader_equals(expected, reader)
+        end
+      end
+    end
+
+    export_data.each_entry do |version, tests|
+      # without_preview
+      test_name = "test_#{xml_library}_#{version.gsub(/\./, "_")}_sans_preview"
+      define_method(test_name.intern) do
+        Splunk::require_xml_library(xml_library)
+        file = File.open("test/data/export/#{version}/export_results.xml")
+        reader = MultiResultsReader.new(file)
+        found = reader.final_results()
+        expected = tests["without_preview"]
+        assert_results_reader_equals(expected, found)
+      end
+
+      # with preview
+      test_name = "test_#{xml_library}_#{version.gsub(/\./, "_")}_with_preview"
+      define_method(test_name.intern) do
+        Splunk::require_xml_library(xml_library)
+        file = File.open("test/data/export/#{version}/export_results.xml")
+        multireader = MultiResultsReader.new(file)
+        n_results_sets = 0
+        readers = []
+        multireader.each_with_index do |rr, index|
+          readers << rr
+          expected = tests["with_preview"][index]
+          assert_results_reader_equals(expected, rr)
+          n_results_sets += 1
+        end
+        assert_equal(tests["with_preview"].length, n_results_sets)
+        assert_raise do # Out of order invocation should raise an error
+          readers[0].each()
+        end
+      end
+
+      # nonreporting
+      test_name = "test_#{xml_library}_#{version.gsub("/\./", "_")}_nonreporting"
+      if tests.has_key?("nonreporting")
+        define_method(test_name.intern) do
+          Splunk::require_xml_library(xml_library)
+          file = File.open("test/data/export/#{version}/nonreporting.xml")
+          multireader = MultiResultsReader.new(file)
+          n_results_sets = 0
+          readers = []
+          multireader.each_with_index do |rr, index|
+            readers << rr
+            expected = tests["nonreporting"][index]
+            assert_results_reader_equals(expected, rr)
+            n_results_sets += 1
+          end
+          assert_equal(1, n_results_sets)
+        end
+      end
+
+    end
+  end
+
+
+end

data/test/test_roles.rb

@@ -0,0 +1,41 @@
+require_relative 'test_helper'
+require 'splunk-sdk-ruby'
+
+include Splunk
+
+class RoleTestCase < TestCaseWithSplunkConnection
+  def teardown
+    @service.roles.each do |role|
+      if role.name.start_with?("delete-me")
+        @service.roles.delete(role.name)
+      end
+    end
+
+    super
+  end
+
+  ##
+  # Create a role and make sure the values we created it with actually
+  # appear, and that the role appears in the collection. Then delete it and
+  # make sure it vanishes from the collection.
+  #
+  def test_create_and_delete
+    name = temporary_name()
+    role = @service.roles.create(name)
+    assert_true(@service.roles.has_key?(name))
+    assert_equal(name, role.name)
+
+    @service.roles.delete(name)
+    assert_false(@service.roles.has_key?(name))
+  end
+
+  ##
+  # Make sure that the roles collection normalizes all names to lowercase,
+  # since role names are case insensitive.
+  #
+  def test_case_insensitive
+    name = temporary_name() + "UPCASE"
+    user = @service.roles.create(name)
+    assert_true(@service.roles.has_key?(name.downcase()))
+  end
+end

data/test/test_saved_searches.rb

@@ -0,0 +1,119 @@
+require_relative 'test_helper'
+require 'splunk-sdk-ruby'
+
+include Splunk
+
+class SavedSearchesTestCase < TestCaseWithSplunkConnection
+  def teardown
+    @service.saved_searches.each do |ss|
+      if ss.name.start_with?("delete-me")
+        ss.history.each() {|job| job.cancel()}
+        @service.saved_searches.delete(ss.name)
+      end
+    end
+
+    assert_eventually_true do
+      @service.saved_searches.all?() {|ss| !ss.name.start_with?("delete-me")}
+    end
+
+    super
+  end
+
+  def check_saved_search(saved_search)
+    expected_fields = ['alert.expires',
+                       'alert.severity',
+                       'alert.track',
+                       'alert_type',
+                       'dispatch.buckets',
+                       'dispatch.lookups',
+                       'dispatch.max_count',
+                       'dispatch.max_time',
+                       'dispatch.reduce_freq',
+                       'dispatch.spawn_process',
+                       'dispatch.time_format',
+                       'dispatch.ttl',
+                       'max_concurrent',
+                       'realtime_schedule',
+                       'restart_on_searchpeer_add',
+                       'run_on_startup',
+                       'search',
+                       'action.email',
+                       'action.populate_lookup',
+                       'action.rss',
+                       'action.script',
+                       'action.summary_index']
+    expected_fields.each do |f|
+      saved_search[f]
+    end
+
+    is_scheduled = saved_search["is_scheduled"]
+    assert_true(is_scheduled == '1' || is_scheduled == '0')
+    is_visible = saved_search["is_visible"]
+    assert_true(is_visible == '1' || is_visible == '0')
+  end
+
+  ##
+  # Make sure we can create a saved search, it shows up in the collection,
+  # and we can delete it.
+  #
+  def test_create_and_delete
+    saved_search_name = temporary_name()
+    @service.saved_searches.create(saved_search_name, :search => "search *")
+    assert_eventually_true(3) do
+      @service.saved_searches.has_key?(saved_search_name)
+    end
+
+    check_saved_search(@service.saved_searches[saved_search_name])
+
+    @service.saved_searches.delete(saved_search_name)
+    assert_eventually_true(3) do
+      !@service.saved_searches.member?(saved_search_name)
+    end
+  end
+
+  ##
+  # In Splunk 4.x, update on saved searches has to have special behavior, since
+  # Splunk will try to clear the search if you don't pass it (or will throw an
+  # error if you don't pass it). So we make sure that update works and the
+  # search is the same before and after.
+  #
+  def test_update
+    saved_search_name = temporary_name()
+    ss = @service.saved_searches.create(saved_search_name,
+                                        :search => "search *")
+
+    ss.update(:description => "boris")
+    ss.refresh()
+    assert_equal("boris", ss["description"])
+    assert_equal("search *", ss["search"])
+  end
+
+  ##
+  # In contrast to the previous test, make sure that we can set the search.
+  # with update.
+  #
+  def test_update_search
+    saved_search_name = temporary_name()
+    ss = @service.saved_searches.create(saved_search_name,
+                                        :search => "search *")
+
+    ss.update(:description => "boris",
+              :search => "search index=_internal *")
+    ss.refresh()
+    assert_equal("boris", ss["description"])
+    assert_equal("search index=_internal *", ss["search"])
+  end
+
+  ##
+  #
+  def test_dispatch()
+    saved_search_name = temporary_name()
+    ss = @service.saved_searches.create(saved_search_name,
+                                        :search => "search *")
+    job = ss.dispatch()
+    while !job.is_ready?()
+      sleep(0.2)
+    end
+  end
+
+end