splunk-sdk-ruby 0.1.0

data/test/test_configuration_file.rb

@@ -0,0 +1,124 @@
+require_relative 'test_helper'
+require 'splunk-sdk-ruby'
+
+include Splunk
+
+class ConfigurationFileTestCase < TestCaseWithSplunkConnection
+  def setup
+    super
+    # We cannot delete configuration files from the REST API
+    # so we create a temporary application to do our manipulation
+    # in. When we delete it at the end of the test run, the
+    # configuration modifications will be deleted as well.
+    @container_app_name = temporary_name()
+    @service.apps.create(@container_app_name)
+
+    # Now reconnect in the test app context.
+    app_service_args = @splunkrc.clone()
+    app_service_args[:namespace] =
+        Splunk::namespace(:sharing => "app", :app => @container_app_name)
+    @app_service = Splunk::Service.new(app_service_args).login()
+    @confs = @app_service.confs
+  end
+
+  def teardown
+    if @service.server_requires_restart?
+      fail("Test left Splunk in a state requiring restart.")
+    end
+
+    @service.apps.delete(@container_app_name)
+    if @service.server_requires_restart?
+      clear_restart_message(@service)
+    end
+
+    super
+  end
+
+  def test_create_and_delete
+    file_name = temporary_name()
+    assert_false(@confs.has_key?(file_name))
+    assert_false(@confs.contains?(file_name))
+    assert_false(@confs.member?(file_name))
+    assert_false(@confs.key?(file_name))
+    assert_false(@confs.include?(file_name))
+
+    conf = @confs.create(file_name)
+    assert_equal(file_name, conf.name)
+    assert_equal(0, conf.length)
+
+    assert_true(@confs.has_key?(file_name))
+    assert_true(@confs.contains?(file_name))
+    assert_true(@confs.member?(file_name))
+    assert_true(@confs.key?(file_name))
+    assert_true(@confs.include?(file_name))
+
+    assert_raises(Splunk::IllegalOperation) { @confs.delete(file_name) }
+  end
+
+  def test_fetch
+    file_name = temporary_name()
+    created_conf = @confs.create(file_name)
+
+    fetched_conf = @confs.fetch(file_name)
+    assert_true(fetched_conf.is_a?(ConfigurationFile))
+    assert_equal(created_conf.name, fetched_conf.name)
+
+    bracket_fetched_conf = @confs[file_name]
+    assert_true(fetched_conf.is_a?(ConfigurationFile))
+    assert_equal(created_conf.name, bracket_fetched_conf.name)
+  end
+
+  def test_each_and_values
+    each_names = []
+    @confs.each() { |entity| each_names << entity.name }
+
+    values_names = @confs.values().map() { |e| e.name }
+
+    assert_false(each_names.empty?)
+    assert_equal(each_names, values_names)
+  end
+
+  def test_create_and_delete_stanzas
+    file_name = temporary_name()
+    conf = @confs.create(file_name)
+
+    assert_equal(0, conf.length())
+
+    n = 5 + rand(5)
+    stanza_names = []
+    (1..n).each() do
+      stanza_name = temporary_name()
+      stanza_names << stanza_name
+      conf.create(stanza_name)
+    end
+
+    assert_equal(n, conf.length())
+
+    stanza_names.each() do |name|
+      conf.delete(name)
+      n -= 1
+      assert_equal(n, conf.length())
+    end
+  end
+
+  def test_each
+    @confs.each() do |configuration_file|
+      assert_true(configuration_file.is_a?(ConfigurationFile))
+    end
+  end
+
+  def test_submit_to_stanza
+    file_name = temporary_name()
+    conf = @confs.create(file_name)
+
+    stanza_name = temporary_name()
+    stanza = conf.create(stanza_name)
+
+    assert_equal(0, stanza.length())
+    stanza.submit(:boris => "natasha", :hilda => "moose on the roof")
+    stanza.refresh()
+    assert_equal(2, stanza.length())
+    assert_equal("natasha", stanza["boris"])
+    assert_equal("moose on the roof", stanza["hilda"])
+  end
+end

data/test/test_context.rb

@@ -0,0 +1,119 @@
+require_relative "test_helper"
+require "splunk-sdk-ruby"
+
+include Splunk
+
+# Test the helper functions in test_helper.rb
+class TestHelpers < TestCaseWithSplunkConnection
+  def test_temporary_name
+    assert_true(temporary_name().start_with?("delete-me"))
+  end
+
+  def test_set_and_clear_restart_messages()
+    service = Context.new(@splunkrc).login()
+    assert_false(service.server_requires_restart?)
+
+    set_restart_message(service)
+    assert_true(service.server_requires_restart?)
+
+    clear_restart_message(service)
+    assert_false(service.server_requires_restart?)
+  end
+end
+
+class TestContext < TestCaseWithSplunkConnection
+  def test_login()
+    service = Context.new(@splunkrc)
+    service.login()
+    assert_logged_in(service)
+  end
+
+  def test_login_with_encodings()
+    ["ASCII", "UTF-8"].each() do |encoding|
+      values = {}
+      @splunkrc.each() do |key, value|
+        if value.is_a?(String)
+          values[key] = value.clone().force_encoding(encoding)
+        else
+          values[key] = value
+        end
+      end
+      service = Context.new(values).login()
+      assert_logged_in(service)
+    end
+  end
+
+  def test_authenticate_with_token
+    service = Context.new(@splunkrc).login()
+    token = service.token
+
+    new_arguments = @splunkrc.clone
+    new_arguments.delete(:username)
+    new_arguments.delete(:password)
+    new_arguments[:token] = token
+
+    new_service = Context.new(new_arguments)
+    assert_not_nil(new_service.token)
+    assert_logged_in(new_service)
+  end
+
+  def test_failed_login()
+    args = @splunkrc.clone()
+    args[:username] = args[:username] + "-boris"
+    service = Context.new(args)
+
+    assert_raises(SplunkHTTPError) {service.login()}
+  end
+
+  def test_multiple_logins_are_nops()
+    service = Context.new(@splunkrc).login()
+    assert_logged_in(service)
+
+    assert_nothing_raised() {service.login()}
+    assert_logged_in(service)
+  end
+
+  def test_logout
+    service = Context.new(@splunkrc).login()
+    assert_logged_in(service)
+
+    service.logout()
+    assert_not_logged_in(service)
+
+    service.login()
+    assert_logged_in(service)
+  end
+
+  def test_connect()
+    service = Context.new(@splunkrc).login()
+    socket = service.connect()
+    # Send a manual HTTP request
+    socket.write("GET /services/data/indexes HTTP/1.1\r\n")
+    socket.write("Authorization: Splunk #{service.token}\r\n")
+    socket.write("\r\n")
+    response = socket.readlines()
+    assert_equal("HTTP/1.1 200 OK", response[0].strip)
+  end
+
+  def test_server_accepting_connections?
+    values = @splunkrc.clone()
+    values[:port] = 10253
+    service = Context.new(values)
+    assert_false(service.server_accepting_connections?)
+
+    service = Context.new(@splunkrc)
+    assert_true(service.server_accepting_connections?)
+  end
+
+  def test_info
+    assert_true(@service.info.has_key?("version"))
+  end
+
+  def test_splunk_version
+    version = @service.splunk_version
+    assert_true(version.is_a?(Array))
+    version.each() do |v|
+      assert_true(v.is_a?(Integer))
+    end
+  end
+end

data/test/test_entity.rb

@@ -0,0 +1,95 @@
+require_relative 'test_helper'
+require 'splunk-sdk-ruby'
+
+include Splunk
+
+class EntityTestCase < TestCaseWithSplunkConnection
+  def setup
+    super
+    @app_args = {
+        "author" => "Harry Belten",
+        "label" => "A random app",
+        "description" => "Sumer is icumen in",
+    }
+    @entity = @service.apps.create(temporary_name(), @app_args)
+  end
+
+  def teardown
+    @entity.delete()
+
+    if @service.splunk_version[0..1] != [4,2]
+      clear_restart_message(@service)
+    end
+
+    super
+  end
+
+  def test_fetch
+    @app_args.each() do |key, value|
+      assert_equal(value, @entity[key])
+      assert_equal(value, @entity.fetch(key))
+    end
+  end
+
+  def test_fetch_with_default
+    assert_equal("boris", @entity.fetch("nonexistant key", "boris"))
+  end
+
+  def test_update_and_refresh
+    @entity.update("label" => "This is a test")
+    assert_equal(@app_args["label"], @entity["label"])
+    @entity.refresh()
+    assert_equal("This is a test", @entity["label"])
+
+    @entity["label"] = "Oh the vogonity!"
+    assert_equal("This is a test", @entity["label"])
+    @entity.refresh()
+    assert_equal("Oh the vogonity!", @entity["label"])
+  end
+
+  def test_read
+    state = @entity.read()
+    assert_false(state.empty?)
+    state.each() do |key, value|
+      assert_equal(value, @entity[key])
+    end
+    state.each() do |key, value|
+      state[key] = "boris"
+      assert_not_equal("boris", value)
+      assert_equal(value, @entity[key])
+    end
+  end
+
+  def test_state_with_field_list
+    state = @entity.read("label", "description")
+    assert_false(state.empty?)
+    state.each() do |key, value|
+      assert_equal(value, @entity[key])
+    end
+    state.each() do |key, value|
+      state[key] = "boris"
+      assert_not_equal("boris", value)
+      assert_equal(value, @entity[key])
+    end
+
+    assert_equal(@entity.read("label", "description"),
+                 @entity.read(["label", "description"]))
+  end
+
+  def test_disable_enable
+    # We have to refresh first, because apps on some versions of Splunk
+    # do not have all their keys (including "disabled") when first created.
+    @entity.refresh()
+
+    assert_equal('0', @entity["disabled"])
+
+    @entity.disable()
+    @entity.refresh()
+    assert_equal('1', @entity["disabled"])
+
+    @entity.enable()
+    @entity.refresh()
+    assert_equal('0', @entity["disabled"])
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,250 @@
+if ENV.has_key?("COVERAGE")
+  require "simplecov"
+  SimpleCov.start() do
+    add_filter("test")
+  end
+end
+
+# This line is required to let RubyMine run the test suite,
+# since otherwise random packages load other random packages
+# in random order and clobber RubyMine's configuration.
+# See http://youtrack.jetbrains.com/issue/RUBY-11922
+$:.unshift($:.select {|i| i.include? '/patch/'}).flatten!
+
+require 'test-unit'
+
+$:.unshift File.expand_path(File.join([File.dirname(__FILE__), "..", "lib"]))
+
+def read_splunkrc
+  file = File.new(File.expand_path("~/.splunkrc"))
+  options = {
+      :host => 'localhost',
+      :port => 8089,
+      :username => 'admin',
+      :password => 'changeme',
+      :scheme => 'https',
+      :version => '5.0'
+  }
+  file.readlines.each do |raw_line|
+    line = raw_line.strip()
+    if line.start_with?("\#") or line.length == 0
+      next
+    else
+      raw_key, raw_value = line.split('=', limit=2)
+      key = raw_key.strip().intern
+      value = raw_value.strip()
+
+      if key == 'port'
+        value = Integer(value)
+      end
+
+      options[key] = value
+    end
+  end
+
+  options
+end
+
+def nokogiri_available?
+  begin
+    require 'nokogiri'
+    return true
+  rescue LoadError
+    return false
+  end
+end
+
+require 'securerandom'
+def temporary_name
+  return "delete-me-" + SecureRandom.uuid()
+end
+
+DEFAULT_RESTART_TIMEOUT = 500 # seconds
+
+class TestCaseWithSplunkConnection < Test::Unit::TestCase
+  def setup
+    super
+    @splunkrc = read_splunkrc()
+    @service = Splunk::Service.new(@splunkrc).login()
+    @installed_apps = []
+
+    if @service.server_requires_restart?
+      puts "Previous test left server in a state requiring a restart."
+      checked_restart(@service)
+    end
+  end
+
+  def teardown
+    if @service.server_requires_restart?()
+      fail("Test left server in a state requiring restart.")
+    end
+
+    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)
+        end
+      end
+    end
+
+    @installed_apps.clear()
+
+    super
+  end
+
+  def assert_eventually_true(timeout=30, &block)
+    Timeout::timeout(timeout) do
+      while !block.call()
+        sleep(0.2)
+      end
+    end
+  end
+
+  def assert_logged_in(service)
+    assert_nothing_raised do
+      # A request to data/indexes requires you to be logged in.
+      service.request(:method=>:GET,
+                      :resource=>["data", "indexes"])
+    end
+  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.")
+    end
+  end
+
+  # Clear any restart messages on _service_.
+  #
+  # If there was no restart message, raises an error. (We want all the restarts
+  # and restart messages carefully controlled in the test suite.)
+  #
+  def clear_restart_message(service)
+    if !service.server_requires_restart?
+        raise StandardError.new("Tried to clear restart message " +
+                                    "when there was none.")
+    end
+    begin
+      service.request(:method => :DELETE,
+                      :resource => ["messages", "restart_required"])
+    rescue SplunkHTTPError => err
+      if err.code != 404
+        raise err
+      end
+    end
+  end
+
+  def has_app_collection?(service)
+    collection_name = 'sdk-app-collection'
+    return service.apps.has_key?(collection_name)
+  end
+
+  def install_app_from_collection(name)
+    collection_name = 'sdk-app-collection'
+    if !@service.apps.has_key?(collection_name)
+      raise StandardError("#{collection_name} not installed in Splunk.")
+    end
+
+    app_path = path_in_app(collection_name, ["build", name+".tar"])
+    args = {"update" => 1, "name" => app_path}
+    begin
+      @service.request(:method => :POST,
+                       :resource => ["apps", "appinstall"],
+                       :body => args)
+      @installed_apps << name
+    rescue SplunkHTTPError => err
+      if err.code == 40
+        raise StandardError("App #{name} not found in app collection")
+      else
+        raise err
+      end
+    end
+  end
+
+  # Return a path to *path_components* in *app_name*.
+  #
+  # `path_in_app` is used to refer to files in applications installed with
+  # `install_app_from_collection`. For example, the app `file_to_upload` in
+  # the collection contains `log.txt`. To get the path to it, call::
+  #
+  # path_in_app('file_to_upload', ['log.txt'])
+  #
+  # The path to `setup.xml` in `has_setup_xml` would be fetched with::
+  #
+  # path_in_app('has_setup_xml', ['default', 'setup.xml'])
+  #
+  # path_in_app` figures out the correct separator to use (based on whether
+  # splunkd is running on Windows or Unix) and joins the elements in
+  # *path_components* into a path relative to the application specified by
+  # *app_name*.
+  #
+  # *path_components* should be a list of strings giving the components.
+  # This function will try to figure out the correct separator (/ or \)
+  # for the platform that splunkd is running on and construct the path
+  # as needed.
+  #
+  # :return: A string giving the path.
+  #
+  def path_in_app(app_name, path_components)
+    splunk_home = @service.settings["SPLUNK_HOME"]
+    if splunk_home.include?("\\")
+      # This clause must come first, since Windows machines may
+      # have mixed \ and / in their paths.
+      separator = "\\"
+    elsif splunk_home.include?("/")
+      separator = "/"
+    else
+      raise StandardError("No separators in $SPLUNK_HOME. Can't determine " +
+                              "what file separator to use.")
+    end
+
+    app_path = ([splunk_home, "etc", "apps", app_name] + path_components).
+        join(separator)
+    return app_path
+  end
+
+
+  # Create a new restart message on _service_.
+  #
+  # Optionally you can specify a value for the restart message, or it will
+  # default to "Ruby SDK test suite asked for a restart."
+  #
+  def set_restart_message(service,
+                          message="Ruby SDK test suite asked for a restart.")
+    service.request(:method => :POST,
+            :namespace => Splunk::namespace(:sharing => "default"),
+            :resource => ["messages"],
+            :body => {"name" => "restart_required",
+                      "value" => "Message set by restart method" +
+                          " of the Splunk Ruby SDK"})
+  end
+
+  # Restart Splunk and wait for it to come back up, but only if it needs it.
+  #
+  # Throws an error if this is called on a Splunk instance that does not
+  # need to be restarted.
+  #
+  def checked_restart(service)
+    if !service.server_requires_restart?
+      raise StandardError("Tried to restart a Splunk instance that" +
+                              " does not need it.")
+    else
+      service.restart(DEFAULT_RESTART_TIMEOUT)
+    end
+  end
+
+  # Restarts a Splunk instance whether it needs it or not.
+  #
+  def unchecked_restart(service)
+    service.restart(DEFAULT_RESTART_TIMEOUT)
+  end
+end