wavefront-cli 2.1.4 → 2.1.5

data/lib/wavefront-cli/query.rb

@@ -9,37 +9,54 @@ module WavefrontCli
     include Wavefront::Mixins
 
     def do_default
-      opts = {
-        autoEvents:             options[:events],
-        i:                      options[:inclusive],
-        summarization:          options[:summarize] || 'mean',
-        listMode:               true,
-        strict:                 true,
-        includeObsoleteMetrics: options[:obsolete],
-        sorted:                 true
-      }
+      t_start     = window_start
+      t_end       = window_end
+      granularity = granularity(t_start, t_end)
+      t_end       = nil unless options[:end]
 
-      options[:start] = if options[:start]
-                          parse_time(options[:start], true)
-                        else
-                          (Time.now - 600).to_i
-                        end
+      wf.query(options[:'<query>'], granularity, t_start, t_end, q_opts)
+    end
 
-      if options[:end]
-        options[:end] = parse_time(options[:end], true)
-        t_end = options[:end]
+    # @return [Hash] options for the SDK query method
+    #
+    def q_opts
+      ret = { autoEvents:             options[:events],
+              i:                      options[:inclusive],
+              summarization:          options[:summarize] || 'mean',
+              listMode:               true,
+              strict:                 true,
+              includeObsoleteMetrics: options[:obsolete],
+              sorted:                 true }
+
+      ret[:n] = options[:name] if options[:name]
+      ret[:p] = options[:points] if options[:points]
+      ret
+    end
+
+    # @return [Integer] start of query window. If one has been
+    #   given, that; if not, ten minutes ago
+    #
+    def window_start
+      if options[:start]
+        parse_time(options[:start], true)
       else
-        t_end = Time.now.to_i
+        (Time.now - 600).to_i
       end
+    end
 
-      options[:granularity] ||= default_granularity((t_end -
-                                                    options[:start]).to_i)
-
-      opts[:n] = options[:name] if options[:name]
-      opts[:p] = options[:points] if options[:points]
+    # @return [Integer] end of query window. If one has been
+    #   given, that; if not, now
+    #
+    def window_end
+      if options[:end]
+        parse_time(options[:end], true)
+      else
+        Time.now.to_i
+      end
+    end
 
-      wf.query(options[:'<query>'], options[:granularity],
-               options[:start], options[:end] || nil, opts)
+    def granularity(t_start, t_end)
+      options[:granularity] || default_granularity(t_start - t_end)
     end
 
     # Work out a sensible granularity based on the time window
@@ -47,9 +64,9 @@ module WavefrontCli
     def default_granularity(window)
       if window < 300
         :s
-      elsif window < 10800
+      elsif window < 10_800
         :m
-      elsif window < 259200
+      elsif window < 259_200
         :h
       else
         :d

data/lib/wavefront-cli/string.rb

@@ -8,9 +8,8 @@ class String
   # @param indent [Integer] size of hanging indent, in chars
   #
   def cmd_fold(tw = TW, indent = 10)
-    #gsub(/\s(?=\w+\])/, '^').scan_line(tw - 8).join("\n" + ' ' * indent)
-    gsub(/(-\w) /, "\\1^").scan_line(tw - 12).join("\n" + ' ' * indent)
-      .tr('^', ' ')
+    gsub(/(-\w) /, '\\1^').scan_line(tw - 12).join("\n" + ' ' * indent)
+                          .tr('^', ' ')
   end
 
   # Wrapper around #fold()
@@ -27,7 +26,6 @@ class String
   # for option folding, now addded the prefix parameter to make it
   # more general.
   #
-  # rubocop:disable Metrics/AbcSize
   #
   # @param tw [Integer] terminal width
   # @param indent [Integer] size of hanging indent, in chars
@@ -35,17 +33,17 @@ class String
   # @return [String] the folded line
   #
   def fold(tw = TW, indent = 10, prefix = '')
-    chunks = self.scan_line(tw - 8)
+    chunks = scan_line(tw - 8)
 
-    line_1 = format("%s%s\n", prefix, chunks.shift)
+    first_line = format("%s%s\n", prefix, chunks.shift)
 
-    return line_1 if chunks.empty?
+    return first_line if chunks.empty?
 
     rest = chunks.join(' ').scan_line(tw - indent - 5).map do |l|
       prefix + ' ' * indent + l
     end
 
-    line_1 + rest.join("\n") + "\n"
+    first_line + rest.join("\n") + "\n"
   end
 
   # @param width [Integer] length of longest string (width of
@@ -59,26 +57,16 @@ class String
 
   def to_seconds
     begin
-      number, unit = self.match(/^(\d+)([smhdw])$/).captures
-    rescue
+      number, unit = match(/^(\d+)([smhdw])$/).captures
+    rescue NoMethodError
       raise ArgumentError
     end
 
-    factor = case unit
-             when 's'
-               1
-             when 'm'
-               60
-             when 'h'
-               3600
-             when 'd'
-               86400
-             when 'w'
-               604800
-             else
-               raise ArgumentError
-             end
+    number.to_i * unit_factor(unit.to_sym)
+  end
 
-    number.to_i * factor
+  def unit_factor(unit)
+    factors = { s: 1, m: 60, h: 3600, d: 86_400, w: 604_800 }
+    factors[unit] || 1
   end
 end

data/lib/wavefront-cli/version.rb

@@ -1 +1 @@
-WF_CLI_VERSION = '2.1.4'.freeze
+WF_CLI_VERSION = '2.1.5'.freeze

data/lib/wavefront-cli/write.rb

@@ -5,7 +5,6 @@ module WavefrontCli
   #
   # Send points to a proxy.
   #
-  # rubocop:disable Metrics/ClassLength
   class Write < Base
     attr_reader :fmt
     include Wavefront::Mixins
@@ -13,9 +12,6 @@ module WavefrontCli
     def mk_creds
       { proxy: options[:proxy], port: options[:port] || 2878 }
     end
-
-    # rubocop:disable Metrics/AbcSize
-    # rubocop:disable Metrics/MethodLength
     def do_point
       p = { path:  options[:'<metric>'],
             value: options[:'<value>'].to_f,
@@ -221,7 +217,7 @@ module WavefrontCli
     #
     def valid_timestamp?(ts)
       (ts.is_a?(Integer) || ts.match(/^\d+$/)) &&
-        ts.to_i > 946684800 && ts.to_i < (Time.now.to_i + 31557600)
+        ts.to_i > 946_684_800 && ts.to_i < (Time.now.to_i + 31_557_600)
     end
 
     def validate_opts
@@ -239,9 +235,8 @@ module WavefrontCli
     end
 
     def load_data(file)
-      IO.read(file)
-    rescue
       raise "Cannot open file '#{file}'." unless file.exist?
+      IO.read(file)
     end
   end
 end

data/spec/.rubocop.yml

@@ -0,0 +1,16 @@
+AllCops:
+  TargetRubyVersion: 2.2
+
+# Allow long blocks of tests
+#
+Metrics/BlockLength:
+  Max: 120
+
+Metrics/MethodLength:
+  Max: 80
+
+Metrics/AbcSize:
+  Max: 45
+
+Metrics/ClassLength:
+  Max: 300

data/spec/spec_helper.rb

@@ -9,35 +9,34 @@ require_relative '../lib/wavefront-cli/controller'
 
 unless defined?(CMD)
   CMD = 'wavefront'.freeze
-  ENDPOINT = 'metrics.wavefront.com'
-  TOKEN = '0123456789-ABCDEF'
+  ENDPOINT = 'metrics.wavefront.com'.freeze
+  TOKEN = '0123456789-ABCDEF'.freeze
   RES_DIR = Pathname.new(__FILE__).dirname + 'wavefront-cli' + 'resources'
   CF = RES_DIR + 'wavefront.conf'
   CF_VAL =  IniFile.load(CF)
   JSON_POST_HEADERS = {
-      :'Content-Type' => 'application/json', :Accept => 'application/json'
+    '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
+  CMDS = %w[alert integration dashboard event link message metric
+            proxy query savedsearch source user window webhook write].freeze
 
-  BAD_TAG="*BAD TAG*"
+  BAD_TAG = '*BAD_TAG*'.freeze
   TW = 80
 end
 
 # 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 }]
-  ]
+  [["-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
@@ -48,12 +47,12 @@ end
 #  command
 # @param call [Hash]
 #
+# rubocop:disable Metrics/AbcSize
 def cmd_to_call(word, args, call, sdk_class = nil)
   headers = { 'Accept':          /.*/,
               'Accept-Encoding': /.*/,
               'Authorization':  'Bearer 0123456789-ABCDEF',
-              'User-Agent':     "wavefront-cli-#{WF_CLI_VERSION}"
-            }
+              'User-Agent':     "wavefront-cli-#{WF_CLI_VERSION}" }
 
   sdk_class ||= Object.const_get("WavefrontCli::#{word.capitalize}")
 
@@ -67,23 +66,25 @@ def cmd_to_call(word, args, call, sdk_class = nil)
         cmd = "#{word} #{args} #{opts} #{fmt}"
         uri = 'https://' + vals[:e] + call[:path]
         h = headers.dup
-        h[:'Authorization'] = "Bearer #{vals[:t]}"
+        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)
+            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)
+            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)
+          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)
@@ -109,8 +110,8 @@ 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)
+      _out, err = fail_command("#{cmd} #{sc}")
+      assert_match(/^'.*' is not a valid #{thing}.\n$/, err)
     end
   end
 end
@@ -118,8 +119,8 @@ 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"
+      _out, err = fail_command("#{cmd} #{sc}")
+      assert_equal(err, "'#{BAD_TAG}' is not a valid tag.\n")
     end
   end
 end
@@ -127,8 +128,8 @@ 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)
+      _out, err = fail_command("#{cmd} #{sc}")
+      assert_match(/^'.+' is not a valid \w/, err)
     end
   end
 end
@@ -142,7 +143,7 @@ def missing_creds(cmd, subcmds)
       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)
+        assert_match(%r{config file '/f' not found.}, out)
       end
     end
   end
@@ -151,7 +152,7 @@ end
 # Generic list tests, needed by most commands
 #
 def list_tests(cmd, pth = nil, k = nil)
-  pth = cmd unless pth
+  pth ||= cmd
   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)
@@ -163,34 +164,33 @@ 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, "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 })
+              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 })
+              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" })
+              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 })
+              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}"])
+  invalid_tags(cmd, ["tag add #{id} #{BAD_TAG}", "tag delete #{id} #{BAD_TAG}"])
 end
 
+# stdlib extensions
+#
 class Hash
-
   # A quick way to deep-copy a hash.
   #
   def dup

data/spec/wavefront-cli/alert_spec.rb

@@ -34,14 +34,14 @@ describe "#{word} command" do
   cmd_to_call(word, "snooze #{id}",
               method: :post, path: "/api/v2/#{word}/#{id}/snooze")
   cmd_to_call(word, "search id=#{id}",
-              { method: :post, path: "/api/v2/search/#{word}",
-                body:   { limit: 10,
-                          offset: 0,
-                          query: [{key: 'id',
-                                   value: id,
-                                   matchingMethod: 'EXACT'}],
-                          sort: {field: 'id', ascending: true}},
-                headers: JSON_POST_HEADERS })
+              method: :post, path: "/api/v2/search/#{word}",
+              body:   { limit: 10,
+                        offset: 0,
+                        query: [{ key: 'id',
+                                  value: id,
+                                  matchingMethod: 'EXACT' }],
+                        sort: { field: 'id', ascending: true } },
+              headers: JSON_POST_HEADERS)
   cmd_to_call(word, "snooze -T 800 #{id}",
               method: :post,
               path:   "/api/v2/#{word}/#{id}/snooze?seconds=800")

data/spec/wavefront-cli/base_spec.rb

@@ -23,7 +23,7 @@ OPTS_CMD = {
 
 DISP_DATA = {
   a: 'string',
-  b: %w(list_1 list_2)
+  b: %w[list_1 list_2]
 }.freeze
 
 # Test base class

data/spec/wavefront-cli/cloudintegration_spec.rb

@@ -17,13 +17,13 @@ describe 'cloudintegration command' do
   cmd_to_call(word, "delete #{id}",
               { method: :delete, path: "/api/v2/cloudintegration/#{id}" }, k)
   cmd_to_call(word, "search -L 100 id~#{id}",
-              { method: :post, path: "/api/v2/search/cloudintegration",
-                body:   { limit: "100",
+              { method: :post, path: '/api/v2/search/cloudintegration',
+                body:   { limit: '100',
                           offset: 0,
-                          query: [{key: 'id',
-                                   value: id,
-                                   matchingMethod: 'CONTAINS'}],
-                          sort: {field: 'id', ascending: true}},
+                          query: [{ key: 'id',
+                                    value: id,
+                                    matchingMethod: 'CONTAINS' }],
+                          sort: { field: 'id', ascending: true } },
                 headers: JSON_POST_HEADERS }, WavefrontCli::CloudIntegration)
   cmd_to_call(word, "undelete #{id}",
               { method: :post,

data/spec/wavefront-cli/commands/base_spec.rb

@@ -64,7 +64,6 @@ class WavefrontCommmandBaseTest < MiniTest::Test
     assert_equal(wf.sdk_file, word.downcase)
   end
 
-  # rubocop:disable Metrics/AbcSize
   def test_commands
     assert wf.commands.start_with?("Usage:\n")
     assert wf.commands.match(/ --help$/)
@@ -90,7 +89,6 @@ class WavefrontCommmandBaseTest < MiniTest::Test
     assert_equal(wf.options.split("\n").select(&:empty?).size, 1)
   end
 
-  # rubocop:disable Metrics/MethodLength
   def test_opt_row
     assert_equal(wf.opt_row('-s, --short    short option', 10),
                  "  -s, --short    short option\n")

data/spec/wavefront-cli/controller_spec.rb

@@ -16,22 +16,20 @@ class WavefrontCliHelpTest < MiniTest::Test
   end
 
   def test_version
-    WavefrontCliController.new(%w(--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))
+    WavefrontCliController.new(%w[--help])
   rescue SystemExit => e
     assert_equal(1, e.status)
     assert_match(/^Commands:$/, e.message)
     CMDS.each { |cmd| assert_match(/^  #{cmd} /, e.message) }
   end
 
-  # rubocop:disable Metrics/AbcSize
-  # rubocop:disable Metrics/MethodLength
   def test_command_help
     CMDS.each do |cmd|
       begin
@@ -56,6 +54,8 @@ class Giblets < WavefrontCliController
   def initialize; end
 end
 
+# Here's the subclass
+#
 class GibletsTest < MiniTest::Test
   attr_reader :wfc
 
@@ -66,6 +66,6 @@ class GibletsTest < MiniTest::Test
   def test_sanitize_keys
     h_in = { '--help': true, stuff: false, 'key' => 'value' }
     assert_equal(wfc.sanitize_keys(h_in),
-                 { help: true, stuff: false, key: 'value' })
+                 help: true, stuff: false, key: 'value')
   end
 end

data/spec/wavefront-cli/dashboard_spec.rb

@@ -30,14 +30,14 @@ describe "#{word} command" do
   end
 
   cmd_to_call(word, "search id=#{id}",
-              { method: :post, path: "/api/v2/search/#{word}",
-                body:   { limit: 10,
-                          offset: 0,
-                          query: [{key: 'id',
-                                   value: id,
-                                   matchingMethod: 'EXACT'}],
-                          sort: {field: 'id', ascending: true}},
-                headers: JSON_POST_HEADERS })
+              method: :post, path: "/api/v2/search/#{word}",
+              body:   { limit: 10,
+                        offset: 0,
+                        query: [{ key: 'id',
+                                  value: id,
+                                  matchingMethod: 'EXACT' }],
+                        sort: { field: 'id', ascending: true } },
+              headers: JSON_POST_HEADERS)
 
   cmd_to_call(word, "undelete #{id}",
               method: :post, path: "/api/v2/#{word}/#{id}/undelete")