wavefront-cli 0.0.2

data/spec/spec_helper.rb

@@ -0,0 +1,197 @@
+require 'webmock/minitest'
+require 'spy/integration'
+require 'inifile'
+require 'minitest'
+require 'minitest/autorun'
+require 'minitest/spec'
+require 'pathname'
+require_relative '../lib/wavefront-cli/controller'
+
+CMD = 'wavefront'.freeze
+ENDPOINT = 'metrics.wavefront.com'
+TOKEN = '0123456789-ABCDEF'
+RES_DIR = Pathname.new(__FILE__).dirname + 'wavefront-cli' + 'resources'
+CF = RES_DIR + 'conf.yaml'
+CF_VAL =  IniFile.load(CF)
+JSON_POST_HEADERS = {
+    :'Content-Type' => 'application/json', :Accept => 'application/json'
+}.freeze
+
+CMDS = %w(alert integration dashboard event link message metric
+          proxy query savedsearch source user window webhook write).freeze
+
+BAD_TAG="*BAD TAG*"
+TW = 80
+
+# Return an array of CLI permutations and the values to which they relate
+#
+def permutations
+  [ ["-t #{TOKEN} -E #{ENDPOINT}", { t: TOKEN, e: ENDPOINT }],
+    ["-c #{CF}", { t: CF_VAL['default']['token'],
+                   e: CF_VAL['default']['endpoint'] }],
+    ["-c #{CF} -P other", { t: CF_VAL['other']['token'],
+                            e: CF_VAL['other']['endpoint'] }],
+    ["-c #{CF} -P other -t #{TOKEN}", { t: TOKEN,
+                                        e: CF_VAL['other']['endpoint'] }],
+    ["-c #{CF} -E #{ENDPOINT}", { t: CF_VAL['default']['token'],
+                                  e: ENDPOINT }]
+  ]
+end
+
+# Match a command to the final API call it should produce, applying options in
+# as many combinations as possible, and ensuring the requisite display methods
+# are called.
+#
+# @param cmd [String] command line args to supply to the Wavefront
+#  command
+# @param call [Hash]
+#
+def cmd_to_call(word, args, call, sdk_class = nil)
+  headers = { 'Accept':          /.*/,
+              'Accept-Encoding': /.*/,
+              'Authorization':  'Bearer 0123456789-ABCDEF',
+              'User-Agent':     /wavefront-sdk .*/,
+            }
+
+  sdk_class ||= Object.const_get("WavefrontCli::#{word.capitalize}")
+
+  headers.merge!(call[:headers]) if call.key?(:headers)
+  method = call[:method] || :get
+  fmts = call[:formats] ? ['-f json', '-f yaml', '-f human', ''] : ['']
+
+  permutations.each do |opts, vals|
+    describe "with #{word} #{args}" do
+      fmts.each do |fmt|
+        cmd = "#{word} #{args} #{opts} #{fmt}"
+        uri = 'https://' + vals[:e] + call[:path]
+        h = headers.dup
+        h[:'Authorization'] = "Bearer #{vals[:t]}"
+
+        it "runs #{cmd} and makes the correct API call" do
+
+          if call.key?(:body)
+            stub_request(method, uri).with(headers: h, body: call[:body]).
+              to_return(body: {}.to_json, status: 200)
+          else
+            stub_request(method, uri).with(headers: h).
+              to_return(body: {}.to_json, status: 200)
+          end
+
+          require "wavefront-sdk/#{sdk_class.name.split('::').last.downcase}"
+          r = Spy.on_instance_method(Object.const_get(
+            "Wavefront::#{sdk_class.name.split('::').last}"),
+            :respond).and_return({})
+          d = Spy.on_instance_method(sdk_class,  :display)
+          WavefrontCliController.new(cmd.split)
+          assert d.has_been_called?
+          assert_requested(method, uri, headers: h)
+          WebMock.reset!
+        end
+      end
+    end
+  end
+end
+
+# Run a command we expect to fail, returning stdout and stderr
+#
+def fail_command(cmd)
+  capture_io do
+    begin
+      WavefrontCliController.new(cmd.split).run
+    rescue SystemExit => e
+      assert_equal(1, e.status)
+    end
+  end
+end
+
+def invalid_something(cmd, subcmds, thing)
+  subcmds.each do |sc|
+    it "fails '#{sc}' because of an invalid #{thing}" do
+      out, err = fail_command("#{cmd} #{sc}")
+       assert_match(/^'.*' is not a valid #{thing}.\n$/, err)
+    end
+  end
+end
+
+def invalid_tags(cmd, subcmds)
+  subcmds.each do |sc|
+    it "fails '#{sc}' because of an invalid tag" do
+      out, err = fail_command("#{cmd} #{sc}")
+       assert out = "'#{BAD_TAG}' is not a valid tag.\n"
+    end
+  end
+end
+
+def invalid_ids(cmd, subcmds)
+  subcmds.each do |sc|
+    it "fails '#{sc}' on invalid input" do
+      out, err = fail_command("#{cmd} #{sc}")
+       assert_match(/^'.+' is not a valid \w/, err)
+    end
+  end
+end
+
+# Without a token, you should get an error. If you don't supply an endpoint, it
+# will default to 'metrics.wavefront.com'.
+#
+def missing_creds(cmd, subcmds)
+  describe 'commands with missing credentials' do
+    subcmds.each do |subcmd|
+      it "'#{subcmd}' errors and tells the user to use a token" do
+        out, err = fail_command("#{cmd} #{subcmd} -c /f")
+        assert_match(/supply an API token/, err)
+        assert_match(/config file '\/f' not found./, out)
+      end
+    end
+  end
+end
+
+# Generic list tests, needed by most commands
+#
+def list_tests(cmd, pth = nil, k = nil)
+  pth = cmd unless pth
+  cmd_to_call(cmd, 'list', { path: "/api/v2/#{pth}?limit=100&offset=0" }, k)
+  cmd_to_call(cmd, 'list -L 50', { path: "/api/v2/#{pth}?limit=50&offset=0" },
+              k)
+  cmd_to_call(cmd, 'list -L 20 -o 8',
+              { path: "/api/v2/#{pth}?limit=20&offset=8" }, k)
+  cmd_to_call(cmd, 'list -o 60', { path: "/api/v2/#{pth}?limit=100&offset=60" },
+              k)
+end
+
+def tag_tests(cmd, id, bad_id, pth = nil)
+  pth ||= cmd
+  cmd_to_call(cmd, "tags #{id}", { path: "/api/v2/#{pth}/#{id}/tag" })
+  cmd_to_call(cmd, "tag set #{id} mytag",
+              { method: :post,
+                path:    "/api/v2/#{pth}/#{id}/tag",
+                body:    %w(mytag).to_json,
+                headers: JSON_POST_HEADERS })
+  cmd_to_call(cmd, "tag set #{id} mytag1 mytag2",
+              { method: :post,
+                path: "/api/v2/#{pth}/#{id}/tag",
+                body: %w(mytag1 mytag2).to_json,
+                headers: JSON_POST_HEADERS })
+  cmd_to_call(cmd, "tag add #{id} mytag",
+              { method: :put, path: "/api/v2/#{pth}/#{id}/tag/mytag" })
+  cmd_to_call(cmd, "tag delete #{id} mytag",
+              { method: :delete, path: "/api/v2/#{pth}/#{id}/tag/mytag" })
+  cmd_to_call(cmd, "tag clear #{id}", { method:  :post,
+                                         path:    "/api/v2/#{pth}/#{id}/tag",
+                                         body:    [].to_json,
+                                         headers: JSON_POST_HEADERS })
+  invalid_ids(cmd, ["tags #{bad_id}", "tag clear #{bad_id}",
+                    "tag add #{bad_id} mytag", "tag delete #{bad_id} mytag"])
+  invalid_tags(cmd, ["tag add #{id} #{BAD_TAG}", "tags #{id} #{BAD_TAG}",
+                     "tags #{id} tag1 #{BAD_TAG}",
+                     "tag delete #{id} #{BAD_TAG}"])
+end
+
+class Hash
+
+  # A quick way to deep-copy a hash.
+  #
+  def dup
+    Marshal.load(Marshal.dump(self))
+  end
+end

data/spec/wavefront-cli/alert_spec.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+
+id = '1481553823153'
+bad_id = '__bad_id__'
+word = 'alert'
+
+require_relative '../spec_helper'
+require_relative "../../lib/wavefront-cli/#{word}"
+
+describe "#{word} command" do
+  missing_creds(word, ['list', "describe #{id}", "snooze #{id}",
+                       "delete #{id}", "undelete #{id}", "history #{id}"])
+  list_tests(word)
+  cmd_to_call(word, "describe #{id}", path: "/api/v2/#{word}/#{id}")
+  cmd_to_call(word, "describe -v 7 #{id}",
+              path: "/api/v2/#{word}/#{id}/history/7")
+  cmd_to_call(word, "history #{id}", path: "/api/v2/#{word}/#{id}/history")
+
+  it 'deletes with a check on inTrash' do
+    stub_request(:get,
+                 'https://other.wavefront.com/api/v2/alert/1481553823153').
+        with(headers: {'Accept': '*/*',
+                       'Accept-Encoding': 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
+                       'Authorization': 'Bearer 0123456789-ABCDEF',
+                       'User-Agent': /wavefront.*/}).
+          to_return(:status => 200, :body => "", :headers => {})
+    cmd_to_call(word, "delete #{id}",
+                method: :delete, path: "/api/v2/#{word}/#{id}")
+  end
+  cmd_to_call(word, "undelete #{id}",
+              method: :post, path: "/api/v2/#{word}/#{id}/undelete")
+  cmd_to_call(word, "snooze #{id}",
+              method: :post, path: "/api/v2/#{word}/#{id}/snooze")
+  cmd_to_call(word, "snooze -T 800 #{id}",
+              method: :post,
+              path:   "/api/v2/#{word}/#{id}/snooze?seconds=800")
+  cmd_to_call(word, "unsnooze #{id}",
+              method: :post, path: "/api/v2/#{word}/#{id}/unsnooze")
+  cmd_to_call(word, 'summary', path: "/api/v2/#{word}/summary")
+  invalid_ids(word, ["describe #{bad_id}", "delete #{bad_id}",
+                     "undelete #{bad_id}", "snooze #{bad_id}",
+                     "snooze -T 500 #{bad_id}"])
+  tag_tests(word, id, bad_id)
+end

data/spec/wavefront-cli/base_spec.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+
+require_relative '../spec_helper'
+require_relative '../../lib/wavefront-cli/base'
+require 'spy'
+require 'spy/integration'
+
+OPTS = {
+  endpoint: 'test.wavefront.com',
+  token:    '0123456789-ABCDEF',
+  debug:    false,
+  noop:     true
+}.freeze
+
+OPTS_CMD = {
+  endpoint: 'test.wavefront.com',
+  token:    '0123456789-ABCDEF',
+  debug:    false,
+  noop:     true,
+  test:     true,
+  cmd:      true
+}.freeze
+
+DISP_DATA = {
+  a: 'string',
+  b: %w(list_1 list_2)
+}.freeze
+
+class WavefrontCliBaseTest < MiniTest::Test
+  attr_reader :wf, :wf_cmd
+
+  def setup
+    @wf = WavefrontCli::Base.new(OPTS)
+    @wf_cmd = WavefrontCli::Base.new(OPTS_CMD)
+    wf_cmd.define_singleton_method(:do_test_cmd) { true }
+  end
+
+  def test_mk_creds
+    assert_equal wf.mk_creds, endpoint: 'test.wavefront.com',
+                              token:    '0123456789-ABCDEF'
+  end
+
+  def test_dispatch
+    assert_raises(WavefrontCli::Exception::UnhandledCommand) { wf.dispatch }
+    #assert_equal(wf_cmd.dispatch, nil)
+  end
+end

data/spec/wavefront-cli/cli_help_spec.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+
+require_relative '../../lib/wavefront-cli/controller'
+require_relative '../spec_helper'
+
+# Be sure the CLI behaves properly when people ask for help
+#
+class WavefrontCliHelpTest < MiniTest::Test
+  def test_no_args
+    WavefrontCliController.new([])
+  rescue SystemExit => e
+    assert_equal(1, e.status)
+    assert_match(/^Usage/, e.message)
+    assert_match(/^  wavefront --version$/, e.message)
+    assert_match(/^  wavefront --help$/, e.message)
+  end
+
+  def test_version
+    WavefrontCliController.new(%w(--version))
+  rescue SystemExit => e
+    assert_equal(1, e.status)
+    assert_match(/^\d+\.\d+\.\d+$/, e.message)
+  end
+
+  def test_help
+    WavefrontCliController.new(%w(--help))
+  rescue SystemExit => e
+    assert_equal(1, e.status)
+    assert_match(/^Commands:$/, e.message)
+    CMDS.each do |cmd|
+      assert_match(/^  #{cmd} /, e.message)
+    end
+  end
+
+  def test_command_help
+    CMDS.each do |cmd|
+      begin
+        WavefrontCliController.new([cmd, '--help'])
+      rescue SystemExit => e
+        assert_equal(1, e.status)
+        assert_match(/^Usage:/, e.message)
+        assert_match(/^  #{CMD} #{cmd} /, e.message)
+        assert_match(/^  #{CMD} #{cmd} --help$/, e.message)
+      end
+    end
+  end
+end

data/spec/wavefront-cli/cloudintegration_spec.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+require_relative '../spec_helper'
+require_relative '../../lib/wavefront-cli/cloudintegration'
+
+id = '3b56f61d-1a79-46f6-905c-d75a0f613d10'
+bad_id = '__BAD__'
+k = WavefrontCli::CloudIntegration
+word = 'integration'
+
+describe 'integration command' do
+  missing_creds(word, ['list', "describe #{id}", "delete #{id}",
+                       "undelete #{id}"])
+  list_tests(word, 'cloudintegration', k)
+  cmd_to_call(word, "describe #{id}",
+              { path: "/api/v2/cloudintegration/#{id}" }, k)
+  cmd_to_call(word, "delete #{id}",
+              { method: :delete, path: "/api/v2/cloudintegration/#{id}" }, k)
+  cmd_to_call(word, "undelete #{id}",
+              { method: :post,
+                path:    "/api/v2/cloudintegration/#{id}/undelete" }, k)
+  invalid_ids(word, ["describe #{bad_id}", "delete #{bad_id}",
+                     "undelete #{bad_id}"])
+end

data/spec/wavefront-cli/dashboard_spec.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+id = 'test_dashboard'
+bad_id = '>_<'
+word = 'dashboard'
+
+require_relative '../spec_helper'
+require_relative "../../lib/wavefront-cli/#{word}"
+
+describe "#{word} command" do
+  missing_creds(word, ['list', "describe #{id}", "delete #{id}",
+                       "undelete #{id}", "history #{id}"])
+  list_tests(word)
+  cmd_to_call(word, "describe #{id}", path: "/api/v2/#{word}/#{id}")
+  cmd_to_call(word, "describe -v 7 #{id}",
+              path: "/api/v2/#{word}/#{id}/history/7")
+  cmd_to_call(word, "history #{id}", path: "/api/v2/#{word}/#{id}/history")
+
+  it 'deletes with a check on inTrash' do
+    stub_request(:get,
+                 "https://other.wavefront.com/api/v2/#{word}/#{id}").
+        with(headers: {'Accept': '*/*',
+                       'Accept-Encoding':
+                          'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
+                       'Authorization': 'Bearer 0123456789-ABCDEF',
+                       'User-Agent': /wavefront.*/}).
+          to_return(:status => 200, :body => "", :headers => {})
+    cmd_to_call(word, "delete #{id}",
+                method: :delete, path: "/api/v2/#{word}/#{id}")
+  end
+
+  cmd_to_call(word, "undelete #{id}",
+              method: :post, path: "/api/v2/#{word}/#{id}/undelete")
+  invalid_ids(word, ["describe #{bad_id}", "delete #{bad_id}",
+                     "undelete #{bad_id}"])
+  tag_tests(word, id, bad_id)
+end

data/spec/wavefront-cli/event_spec.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+id = '1481553823153:testev'
+bad_id = '__bad_id__'
+word = 'event'
+
+require_relative '../spec_helper'
+require_relative "../../lib/wavefront-cli/#{word}"
+
+describe "#{word} command" do
+  missing_creds(word, ['list', "describe #{id}", "create #{id}",
+                       "close #{id}", "delete #{id}"])
+  cmd_to_call(word, "describe #{id}", path: "/api/v2/#{word}/#{id}")
+  cmd_to_call(word, "create -N #{id}",
+              method: :post, path: "/api/v2/#{word}")
+  cmd_to_call(word, "close #{id}",
+              method: :post, path: "/api/v2/#{word}/#{id}/close")
+  tag_tests(word, id, bad_id)
+end

data/spec/wavefront-cli/externallink_spec.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+require_relative '../spec_helper'
+require_relative '../../lib/wavefront-cli/externallink'
+
+id = 'lq6rPlSg2CFMSrg6'
+bad_id = '__BAD__'
+k = WavefrontCli::ExternalLink
+word = 'link'
+
+describe "#{word} command" do
+  missing_creds(word, ['list', "describe #{id}", "delete #{id}"])
+  list_tests(word, 'extlink', k)
+  cmd_to_call(word, "describe #{id}", { path: "/api/v2/extlink/#{id}" }, k)
+  cmd_to_call(word, "delete #{id}",
+              { method: :delete, path: "/api/v2/extlink/#{id}" }, k)
+  invalid_ids(word, ["describe #{bad_id}", "delete #{bad_id}"])
+end

data/spec/wavefront-cli/maintanancewindow_spec.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+require_relative '../spec_helper'
+require_relative '../../lib/wavefront-cli/maintenancewindow'
+
+id = '1493324005091'
+bad_id = '__BAD__'
+k = WavefrontCli::MaintenanceWindow
+word = 'window'
+
+describe "#{word} command" do
+  missing_creds(word, ['list', "describe #{id}", "delete #{id}"])
+  list_tests(word, 'maintenancewindow', k)
+  cmd_to_call(word, "describe #{id}",
+              { path: "/api/v2/maintenancewindow/#{id}" }, k)
+  cmd_to_call(word, "delete #{id}",
+              { method: :delete, path: "/api/v2/maintenancewindow/#{id}" }, k)
+  invalid_ids(word, ["describe #{bad_id}", "delete #{bad_id}"])
+end