wavefront-client 3.2.0 → 3.3.0

data/spec/wavefront/cli/alerts_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+require 'pathname'
+require 'json'
+require 'erb'
+
+# Valid alert states as defined in alerting.rb
+#
+states = %w(active affected_by_maintenance all invalid snoozed)
+formats = %w(ruby json human)
+
+opts = {
+  token: TEST_TOKEN,
+}
+
+describe Wavefront::Cli::Alerts do
+
+  describe '#run' do
+
+    it 'raises an exception if there are no arguments' do
+      k = Wavefront::Cli::Alerts.new(opts, [])
+      expect{k.run}.to raise_exception('Missing query.')
+    end
+  end
+
+  describe '#valid_state?' do
+    wfa = Wavefront::Alerting.new(TEST_TOKEN)
+
+    it 'raises an exception if the alert type is invalid' do
+      k = Wavefront::Cli::Alerts.new(opts, ['all'])
+      expect{k.valid_state?(wfa, 'nosuch_alert')}.to raise_exception(
+        RuntimeError, "State must be one of: #{states.join(', ')}.")
+    end
+
+    it 'accepts all valid states' do
+      k = Wavefront::Cli::Alerts.new(opts, ['all'])
+
+      states.each do |state|
+        expect(k.valid_state?(wfa, state.to_sym)).to be(true)
+      end
+    end
+  end
+
+  describe '#valid_format?' do
+    k = Wavefront::Cli::Alerts.new(opts, ['all'])
+
+    it 'accepts valid formats as symbols and strings' do
+      formats.each do |fmt|
+        expect(k.valid_format?(fmt)).to be(true)
+        expect(k.valid_format?(fmt.to_s)).to be(true)
+      end
+    end
+
+    it 'raises an exception on an invalid format' do
+      expect{k.valid_format?('junk')}.to raise_exception( RuntimeError,
+        "Output format must be one of: #{formats.join(', ')}.")
+    end
+  end
+
+  describe '#format_result' do
+    k = Wavefront::Cli::Alerts.new(opts, ['all'])
+    res = "{\n  \"a\": 1,\n  \"b\": 2\n}"
+
+    it 'raises an error on unknown type' do
+      expect{k.format_result(res, :nonsense)}.to raise_exception(RuntimeError)
+    end
+
+    it 'pretty-prints when requested' do
+      expect{k.format_result(res, :ruby)}.to match_stdout(
+        "[{\n  \"a\": 1,\n  \"b\": 2\n}]")
+    end
+
+    it 'prints as JSON when requested' do
+      expect{k.format_result(res, :json)}.to match_stdout(res)
+    end
+
+    it 'reconstructs JSON output' do
+      src = IO.read(Pathname.new(__FILE__).dirname + 'resources' +
+                'alert.raw')
+      out = IO.read(Pathname.new(__FILE__).dirname + 'resources' +
+                'alert.json')
+      expect{k.format_result(src, :json)}.to match_stdout(out)
+    end
+  end
+
+  describe '#humanize' do
+    k = Wavefront::Cli::Alerts.new(opts, ['all'])
+    src = IO.read(Pathname.new(__FILE__).dirname + 'resources' +
+                  'alert.raw')
+    #
+    # The output has to get munged a bit here because it turns out
+    # that comparing multi-line things isn't anywhere near so
+    # straightforward as I expected.
+    #
+    it 'reconstructs human output' do
+      out = ERB.new(IO.read(Pathname.new(__FILE__).dirname +
+                            'resources' + 'alert.human.erb')).result
+      expect(k.humanize(JSON.parse(src)).join("\n") + "\n").to eq(out)
+    end
+  end
+
+  describe '#human_line' do
+    k = Wavefront::Cli::Alerts.new(opts, ['all'])
+    it 'prints in the correct format' do
+      expect(k.human_line('desc', 123)).to eq('desc                  123')
+    end
+  end
+
+  describe '#human_line_created' do
+    k = Wavefront::Cli::Alerts.new(opts, ['all'])
+    it 'prints in the correct format' do
+      expect(k.human_line_created('time', 1469804504000)).to eq(
+        "time                  #{Time.at(1469804504)}")
+    end
+  end
+
+  describe '#human_line_hostsUsed' do
+    k = Wavefront::Cli::Alerts.new(opts, ['all'])
+
+    it 'just prints the header if there are no hosts' do
+      expect(k.human_line_hostsUsed('host', false)).to eq('host')
+      expect(k.human_line_hostsUsed('host', [])).to eq('host')
+      expect(k.human_line_hostsUsed('host', {})).to eq('host')
+    end
+
+    it 'prints in the correct format for a single host' do
+      expect(k.human_line_hostsUsed('host', ['hostname'])).to eq(
+        ['host                  hostname'])
+    end
+
+    it 'prints in the correct format for a multiple hosts' do
+      expect(k.human_line_hostsUsed('host', ['host1', 'host2'])).to eq(
+        ['host                  host1', '                      host2'])
+    end
+  end
+
+  describe '#indent_wrap' do
+    k = Wavefront::Cli::Alerts.new(opts, ['all'])
+
+    it 'leaves short strings unchanged' do
+      expect(k.indent_wrap('short string')).to eq("short string")
+    end
+
+    it 'wraps long strings with a hanging indent' do
+      expect(k.indent_wrap('lots and lots of words which are ' +
+             'altogether far too wide for an 80 column terminal to ' +
+             'display without breaking at least once, especially with ' +
+             'a hanging indent')).to eq(
+"lots and lots of words which are altogether far too wide
+                      for an 80 column terminal to display without breaking at
+                      least once, especially with a hanging indent")
+    end
+  end
+end

data/spec/wavefront/cli/batch_write_spec.rb

@@ -0,0 +1,251 @@
+require 'pathname'
+require 'spec_helper'
+
+opts = {}
+
+describe '#run' do
+end
+
+describe '#load_data' do
+  k = Wavefront::Cli::BatchWrite.new(opts, 'write')
+
+  it 'loads in a data file' do
+    expect(k.load_data(Pathname.new(__FILE__).dirname + 'resources' +
+                       'write.parabola').length).to eq(784)
+  end
+
+  it 'raises an error if the file does not exist' do
+    expect{k.load_data(Pathname.new('/no/such/file'))}.to raise_exception(
+      RuntimeError)
+  end
+end
+
+describe '#tags_to_hash' do
+  k = Wavefront::Cli::BatchWrite.new(opts, 'write')
+
+  it 'parses a single tag' do
+    expect(k.tags_to_hash('key=value')).to eq(key: 'value')
+  end
+
+  it 'parses multiple tags' do
+    expect(k.tags_to_hash(['k1=v1', 'k2=v2', 'k3=v3'])).to eq(
+      {k1: 'v1', k2: 'v2', k3: 'v3'})
+  end
+
+  it 'skips tags with no value' do
+    expect(k.tags_to_hash(['k1=v1', 'k2v2', 'k3=v3'])).to eq(
+      {k1: 'v1', k3: 'v3'})
+  end
+
+  it 'handles tags containing an "="' do
+    expect(k.tags_to_hash(['k1=v1', 'k2=^=^', 'k3=v3'])).to eq(
+      {k1: 'v1', k2: '^=^', k3: 'v3'})
+  end
+
+  it 'silently handles things which are not arrays' do
+    expect(k.tags_to_hash({})).to eq({})
+  end
+
+  it 'deals with quoted tags' do
+    expect(k.tags_to_hash(["'k1'='v1'", '"k2"="v2"', 'k3="v3"'])).to eq(
+      {k1: 'v1', k2: 'v2', k3: 'v3'})
+  end
+end
+
+describe '#process_filedata' do
+end
+
+describe '#valid_format?' do
+  k = Wavefront::Cli::BatchWrite.new(opts, 'write')
+  context 'valid format strings' do
+    %w(v vT tv tvT mv vm mvt mtv tmv mvT vmT mvtT tmvT).each do |fmt|
+      it 'accepts #{fmt}' do
+        expect(k.valid_format?(fmt)).to be true
+      end
+    end
+  end
+
+  context 'invalid format strings' do
+    %w(Tmv m mvTt amv mmv vv mvTm).each do |fmt|
+      it "rejects #{fmt}" do
+        expect(k.valid_format?(fmt)).to be_falsey
+      end
+    end
+  end
+end
+
+describe '#valid_line?' do
+  context 'using four columns including points tags' do
+    k = Wavefront::Cli::BatchWrite.new(opts, 'write')
+    k.setup_fmt('mtvT')
+
+    it 'accepts four columns' do
+      expect(k.valid_line?('metric time value TAG1')).to be true
+    end
+
+    it 'accepts six columns' do
+      expect(k.valid_line?('metric time value TAG1 TAG2 TAG3')).to be true
+    end
+
+    it 'rejects three columns' do
+      expect(k.valid_line?('metric time value')).to be false
+    end
+  end
+
+  context 'using two columns, not including points tags' do
+    k = Wavefront::Cli::BatchWrite.new(opts, 'write')
+    k.setup_fmt('mv')
+
+    it 'accepts two columns' do
+      expect(k.valid_line?('metric value')).to be true
+    end
+
+    it 'rejects three columns' do
+      expect(k.valid_line?('metric time TAG1')).to be false
+    end
+
+    it 'rejects one column' do
+      expect(k.valid_line?('metric')).to be false
+    end
+  end
+end
+
+describe '#valid_timestamp?' do
+  k = Wavefront::Cli::BatchWrite.new(opts, 'write')
+
+  it 'accepts a valid timestamp as an integer' do
+    expect(k.valid_timestamp?(Time.now.to_i)).to be true
+  end
+
+  it 'accepts a valid timestamp as a string' do
+    expect(k.valid_timestamp?(Time.now.to_i.to_s)).to be true
+  end
+
+  it 'rejects a timestamp too far in the past' do
+    expect(k.valid_timestamp?(Time.new('1999-12-31').to_i)).to be false
+  end
+
+  it 'rejects a timestamp too far in the future' do
+    expect(k.valid_timestamp?((Date.today + 367).to_time.to_i)).to be false
+  end
+end
+
+describe '#valid_value?' do
+  k = Wavefront::Cli::BatchWrite.new(opts, 'write')
+  context 'numerics' do
+    [-1, 0, 10, 1e6, 3.14].each do |n|
+      it "accepts #{n}" do
+        expect(k.valid_value?(n)).to be true
+      end
+    end
+  end
+
+  context 'strings' do
+    %w(-1 0 10 1e6 3.14).each do |n|
+      it "accepts #{n}" do
+        expect(k.valid_value?(n)).to be_truthy
+      end
+    end
+
+    %w(1-2 a --6 1.2.3).each do |s|
+      it "rejects #{s}" do
+        expect(k.valid_value?(s)).to be_falsey
+      end
+    end
+  end
+end
+
+describe '#process_line' do
+
+  context 'without metric prefix' do
+    k = Wavefront::Cli::BatchWrite.new(opts, 'write')
+    k.setup_opts(opts)
+
+    it 'processes a four-field line' do
+      k.setup_fmt('mtvT')
+      expect(k.process_line('test_metric 1470176262 1234 t1="v1"')).to eq(
+        { path:   'test_metric',
+          ts:     Time.at(1470176262),
+          source: HOSTNAME,
+          value:  1234,
+          tags:   { t1: 'v1' }
+      })
+    end
+
+    it 'processes a four-field line with multiple tags' do
+      k.setup_fmt('mtvT')
+      expect(k.process_line('test_metric 1470176262 3.14 t1=v1 t2=v2 t3=v3')
+            ).to eq(
+        { path:   'test_metric',
+          ts:     Time.at(1470176262),
+          source: HOSTNAME,
+          value:  3.14,
+          tags:   { t1: 'v1', t2: 'v2', t3: 'v3' }
+         })
+    end
+
+    it 'skips a blank line' do
+      expect(k.process_line('')).to be true
+    end
+
+    it 'rejects a three-field line when expecting two fields' do
+      k.setup_fmt('mvt')
+      expect(k.process_line('3 1470176262')).to be false
+      expect{k.process_line('3 1470176262')}.to match_stdout(
+        'WARNING: wrong number of fields. Skipping.')
+    end
+
+    it 'ignores dodgy tags' do
+      k.setup_fmt('mtvT')
+      expect(k.process_line('test_metric 1470176262 3.14 bad_tag')).to eq(
+        { path:   'test_metric',
+          ts:     Time.at(1470176262),
+          source: HOSTNAME,
+          value:  3.14,
+          tags:   {}
+      })
+    end
+  end
+
+  context 'with metric prefix' do
+    k = Wavefront::Cli::BatchWrite.new(opts, 'write')
+    k.setup_opts(metric: 'test_metric_3')
+
+    it 'rejects a two-field line with the fields backwards' do
+      k.setup_fmt('vt')
+      expect(k.process_line('1470176262 3.14')).to be false
+      expect{k.process_line('1470176262 3.14')}.to match_stdout(
+        "WARNING: invalid timestamp '3.14'. Skipping.")
+    end
+
+    it 'rejects a two-field line with an invalid value' do
+      k.setup_fmt('vt')
+      expect(k.process_line('x 1470176262')).to be false
+      expect{k.process_line('x 14701762624')}.to match_stdout(
+        "WARNING: invalid value 'x'. Skipping.")
+    end
+
+    it 'processes a two-field line with a CLI metric path' do
+      k.setup_fmt('tv')
+      expect(k.process_line('1470176262 3.14')
+            ).to eq(
+        { path:   'test_metric_3',
+          ts:     Time.at(1470176262),
+          source: HOSTNAME,
+          value:  3.14,
+      })
+    end
+
+    it 'processes a two-field line with spacey tags' do
+      k.setup_fmt('tvT')
+      expect(k.process_line('1470176262 3.14 t1="value 1" t2="value 2"')
+            ).to eq(
+        { path:   'test_metric_3',
+          ts:     Time.at(1470176262),
+          source: HOSTNAME,
+          value:  3.14,
+          tags:   { t1: 'value 1', t2: 'value 2' }
+      })
+    end
+  end
+end

data/spec/wavefront/cli/events_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'pathname'
+require 'json'
+
+# Valid alert states as defined in alerting.rb
+#
+states = %w(active affected_by_maintenance all invalid snoozed)
+formats = %w(ruby json human)
+
+opts = {
+  token: TEST_TOKEN,
+}
+
+describe Wavefront::Cli::Alerts do
+
+  describe '#prep_time' do
+
+    [Time.now, 1469826353, 1469826353000,
+     '2016-07-29 22:05:51 +0100', '12:00', '2001-01-01'].each do |t|
+      it "converts time like '#{t}' (#{t.class}) into epoch ms" do
+        opts[:start] = t
+        k = Wavefront::Cli::Events.new(opts, [])
+        expect(k.prep_time(:start)).to be_kind_of(Numeric)
+        expect(k.prep_time(:start)).to be > 978307000000
+      end
+    end
+  end
+
+  describe '#prep_hosts' do
+    k = Wavefront::Cli::Events.new(opts, [])
+    k.hostname = 'this-host'
+
+    it 'returns the local hostname if nothing is given' do
+      expect(k.prep_hosts).to eq ['this-host']
+    end
+
+    it 'returns multiple hosts if an array is passed' do
+      expect(k.prep_hosts('host-a,host-b,host-c')).to eq(
+        ['host-a', 'host-b', 'host-c'])
+    end
+  end
+
+end

data/spec/wavefront/cli/resources/alert.human.erb

@@ -0,0 +1,14 @@
+name                  Test Alert
+created               <%= Time.at(1469807662271 / 1000) %>
+severity              WARN
+condition             ts("dev.cli.test_metric") > 0
+displayExpression     ts("dev.cli.test_metric")
+minutes               5
+resolveAfterMinutes
+updated               <%= Time.at(1469807735018 / 1000) %>
+alertStates           CHECKING
+metricsUsed
+hostsUsed
+additionalInformation This alert has been made up to feed into the test
+                      framework for the Ruby CLI. It is not real. Even this
+                      text is just placeholder text.