splunk-sdk-ruby 0.1.0

data/test/services.server.info.xml

@@ -0,0 +1,43 @@
+<ns0:feed xmlns:ns0="http://www.w3.org/2005/Atom">
+  <ns0:title>server-info</ns0:title>
+  <ns0:id>https://localhost/services/server/info</ns0:id>
+  <ns0:updated>2011-07-01T16:53:53-07:00</ns0:updated>
+  <ns0:generator version="101089" />
+  <ns0:author>
+    <ns0:name>Splunk</ns0:name>
+  </ns0:author>
+  <ns1:totalResults xmlns:ns1="http://a9.com/-/spec/opensearch/1.1/">1</ns1:totalResults>
+  <ns1:itemsPerPage xmlns:ns1="http://a9.com/-/spec/opensearch/1.1/">30</ns1:itemsPerPage>
+  <ns1:startIndex xmlns:ns1="http://a9.com/-/spec/opensearch/1.1/">0</ns1:startIndex>
+  <ns1:messages xmlns:ns1="http://dev.splunk.com/ns/rest" />
+  <ns0:entry>
+    <ns0:title>server-info</ns0:title>
+    <ns0:id>https://localhost/services/server/info/server-info</ns0:id>
+    <ns0:updated>2011-07-01T16:53:53-07:00</ns0:updated>
+    <ns0:link href="/services/server/info/server-info" rel="alternate" />
+    <ns0:author>
+      <ns0:name>system</ns0:name>
+    </ns0:author>
+    <ns0:link href="/services/server/info/server-info" rel="list" />
+    <ns0:content type="text/xml">
+      <ns1:dict xmlns:ns1="http://dev.splunk.com/ns/rest">
+        <ns1:key name="build">101089</ns1:key>
+        <ns1:key name="cpu_arch">i386</ns1:key>
+        <ns1:key name="eai:acl"><ns1:dict><ns1:key name="app" /><ns1:key name="can_write">0</ns1:key><ns1:key name="modifiable">0</ns1:key><ns1:key name="owner">system</ns1:key><ns1:key name="perms"><ns1:dict><ns1:key name="read"><ns1:list><ns1:item>*</ns1:item></ns1:list></ns1:key><ns1:key name="write"><ns1:list /></ns1:key></ns1:dict></ns1:key><ns1:key name="sharing">system</ns1:key></ns1:dict></ns1:key>
+        <ns1:key name="guid">3FD18BC4-010D-4845-AD51-27963CB17412</ns1:key>
+        <ns1:key name="isFree">0</ns1:key>
+        <ns1:key name="isTrial">0</ns1:key>
+        <ns1:key name="licenseKeys"><ns1:list><ns1:item>E4BF242DB47AB54B5F9DC69D00E65A4BD4E89F917B93D0FA611EDF85ABFC639D</ns1:item></ns1:list></ns1:key>
+        <ns1:key name="licenseSignature">3af106e3af0db73ca69339684cad26eb</ns1:key>
+        <ns1:key name="licenseState">OK</ns1:key>
+        <ns1:key name="master_guid">3FD18BC4-010D-4845-AD51-27963CB17412</ns1:key>
+        <ns1:key name="mode">normal</ns1:key>
+        <ns1:key name="os_build">Darwin Kernel Version 10.8.0: Tue Jun  7 16:33:36 PDT 2011; root:xnu-1504.15.3~1/RELEASE_I386</ns1:key>
+        <ns1:key name="os_name">Darwin</ns1:key>
+        <ns1:key name="os_version">10.8.0</ns1:key>
+        <ns1:key name="serverName">blovering.local</ns1:key>
+        <ns1:key name="version">4.3</ns1:key>
+      </ns1:dict>
+    </ns0:content>
+  </ns0:entry>
+</ns0:feed>

data/test/services.xml

@@ -0,0 +1,111 @@
+<ns0:feed xmlns:ns0="http://www.w3.org/2005/Atom">
+  <ns0:title>services</ns0:title>
+  <ns0:id>https://localhost/services/</ns0:id>
+  <ns0:updated>2011-07-01T16:52:51-07:00</ns0:updated>
+  <ns0:generator version="101089" />
+  <ns0:author>
+    <ns0:name>Splunk</ns0:name>
+  </ns0:author>
+  <ns0:entry>
+    <ns0:title>alerts</ns0:title>
+    <ns0:id>https://localhost/services/alerts</ns0:id>
+    <ns0:updated>2011-07-01T16:52:51-07:00</ns0:updated>
+    <ns0:link href="/services/alerts" rel="alternate" />
+  </ns0:entry>
+  <ns0:entry>
+    <ns0:title>apps</ns0:title>
+    <ns0:id>https://localhost/services/apps</ns0:id>
+    <ns0:updated>2011-07-01T16:52:51-07:00</ns0:updated>
+    <ns0:link href="/services/apps" rel="alternate" />
+  </ns0:entry>
+  <ns0:entry>
+    <ns0:title>authentication</ns0:title>
+    <ns0:id>https://localhost/services/authentication</ns0:id>
+    <ns0:updated>2011-07-01T16:52:51-07:00</ns0:updated>
+    <ns0:link href="/services/authentication" rel="alternate" />
+  </ns0:entry>
+  <ns0:entry>
+    <ns0:title>authorization</ns0:title>
+    <ns0:id>https://localhost/services/authorization</ns0:id>
+    <ns0:updated>2011-07-01T16:52:51-07:00</ns0:updated>
+    <ns0:link href="/services/authorization" rel="alternate" />
+  </ns0:entry>
+  <ns0:entry>
+    <ns0:title>data</ns0:title>
+    <ns0:id>https://localhost/services/data</ns0:id>
+    <ns0:updated>2011-07-01T16:52:51-07:00</ns0:updated>
+    <ns0:link href="/services/data" rel="alternate" />
+  </ns0:entry>
+  <ns0:entry>
+    <ns0:title>deployment</ns0:title>
+    <ns0:id>https://localhost/services/deployment</ns0:id>
+    <ns0:updated>2011-07-01T16:52:51-07:00</ns0:updated>
+    <ns0:link href="/services/deployment" rel="alternate" />
+  </ns0:entry>
+  <ns0:entry>
+    <ns0:title>licenser</ns0:title>
+    <ns0:id>https://localhost/services/licenser</ns0:id>
+    <ns0:updated>2011-07-01T16:52:51-07:00</ns0:updated>
+    <ns0:link href="/services/licenser" rel="alternate" />
+  </ns0:entry>
+  <ns0:entry>
+    <ns0:title>messages</ns0:title>
+    <ns0:id>https://localhost/services/messages</ns0:id>
+    <ns0:updated>2011-07-01T16:52:51-07:00</ns0:updated>
+    <ns0:link href="/services/messages" rel="alternate" />
+  </ns0:entry>
+  <ns0:entry>
+    <ns0:title>configs</ns0:title>
+    <ns0:id>https://localhost/services/configs</ns0:id>
+    <ns0:updated>2011-07-01T16:52:51-07:00</ns0:updated>
+    <ns0:link href="/services/configs" rel="alternate" />
+  </ns0:entry>
+  <ns0:entry>
+    <ns0:title>saved</ns0:title>
+    <ns0:id>https://localhost/services/saved</ns0:id>
+    <ns0:updated>2011-07-01T16:52:51-07:00</ns0:updated>
+    <ns0:link href="/services/saved" rel="alternate" />
+  </ns0:entry>
+  <ns0:entry>
+    <ns0:title>scheduled</ns0:title>
+    <ns0:id>https://localhost/services/scheduled</ns0:id>
+    <ns0:updated>2011-07-01T16:52:51-07:00</ns0:updated>
+    <ns0:link href="/services/scheduled" rel="alternate" />
+  </ns0:entry>
+  <ns0:entry>
+    <ns0:title>search</ns0:title>
+    <ns0:id>https://localhost/services/search</ns0:id>
+    <ns0:updated>2011-07-01T16:52:51-07:00</ns0:updated>
+    <ns0:link href="/services/search" rel="alternate" />
+  </ns0:entry>
+  <ns0:entry>
+    <ns0:title>server</ns0:title>
+    <ns0:id>https://localhost/services/server</ns0:id>
+    <ns0:updated>2011-07-01T16:52:51-07:00</ns0:updated>
+    <ns0:link href="/services/server" rel="alternate" />
+  </ns0:entry>
+  <ns0:entry>
+    <ns0:title>streams</ns0:title>
+    <ns0:id>https://localhost/services/streams</ns0:id>
+    <ns0:updated>2011-07-01T16:52:51-07:00</ns0:updated>
+    <ns0:link href="/services/streams" rel="alternate" />
+  </ns0:entry>
+  <ns0:entry>
+    <ns0:title>broker</ns0:title>
+    <ns0:id>https://localhost/services/broker</ns0:id>
+    <ns0:updated>2011-07-01T16:52:51-07:00</ns0:updated>
+    <ns0:link href="/services/broker" rel="alternate" />
+  </ns0:entry>
+  <ns0:entry>
+    <ns0:title>clustering</ns0:title>
+    <ns0:id>https://localhost/services/clustering</ns0:id>
+    <ns0:updated>2011-07-01T16:52:51-07:00</ns0:updated>
+    <ns0:link href="/services/clustering" rel="alternate" />
+  </ns0:entry>
+  <ns0:entry>
+    <ns0:title>masterlm</ns0:title>
+    <ns0:id>https://localhost/services/masterlm</ns0:id>
+    <ns0:updated>2011-07-01T16:52:51-07:00</ns0:updated>
+    <ns0:link href="/services/masterlm" rel="alternate" />
+  </ns0:entry>
+</ns0:feed>

data/test/test_atomfeed.rb

@@ -0,0 +1,71 @@
+require_relative "test_helper"
+require "splunk-sdk-ruby"
+
+include Splunk
+
+# URI's classes compare by object identity, which is exactly what we
+# *don't* want to do. Instead we use simple textual identity.
+module URI
+  class Generic
+    def ==(other)
+      return self.to_s == other.to_s
+    end
+  end
+
+  class HTTPS
+    def ==(other)
+      return self.to_s == other.to_s
+    end
+  end
+
+  class HTTP
+    def ==(other)
+      return self.to_s == other.to_s
+    end
+  end
+end
+
+class TestAtomFeed < Test::Unit::TestCase
+  # If Nokogiri is available, we'll test AtomFeed against both it
+  # and REXML. Otherwise, we'll print a warning and test only against
+  # REXML. REXML is part of the standard library in Ruby 1.9, so it will
+  # always be present.
+  if nokogiri_available?
+    xml_libraries = [:nokogiri, :rexml]
+  else
+    xml_libraries = [:rexml]
+    puts "Nokogiri not installed. Skipping."
+  end
+
+  test_cases = eval(open("test/atom_test_data.rb").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")
+        feed = Splunk::AtomFeed.new(file)
+
+        # 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]])
+        end
+        assert_equal(expected[:metadata], feed.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|
+          entry.each_entry do |key, value|
+            assert_equal([filename, index, key, value],
+                         [filename, index, key, feed.entries[index][key]])
+          end
+        end
+        assert_equal(expected[:entries], feed.entries)
+      end
+    end
+  end
+end
+

data/test/test_collection.rb

@@ -0,0 +1,278 @@
+require_relative 'test_helper'
+require 'splunk-sdk-ruby'
+
+include Splunk
+
+class TestCollection < TestCaseWithSplunkConnection
+  def teardown
+    c = Collection.new(@service, ["saved", "searches"])
+    c.delete_if() { |e| e.name.start_with?("delete-me") }
+    super
+  end
+
+  def test_constructor
+    resource = [temporary_name(), temporary_name()]
+    c = Collection.new(@service, resource)
+    assert_equal(@service, c.service)
+    assert_equal(resource, c.resource)
+    assert_equal(Entity, c.entity_class)
+  end
+
+  def test_constructor_with_entity_class
+    resource = [temporary_name(), temporary_name()]
+    c = Collection.new(@service, resource, TestCollection)
+    assert_equal(@service, c.service)
+    assert_equal(resource, c.resource)
+    assert_equal(TestCollection, c.entity_class)
+  end
+
+  def test_each_without_pagination
+    n_entities = 0
+    @service.apps.each(:count => 5) do |entity|
+      assert_true(entity.is_a?(Entity))
+      n_entities += 1
+    end
+    assert_true(n_entities <= 5)
+  end
+
+  def test_each_with_offset_and_count
+    entities = []
+    @service.apps.each(:count => 5) do |entity|
+      entities << entity.name
+    end
+
+    entities_with_offset = []
+    @service.apps.each(:count => entities.length-1, :offset => 1) do |entity|
+      entities_with_offset << entity.name
+    end
+
+    assert_equal(entities[1..4], entities_with_offset)
+  end
+
+  def test_each_with_pagination
+    total = 5 + rand(15)
+    page_size = 1 + rand(3)
+
+    entities = []
+    @service.apps.each(:count => total) do |entity|
+      entities << entity.name
+    end
+
+    entities_with_pagination = []
+    @service.apps.each(:count => total, :page_size => page_size) do |entity|
+      entities_with_pagination << entity.name
+    end
+
+    assert_equal(entities, entities_with_pagination)
+  end
+
+  def test_has_key
+    c = @service.apps
+    @service.apps.each(:count => 3) do |entity|
+      assert_true(c.has_key?(entity.name))
+      assert_true(c.contains?(entity.name))
+      assert_true(c.include?(entity.name))
+      assert_true(c.key?(entity.name))
+      assert_true(c.member?(entity.name))
+    end
+
+    name = "nonexistant saved search"
+    assert_false(c.has_key?(name))
+    assert_false(c.contains?(name))
+    assert_false(c.include?(name))
+    assert_false(c.key?(name))
+    assert_false(c.member?(name))
+  end
+
+  def test_create_and_delete
+    search_name = temporary_name()
+    search = "search index=_internal | head 10"
+
+    c = Collection.new(@service, ["saved", "searches"])
+
+    c.create(search_name, :search => search)
+    assert_true(c.has_key?(search_name))
+
+    assert_equal(search_name,
+                 c.fetch(search_name).name)
+    assert_equal(search_name,
+                 c[search_name].name)
+
+    c.delete(search_name)
+    assert_false(c.has_key?(search_name))
+  end
+
+  def test_create_twice
+    search_name = temporary_name()
+    search = "search index=_internal | head 10"
+
+    c = Collection.new(@service, ["saved", "searches"])
+
+    c.create(search_name, :search => search)
+    assert_true(c.has_key?(search_name))
+
+    assert_raises(SplunkHTTPError) { c.create(search_name, :search => search) }
+
+    c.delete(search_name)
+    assert_false(c.has_key?(search_name))
+  end
+
+  def test_name_collisions
+    search_name = temporary_name()
+    search = "search * | head 5"
+
+    saved_searches = Collection.new(@service, ["saved", "searches"])
+    ss1 = saved_searches.create(search_name,
+                                :search => search,
+                                :namespace => Splunk::namespace(:sharing => "app",
+                                                                :app => "search"))
+    ss2 = saved_searches.create(search_name, :search => search,
+                                :namespace => Splunk::namespace(:sharing => "user",
+                                                                :app => "search",
+                                                                :owner => "admin"))
+
+    wildcard_service_args = @splunkrc.clone()
+    wildcard_service_args[:namespace] = Splunk::namespace(:sharing => "user",
+                                                          :owner => "-",
+                                                          :app => "-")
+    wildcard_service = Context.new(wildcard_service_args).login()
+
+    wildcard_saved_searches =
+        Collection.new(wildcard_service, ["saved", "searches"])
+    assert_true(wildcard_saved_searches.has_key?(search_name))
+
+    assert_raises(Splunk::AmbiguousEntityReference) do
+      wildcard_saved_searches.fetch(search_name)
+    end
+
+    assert_raises(Splunk::AmbiguousEntityReference) do
+      wildcard_saved_searches[search_name]
+    end
+
+    assert_equal(search_name,
+                 wildcard_saved_searches.fetch(
+                     search_name,
+                     Splunk::namespace(:sharing => "app",
+                                       :app => "search")).name)
+    assert_equal(search_name,
+                 wildcard_saved_searches.fetch(
+                     search_name,
+                     Splunk::namespace(:sharing => "user",
+                                       :app => "search",
+                                       :owner => "admin")).name)
+
+    assert_raises(StandardError) do
+      wildcard_saved_searches.delete(search_name)
+    end
+
+    # The order here is important. The app/search namespace
+    # will delete both of the saved searches; user/search/admin
+    # will only delete that particular one.
+    wildcard_saved_searches.delete(search_name,
+                                   namespace=Splunk::namespace(:sharing => "user",
+                                                               :app => "search",
+                                                               :owner => "admin"))
+    assert_true(wildcard_saved_searches.has_key?(search_name))
+    wildcard_saved_searches.delete(search_name,
+                                   namespace=Splunk::namespace(:sharing => "app", :app => "search"))
+
+    assert_false(wildcard_saved_searches.has_key?(search_name))
+  end
+
+  def test_values
+    es = @service.apps.values(:count => 3)
+    assert_true(es.length <= 3)
+    es.each do |entity|
+      assert_true(entity.is_a?(Entity))
+    end
+  end
+
+  def test_each_equivales_values
+    assert_equal(
+        @service.apps.each().to_a().map() { |e| e.name },
+        @service.apps.values.map() { |e| e.name }
+    )
+  end
+
+  def test_length
+    c = @service.apps
+    assert_equal(c.values().length(), c.length())
+    assert_equal(c.values().length(), c.size())
+  end
+
+
+  def test_select
+    a = @service.apps.select() { |e| e.name == "search" }.to_a
+    assert_equal(1, a.length)
+    assert_equal("search", a[0].name)
+  end
+
+  def test_reject
+    a = @service.apps.reject() { |e| e.name != "search" }.to_a
+    assert_equal(1, a.length)
+    assert_equal("search", a[0].name)
+  end
+
+  def test_fetch_nonexistant
+    assert_nil(@service.apps.fetch("this does not exist"))
+  end
+
+  def test_assoc
+    name, entity = @service.apps.assoc("search")
+    assert_equal("search", name)
+    assert_equal("search", entity.name)
+
+    assert_nil(@service.apps.assoc("this does not exist"))
+  end
+
+  def test_keys
+    keys = @service.apps.keys()
+    assert_equal(@service.apps.values().map() { |e| e.name },
+                 keys)
+  end
+
+  def test_each_key
+    assert_equal(@service.apps.keys(), @service.apps.each_key.to_a)
+  end
+
+  def test_each_pair
+    keys = []
+    @service.apps.each_pair do |key, value|
+      assert_equal(key, value.name)
+      keys << key
+    end
+    assert_equal(@service.apps.keys(), keys)
+  end
+
+  def test_each_value
+    keys = []
+    @service.apps.each_value do |value|
+      keys << value.name
+    end
+    assert_equal(@service.apps.keys(), keys)
+  end
+
+  def test_empty
+    assert_false(@service.apps.empty?)
+  end
+
+  def test_delete_if
+    c = Collection.new(@service, ["saved", "searches"])
+
+    c.create(temporary_name(), :search => "search *")
+    c.create(temporary_name(), :search => "search *")
+    c.create(temporary_name(), :search => "search *")
+    assert_equal(
+        3,
+        c.select() { |e| e.name.start_with?("delete-me") }.to_a.length()
+    )
+
+    c.delete_if() { |e| e.name.start_with?("delete-me") }
+
+    assert_equal(
+        0,
+        c.select() { |e| e.name.start_with?("delete-me") }.to_a.length()
+    )
+  end
+
+end