wavefront-sdk 1.6.2 → 2.0.0

data/spec/wavefront-sdk/core/api_spec.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+require_relative '../../spec_helper'
+require_relative '../../../lib/wavefront-sdk/core/api'
+
+#
+# Test SDK core API class
+#
+class WavefrontCoreApiTest < MiniTest::Test
+  attr_reader :wf
+
+  def setup
+    @wf = Wavefront::CoreApi.new(CREDS)
+  end
+
+  def test_time_to_ms
+    now_ms = Time.now.to_i * 1000
+    assert_equal wf.time_to_ms(now_ms), now_ms
+    assert_equal wf.time_to_ms(1_469_711_187), 1_469_711_187_000
+    refute wf.time_to_ms([])
+    refute wf.time_to_ms('1469711187')
+  end
+
+  def test_hash_for_update
+    wf.instance_variable_set('@update_keys', %i[k1 k2])
+    body = { k1: 'ov1', k2: 'ov2', k3: 'ov3' }
+    upd = { k2: 'nv1' }
+
+    assert_equal(wf.hash_for_update(body, upd), k1: 'ov1', k2: 'nv1')
+  end
+end

data/spec/wavefront-sdk/{logger_spec.rb → core/logger_spec.rb}

@@ -1,8 +1,8 @@
 #!/usr/bin/env ruby
 
 require 'logger'
-require_relative '../spec_helper'
-require_relative '../../lib/wavefront-sdk/logger'
+require_relative '../../spec_helper'
+require_relative '../../../lib/wavefront-sdk/core/logger'
 
 # Test SDK logger class
 #
@@ -30,7 +30,7 @@ class WavefrontLoggerTest < MiniTest::Test
   def test_log_no_logger_no_debug
     l = Wavefront::Logger.new(debug: false, verbose: false)
     assert_silent { l.log('my message', :debug) }
-    assert_output("SDK INFO: my message\n") { l.log('my message', :info) }
+    assert_output('') { l.log('my message', :info) }
     out, err = capture_io { l.log('my message', :error) }
     assert_equal("SDK ERROR: my message\n", err)
     assert_empty(out)

data/spec/wavefront-sdk/core/response_spec.rb

@@ -0,0 +1,77 @@
+#!/usr/bin/env ruby
+
+require 'json'
+require_relative '../../spec_helper'
+require_relative '../../../lib/wavefront-sdk/core/exception'
+require_relative '../../../lib/wavefront-sdk/core/response'
+
+GOOD_RESP = '{"status":{"result":"OK","message":"","code":200},' \
+             '"response":{"items":[{"name":"test agent"}],"offset":0,' \
+             '"limit":100,"totalItems":3,"moreItems":false}}'.freeze
+
+BAD_RESP = "error='not_found'
+message='resource cannot be found'
+trackingId=eca22ddc-848b-4e67-876a-366145c8a759".freeze
+
+# Unit tests for Response class. Also inderectly tests the Status
+# type.
+#
+class WavefrontResponseTest < MiniTest::Test
+  attr_reader :wfg, :wfb
+
+  def setup
+    @wfg = Wavefront::Response.new(GOOD_RESP, 200)
+    @wfb = Wavefront::Response.new(BAD_RESP, 404)
+  end
+
+  def test_initialize_good_data
+    assert_instance_of(Wavefront::Response, wfg)
+    assert_respond_to(wfg, :status)
+    assert_respond_to(wfg, :response)
+    refute_respond_to(wfg, :to_a)
+    assert_respond_to(wfg.response, :items)
+    assert_instance_of(Array, wfg.response.items)
+    assert_instance_of(Wavefront::Type::Status, wfg.status)
+    assert_equal(200, wfg.status.code)
+    assert_equal('OK', wfg.status.result)
+    assert_instance_of(String, wfg.status.message)
+    assert_empty(wfg.status.message)
+    assert wfg.ok?
+    refute wfg.more_items?
+    refute wfg.next_item
+  end
+
+  def test_initialize_bad_data
+    assert_instance_of(Wavefront::Response, wfb)
+    assert_respond_to(wfb, :status)
+    assert_respond_to(wfb, :response)
+    refute_respond_to(wfb, :to_a)
+    refute_respond_to(wfb.response, :items)
+    assert_instance_of(Wavefront::Type::Status, wfb.status)
+    assert_equal(404, wfb.status.code)
+    assert_equal('ERROR', wfb.status.result)
+    assert_instance_of(String, wfb.status.message)
+    assert_match(/error='not_found'/, wfb.status.message)
+    refute wfb.ok?
+    refute wfb.more_items?
+    refute wfb.next_item
+  end
+
+  # This is a private method, so we test its public interface
+  #
+  def test_build_response
+    assert_equal(Map.new, Wavefront::Response.new('', 200).response)
+    assert_equal(Map.new, Wavefront::Response.new({}, 200).response)
+    assert_equal(Map.new, Wavefront::Response.new([], 200).response)
+    assert_equal(Map.new(message: 'string', code: 200),
+                 Wavefront::Response.new('string', 200).response)
+    assert_equal(123, Wavefront::Response.new({ response: 123 }.to_json,
+                                              200).response)
+  end
+
+  def test_to_s
+    assert_instance_of(String, wfg.to_s)
+    assert_match(/:code=>200/, wfg.to_s)
+    assert_match(/"limit"=>100/, wfg.to_s)
+  end
+end

data/spec/wavefront-sdk/credentials_spec.rb

@@ -4,8 +4,10 @@ require 'pathname'
 require_relative '../spec_helper'
 require_relative '../../lib/wavefront-sdk/credentials'
 
-CONF = Pathname.new(__FILE__).dirname.realpath + 'resources' + 'test.conf'
-CONF2 = Pathname.new(__FILE__).dirname.realpath + 'resources' + 'test2.conf'
+p RESOURCE_DIR
+
+CONF1 = RESOURCE_DIR + 'test.conf'
+CONF2 = RESOURCE_DIR + 'test2.conf'
 
 # Test SDK base class end-to-end
 #
@@ -15,11 +17,12 @@ class WavefrontCredentialsTest < MiniTest::Test
   def test_initialize_1
     ENV.delete('WAVEFRONT_ENDPOINT')
     ENV.delete('WAVEFRONT_TOKEN')
-    c = Wavefront::Credentials.new(file: CONF)
+    c = Wavefront::Credentials.new(file: CONF1)
     assert_instance_of(Wavefront::Credentials, c)
     assert_instance_of(Map, c.creds)
     assert_instance_of(Map, c.proxy)
     assert_instance_of(Map, c.config)
+    assert_instance_of(Map, c.all)
 
     assert_equal(c.creds.keys, %w[token endpoint])
     assert_equal(c.creds[:token], '12345678-abcd-1234-abcd-123456789012')
@@ -29,11 +32,12 @@ class WavefrontCredentialsTest < MiniTest::Test
   def test_initialize_env_token
     ENV.delete('WAVEFRONT_ENDPOINT')
     ENV['WAVEFRONT_TOKEN'] = 'abcdefgh'
-    c = Wavefront::Credentials.new(file: CONF)
+    c = Wavefront::Credentials.new(file: CONF1)
     assert_instance_of(Wavefront::Credentials, c)
     assert_instance_of(Map, c.creds)
     assert_instance_of(Map, c.proxy)
     assert_instance_of(Map, c.config)
+    assert_instance_of(Map, c.all)
 
     assert_equal(c.creds.keys, %w[token endpoint])
     assert_equal(c.creds[:token], 'abcdefgh')
@@ -43,11 +47,12 @@ class WavefrontCredentialsTest < MiniTest::Test
   def test_initialize_env_endpoint
     ENV.delete('WAVEFRONT_TOKEN')
     ENV['WAVEFRONT_ENDPOINT'] = 'endpoint.wavefront.com'
-    c = Wavefront::Credentials.new(file: CONF)
+    c = Wavefront::Credentials.new(file: CONF1)
     assert_instance_of(Wavefront::Credentials, c)
     assert_instance_of(Map, c.creds)
     assert_instance_of(Map, c.proxy)
     assert_instance_of(Map, c.config)
+    assert_instance_of(Map, c.all)
 
     assert_equal(c.creds.keys, %w[token endpoint])
     assert_equal(c.creds[:token], '12345678-abcd-1234-abcd-123456789012')
@@ -148,10 +153,10 @@ class GibletsTest < MiniTest::Test
                    [Pathname.new('/no/file/1'), Pathname.new('/no/file/2')]
     ), {})
 
-    assert_equal(wf.load_from_file([CONF], 'noprofile'),
-                 file: CONF)
+    assert_equal(wf.load_from_file([CONF1], 'noprofile'),
+                 file: CONF1)
 
-    x = wf.load_from_file([CONF2, CONF], 'default')
+    x = wf.load_from_file([CONF2, CONF1], 'default')
     assert_instance_of(Hash, x)
     assert_equal(x.keys.size, 5)
     assert_equal(x[:proxy], 'wavefront.localnet')
@@ -160,13 +165,13 @@ class GibletsTest < MiniTest::Test
       assert_includes(x.keys, k)
     end
 
-    y = wf.load_from_file([CONF2, CONF], 'other')
+    y = wf.load_from_file([CONF2, CONF1], 'other')
     assert_instance_of(Hash, y)
     %i[token endpoint proxy file].each { |k| assert_includes(y.keys, k) }
     assert_equal(y.keys.size, 4)
     assert_equal(y[:proxy], 'otherwf.localnet')
 
-    z = wf.load_from_file([CONF, CONF2], 'default')
+    z = wf.load_from_file([CONF1, CONF2], 'default')
     assert_instance_of(Hash, z)
     %i[token endpoint proxy file].each { |k| assert_includes(z.keys, k) }
     assert_equal(z.keys.size, 4)

data/spec/wavefront-sdk/distribution_spec.rb

@@ -0,0 +1,78 @@
+#!/usr/bin/env ruby
+
+require 'minitest/autorun'
+require_relative '../../lib/wavefront-sdk/distribution'
+
+W_CREDS = { proxy: 'wavefront', port: 2878 }.freeze
+
+DIST = {
+  interval: :m,
+  path:     'test.distribution',
+  value:    [[5, 11], [15, 2.533], [8, -15], [12, 1e6]],
+  ts:       1_538_865_613,
+  source:   'minitest',
+  tags:     { tag1: 'val1', tag2: 'val2' }
+}.freeze
+
+# Most of the distribution methods are inherited from the Write
+# class so they aren't tested again here.
+#
+class WavefrontDistributionTest < MiniTest::Test
+  attr_reader :wf, :wf_noop, :wf_tags
+
+  def setup
+    @wf = Wavefront::Distribution.new(W_CREDS)
+  end
+
+  def test_mk_distribution
+    assert_equal([[4, 1], [2, 3], [1, 2], [2, 6]].sort,
+                 wf.mk_distribution([1, 6, 3, 1, 1, 3, 2, 6, 1]).sort)
+  end
+
+  def test_mk_wf_distribution
+    assert_equal('#4 1.0 #2 3.0 #1 2.0 #2 6.0',
+                 wf.mk_wf_distribution([1, 1, 1, 1, 3, 3, 2, 6, 6]))
+    assert_equal('#4 1.0 #2 3.0 #1 2.0 #2 6.0',
+                 wf.mk_wf_distribution('1 1 1 1 3 3 2 6 6'))
+    assert_equal('#4 1.0 #2 3.0 #1 2.0 #2 6.0',
+                 wf.mk_wf_distribution(1, 1, 1, 1, 3, 3, 2, 6, 6))
+    assert_equal('#4 1.0 #2 3.0 #1 2.0 #2 6.0',
+                 wf.mk_wf_distribution([1, 1, 1], [1, 3, 3, 2, 6, 6]))
+  end
+
+  def test_hash_to_wf
+    assert_equal(wf.hash_to_wf(DIST),
+                 '!M 1538865613 #5 11 #15 2.533 #8 -15 #12 1000000.0 ' \
+                 'test.distribution source=minitest ' \
+                 'tag1="val1" tag2="val2"')
+
+    d2 = DIST.dup
+    d2[:tags] = {}
+
+    assert_equal(wf.hash_to_wf(d2),
+                 '!M 1538865613 #5 11 #15 2.533 #8 -15 #12 1000000.0 ' \
+                 'test.distribution source=minitest')
+
+    d3 = DIST.dup
+    d3[:ts] = Time.at(1_538_865_613)
+    d3 = d3.tap { |d| d.delete(:source) }
+
+    assert_equal(wf.hash_to_wf(d3),
+                 '!M 1538865613 #5 11 #15 2.533 #8 -15 #12 1000000.0 ' \
+                 "test.distribution source=#{Socket.gethostname} " \
+                 'tag1="val1" tag2="val2"')
+  end
+
+  def test_array2dist
+    assert_equal(wf.array2dist([[1, 4], [6, 5]]), '#1 4 #6 5')
+    assert_equal(wf.array2dist([[12, 4.235]]), '#12 4.235')
+  end
+end
+
+# A mock socket
+#
+class Mocket
+  def puts(socket); end
+
+  def close; end
+end

data/spec/wavefront-sdk/paginator/base_spec.rb

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby
+
+require_relative '../../spec_helper'
+require_relative '../../../lib/wavefront-sdk/paginator/base'
+
+# Stub for ApiCaller class
+#
+class FakeApiCaller
+  def respond(args); end
+end
+
+# Stub for connection object
+#
+class FakeConn
+  def get(*args); end
+end
+
+# Paginator tests
+#
+class WavefrontPaginatorBaseTest < MiniTest::Test
+  attr_reader :wf, :apicaller, :conn
+
+  def setup
+    @apicaller = FakeApiCaller.new
+    @conn      = FakeConn.new
+    args = [nil, { offset: 3, limit: :lazy }]
+
+    @wf = Wavefront::Paginator::Base.new(apicaller, conn, :get, args)
+  end
+
+  def _test_limit_and_offset
+    assert_equal({ limit: nil, offset: nil }, wf.limit_and_offset([]))
+    assert_equal({ limit: nil, offset: 10 },
+                 wf.limit_and_offset([nil, { offset: 10 }]))
+    assert_equal({ limit: 15, offset: nil },
+                 wf.limit_and_offset([nil, { limit: 15 }]))
+    assert_equal({ limit: 95, offset: 0 },
+                 wf.limit_and_offset([nil, { limit: 95, offset: 0 }]))
+    assert_equal({ limit: 95, offset: 0 },
+                 wf.limit_and_offset([{ a: 1 }, { limit: 95, offset: 0 }]))
+    assert_equal({ limit: 33, offset: 6 },
+                 wf.limit_and_offset([{ offset: 1 },
+                                      { limit: 33, offset: 6 }]))
+  end
+
+  def test_user_page_size
+    assert_equal(3, wf.user_page_size([offset: 3]))
+    assert_equal(15, wf.user_page_size([nil, { offset: 15, limit: :lazy }]))
+    assert_equal(25, wf.user_page_size([nil, { offset: 25 },
+                                        { limit: :lazy }]))
+    assert_equal(999, wf.user_page_size([a: 3, b: 2]))
+  end
+
+  def test_set_pagination
+    assert_equal([nil, { offset: 5, limit: 10 }],
+                 wf.set_pagination(5, 10, [nil, { offset: 0, limit: 100 }]))
+    assert_equal([nil, { a: 1, b: 2 }],
+                 wf.set_pagination(5, 10, [nil, { a: 1, b: 2 }]))
+    assert_equal([nil, { offset: 15 }, { a: 2 }, { limit: 20 }],
+                 wf.set_pagination(15, 20, [nil, { offset: 0 }, { a: 2 },
+                                            { limit: 100 }]))
+    assert_equal(['str1', { offset: 5, limit: 10 }, [1, 2]],
+                 wf.set_pagination(5, 10, ['str1',
+                                           { offset: 0, limit: 100 },
+                                           [1, 2]]))
+  end
+end

data/spec/wavefront-sdk/paginator/post_spec.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+
+require 'json'
+require_relative '../../spec_helper'
+require_relative '../../../lib/wavefront-sdk/paginator/post'
+
+# Stub for ApiCaller class
+#
+class FakeApiCaller
+  def respond(_args)
+    puts 'merp'
+  end
+end
+
+# Stub for connection object
+#
+class FakeConn
+  def get(*args)
+    puts args
+  end
+end
+
+# Test POST pagination
+#
+class WavefrontPaginatorPostTest < MiniTest::Test
+  attr_reader :wf, :apicaller, :conn
+
+  def setup
+    @apicaller = FakeApiCaller.new
+    @conn      = FakeConn.new
+    args = [nil, { offset: 3, limit: :lazy }]
+    @wf = Wavefront::Paginator::Post.new(apicaller, conn, :post, args)
+  end
+
+  def test_body_as
+    bo1 = [nil, { offset: 3, limit: 'lazy' }]
+    bs1 = [nil, '{"offset":3,"limit":"lazy"}']
+
+    bo2 = ['thing', { offset: 3, limit: 'lazy', a: 2 }, { c: 3 }]
+    bs2 = ['thing', '{"offset":3,"limit":"lazy","a":2}', { c: 3 }]
+
+    assert_equal(bo1, wf.body_as(Hash, bo1))
+    assert_equal(bo1, wf.body_as(Hash, bs1))
+    assert_equal(bs1, wf.body_as(String, bs1))
+    assert_equal(bo1, wf.body_as(Hash, bs1))
+    assert_equal([], wf.body_as(Hash, 'plain string'))
+
+    assert_equal(bo2, wf.body_as(Hash, bo2))
+    assert_equal(bo2, wf.body_as(Hash, bs2))
+    assert_equal(bs2, wf.body_as(String, bs2))
+    assert_equal(bo2, wf.body_as(Hash, bs2))
+  end
+end

data/spec/wavefront-sdk/report_spec.rb

@@ -1,8 +1,10 @@
 #!/usr/bin/env ruby
 
 require_relative '../spec_helper'
+require_relative 'resources/dummy_points'
 
 HEADERS = POST_HEADERS.merge('Content-Type': 'application/octet-stream')
+
 # Unit tests for Report class
 #
 class WavefrontReportTest < WavefrontTestBase
@@ -11,7 +13,7 @@ class WavefrontReportTest < WavefrontTestBase
   end
 
   def test_write
-    should_work(:write, POINT, ['?f=graphite_v2', nil],
+    should_work(:write, POINT, ['?f=wavefront', nil],
                 :post, HEADERS, POINT_L)
   end
 end

data/spec/wavefront-sdk/search_spec.rb

@@ -44,4 +44,29 @@ class WavefrontSearchTest < WavefrontTestBase
     assert_raises(ArgumentError) { wf.raw_facet_search }
     assert_raises(ArgumentError) { wf.raw_facet_search('ALERT', 'junk') }
   end
+
+  def test_body
+    q = [{ key: 'k1', value: 'v1', matchingMethod: 'EXACT' },
+         { key: 'k2', value: 'v2', matchingMethod: 'CONTAINS' }]
+
+    r1 = wf.body(q, {})
+
+    assert_equal({ limit: 10,
+                   offset: 0,
+                   query:  [
+                     { key: 'k1', value: 'v1', matchingMethod: 'EXACT' },
+                     { key: 'k2', value: 'v2', matchingMethod: 'CONTAINS' }
+                   ],
+                   sort: { field: 'k1', ascending: true } },
+                 r1)
+
+    r2 = wf.body(q, limit: 50)
+    assert_equal(50, r2[:limit])
+    assert_equal(0, r2[:offset])
+
+    r3 = wf.body([], {})
+
+    assert_equal({ limit: 10, offset: 0 }, r3)
+    assert_equal(0, r3[:offset])
+  end
 end