collins-cli 0.1.1 → 0.2.0

data/lib/collins/cli/log.rb

@@ -0,0 +1,173 @@
+# TODO: make poll_wait tunable
+# TODO: add options to sort ascending or descending on date
+# TODO: implement searching logs (is this really useful?)
+# TODO: add duplicate line detection and compression (...)
+
+require 'collins-cli'
+require 'set'
+
+module Collins::CLI
+  class Log
+
+    include Mixins
+
+    LOG_LEVELS = Collins::Api::Logging::Severity.constants.map(&:to_s)
+    OPTIONS_DEFAULTS = {
+      :tags => [],
+      :show_all => false,
+      :poll_wait => 2,
+      :follow => false,
+      :severities => [],
+      :timeout => 20,
+      :sev_colors => {
+        'EMERGENCY'     => {:color => :red, :background => :light_blue},
+        'ALERT'         => {:color => :red},
+        'CRITICAL'      => {:color => :black, :background => :red},
+        'ERROR'         => {:color => :red},
+        'WARNING'       => {:color => :yellow},
+        'NOTICE'        => {},
+        'INFORMATIONAL' => {:color => :green},
+        'DEBUG'         => {:color => :blue},
+        'NOTE'          => {:color => :light_cyan},
+      },
+      :config => nil
+    }
+    SEARCH_DEFAULTS = {
+      :size => 20,
+      :filter => nil,
+    }
+    PROG_NAME = 'collins log'
+
+    def initialize
+      @parsed = false
+      @validated = false
+      @running = false
+      @collins = nil
+      @logs_seen = []
+      @options = OPTIONS_DEFAULTS.clone
+      @search_opts = SEARCH_DEFAULTS.clone
+    end
+
+    def parse!(argv = ARGV)
+      raise "No flags given! See --help for #{PROG_NAME} usage" if argv.empty?
+      OptionParser.new do |opts|
+        opts.banner = "Usage: #{PROG_NAME} [options]"
+        opts.on('-a','--all',"Show logs from ALL assets") {|v| @options[:show_all] = true}
+        opts.on('-n','--number LINES',Integer,"Show the last LINES log entries. (Default: #{@search_opts[:size]})") {|v| @search_opts[:size] = v}
+        opts.on('-t','--tags TAGS',Array,"Tags to work on, comma separated") {|v| @options[:tags] = v}
+        opts.on('-f','--follow',"Poll for logs every #{@options[:poll_wait]} seconds") {|v| @options[:follow] = true}
+        opts.on('-s','--severity SEVERITY[,...]',Array,"Log severities to return (Defaults to all). Use !SEVERITY to exclude one.") {|v| @options[:severities] = v.map(&:upcase) }
+        #opts.on('-i','--interleave',"Interleave all log entries (Default: groups by asset)") {|v| options[:interleave] = true}
+        opts.on('-C','--config CONFIG',String,'Use specific Collins config yaml for Collins::Client') {|v| @options[:config] = v}
+        opts.on('-h','--help',"Help") {puts opts ; exit 0}
+        opts.separator ""
+        opts.separator <<_EOE_
+Severities:
+  #{Collins::Api::Logging::Severity.to_a.map{|s| s.colorize(@options[:sev_colors][s])}.join(", ")}
+
+Examples:
+  Show last 20 logs for an asset
+    #{PROG_NAME} -t 001234
+  Show last 100 logs for an asset
+    #{PROG_NAME} -t 001234 -n100
+  Show last 10 logs for 2 assets that are ERROR severity
+    #{PROG_NAME} -t 001234,001235 -n10 -sERROR
+  Show last 10 logs all assets that are not note or informational severity
+    #{PROG_NAME} -a -n10 -s'!informational,!note'
+  Show last 10 logs for all web nodes that are provisioned having verification in the message
+    collins find -S provisioned -n webnode\$ | #{PROG_NAME} -n10 -s debug | grep -i verification
+  Tail logs for all assets that are provisioning
+    collins find -Sprovisioning,provisioned | #{PROG_NAME} -f
+_EOE_
+      end.parse!(argv)
+      @parsed = true
+      self
+    end
+
+    def validate!
+      raise "Options not yet parsed with #parse!" unless @parsed
+      unless @options[:severities].all? {|l| Collins::Api::Logging::Severity.valid?(l.tr('!','')) }
+        raise "Log severities #{@options[:severities].join(',')} are invalid! Use one of #{LOG_LEVELS.join(', ')}"
+      end
+      @search_opts[:filter] = @options[:severities].join(';')
+      if @options[:tags].empty? and not @options[:show_all]
+        # read tags from stdin. first field on the line is the tag
+        begin
+          input = ARGF.readlines
+        rescue Interrupt
+          raise "Interrupt reading tags from ARGF"
+        end
+        @options[:tags] = input.map{|l| l.split(/\s+/)[0] rescue nil}.compact.uniq
+      end
+      raise "You need to give me some assets to display logs; see --help" if @options[:tags].empty? and not @options[:show_all]
+      @validated = true
+      self
+    end
+
+    def run!
+      raise "Options not yet validated with #validate!" unless @validated
+      raise "Already running" if @running
+
+      begin
+        @running = true
+        all_logs = grab_logs
+        @logs_seen = all_logs.map(&:ID).to_set
+        output_logs(all_logs)
+        while @options[:follow]
+          sleep @options[:poll_wait]
+          logs = grab_logs
+          new_logs = logs.reject {|l| @logs_seen.include?(l.ID)}
+          output_logs(new_logs)
+          @logs_seen = @logs_seen | new_logs.map(&:ID)
+        end
+        return true
+      rescue Interrupt
+        return true
+      rescue
+        return false
+      ensure
+        @running = false
+      end
+    end
+
+    private
+
+    def output_logs(logs)
+      # colorize output before computing width of fields
+      logs.map! do |l|
+        l.TYPE = @options[:sev_colors].has_key?(l.TYPE) ? l.TYPE.colorize(@options[:sev_colors][l.TYPE]) : l.TYPE
+        l
+      end
+      # show newest last
+      sorted_logs = logs.sort_by {|l| l.CREATED }
+      tag_width = sorted_logs.map{|l| l.ASSET_TAG.length}.max
+      sev_width = sorted_logs.map{|l| l.TYPE.length}.max
+      time_width = sorted_logs.map{|l| l.CREATED.length}.max
+      sorted_logs.each do |l|
+        puts "%-#{time_width}s: %-#{sev_width}s %-#{tag_width}s %s" % [l.CREATED, l.TYPE, l.ASSET_TAG, l.MESSAGE]
+      end
+    end
+
+    def grab_logs
+      if @options[:tags].empty?
+        begin
+          collins.all_logs(@search_opts)
+        rescue => e
+          $stderr.puts "Unable to fetch logs:".colorize(@options[:sev_colors]['WARNING']) + " #{e.message}"
+          []
+        end
+      else
+        @options[:tags].flat_map do |t|
+          begin
+            collins.logs(t, @search_opts)
+          rescue => e
+            $stderr.puts "Unable to fetch logs for #{t}:".colorize(@options[:sev_colors]['WARNING']) + " #{e.message}"
+            []
+          end
+        end
+      end
+    end
+
+  end
+end
+

data/lib/collins/cli/mixins.rb

@@ -0,0 +1,73 @@
+require 'collins-cli'
+
+module Collins ; module CLI ; module Mixins
+  COLORS = {
+        'EMERGENCY'     => {:color => :red, :background => :light_blue},
+        'ALERT'         => {:color => :red},
+        'CRITICAL'      => {:color => :black, :background => :red},
+        'ERROR'         => {:color => :red},
+        'WARNING'       => {:color => :yellow},
+        'NOTICE'        => {},
+        'INFORMATIONAL' => {:color => :green},
+        'SUCCESS'       => {:color => :green},
+        'DEBUG'         => {:color => :blue},
+        'NOTE'          => {:color => :light_cyan},
+      }
+  SUCCESS = "SUCCESS".colorize(COLORS['SUCCESS'])
+  ERROR   = "ERROR".colorize(COLORS['ERROR'])
+
+  def collins
+    begin
+      @collins ||= Collins::Authenticator.setup_client timeout: @options[:timeout], config_file: @options[:config], prompt: true
+    rescue => e
+      raise "Unable to set up Collins client! #{e.message}"
+    end
+  end
+
+  def api_call desc, method, tag, *varargs, &block
+    printf "%s %s... " % [tag, desc]
+    result,message = begin
+      [collins.send(method,tag,*varargs),nil]
+    rescue => e
+      [false,e.message]
+    end
+    if result && block_given?
+      # if the call was a success, let the caller format the response
+      formatted_result = yield result
+    end
+    str = "#{result ? SUCCESS : ERROR}#{formatted_result.nil? ? '' : " (#{formatted_result})"}#{message.nil? ? nil : " (%s)" % e.message}"
+    puts str
+    result
+  end
+
+  def as_query?(attrs)
+    attrs.any?{|k,v| v.is_a? Array}
+  end
+
+  def convert_to_query(op, attrs, options)
+    # we want to support being able to query -Smaintenance:noop,:running,:provisioning_problem
+    # and not have the states ored together. Handle status/state pairs separately
+    basic_query = attrs.reject {|k,v| [:status,:state].include?(k)}.map do |k,v|
+      next if v.nil?
+      if v.is_a? Array
+        "(" + v.map{|x| "#{k} = #{x}"}.join(' OR ') + ")"
+      else
+        "#{k} = #{v}"
+      end
+    end.compact.join(" #{op} ")
+    # because they are provided in pairs, lets handle them together
+    # create the (( STATUS = maintenance AND STATE = noop) OR (STATE = provisioning_problem)) query
+    if options[:status_state]
+      status_query = options[:status_state].flat_map do |ss|
+        h = {}
+        h[:status], h[:state] = ss.split(':')
+        h[:status] = nil if h[:status].nil? or h[:status].empty?
+        h[:state] = nil if h[:state].nil? or h[:state].empty?
+        "( " + h.map {|k,v| v.nil? ? nil : "#{k.to_s.upcase} = #{v}"}.compact.join(" AND ") + " )"
+      end.compact.join(' OR ')
+      status_query = "( #{status_query} )"
+    end
+    [basic_query,status_query].reject {|q| q.nil? or q.empty?}.join(" #{op} ")
+  end
+
+end ; end ; end

data/lib/collins/cli/modify.rb

@@ -0,0 +1,144 @@
+require 'collins-cli'
+
+module Collins::CLI
+  class Modify
+
+    include Mixins
+
+    VALID_STATUSES = ["ALLOCATED","CANCELLED","DECOMMISSIONED","INCOMPLETE","MAINTENANCE","NEW","PROVISIONED","PROVISIONING","UNALLOCATED"]
+    #TODO: this shouldnt be hardcoded. we should pull this from the API instead?
+    # should elegantly support user-defined states without changing this script
+    VALID_STATES = {
+      "ALLOCATED" => ["CLAIMED","SPARE","RUNNING_UNMONITORED","UNMONITORED"],
+      "MAINTENANCE" => ["AWAITING_REVIEW","HARDWARE_PROBLEM","HW_TESTING","HARDWARE_UPGRADE","IPMI_PROBLEM","MAINT_NOOP","NETWORK_PROBLEM","RELOCATION",'PROVISIONING_PROBLEM'],
+      "ANY" => ["RUNNING","STARTING","STOPPING","TERMINATED"],
+    }
+    LOG_LEVELS = Collins::Api::Logging::Severity.constants.map(&:to_s)
+    OPTIONS_DEFAULTS = {
+      :query_size => 9999,
+      :attributes => {},
+      :delete_attributes => [],
+      :log_level  => 'NOTE',
+      :timeout    => 120,
+      :config     => nil
+    }
+    PROG_NAME = 'collins modify'
+
+    attr_reader :options
+
+    def initialize
+      @options = OPTIONS_DEFAULTS.clone
+      @validated = false
+      @parsed = false
+    end
+
+    def parse!(argv = ARGV)
+      OptionParser.new do |opts|
+        opts.banner = "Usage: #{PROG_NAME} [options]"
+        opts.on('-a','--set-attribute attribute:value',String,"Set attribute=value. : between key and value. attribute will be uppercased.") do |x|
+          if not x.include? ':'
+            puts '--set-attribute requires attribute:value, missing :value'
+            puts opts.help
+            exit 1
+          end
+          a,v = x.split(':')
+          @options[:attributes][a.upcase.to_sym] = v
+        end
+        opts.on('-d','--delete-attribute attribute',String,"Delete attribute.") {|v| @options[:delete_attributes] << v.to_sym }
+        opts.on('-S','--set-status status[:state]',String,'Set status (and optionally state) to status:state. Requires --reason') do |v|
+          status,state = v.split(':')
+          @options[:status] = status.upcase if not status.nil? and not status.empty?
+          @options[:state] = state.upcase if not state.nil? and not state.empty?
+        end
+        opts.on('-r','--reason REASON',String,"Reason for changing status/state.") {|v| @options[:reason] = v }
+        opts.on('-l','--log MESSAGE',String,"Create a log entry.") do |v|
+          @options[:log_message] = v
+        end
+        opts.on('-L','--level LEVEL',String, LOG_LEVELS + LOG_LEVELS.map(&:downcase),"Set log level. Default level is #{@options[:log_level]}.") do |v|
+          @options[:log_level] = v.upcase
+        end
+        opts.on('-t','--tags TAGS',Array,"Tags to work on, comma separated") {|v| @options[:tags] = v.map(&:to_sym)}
+        opts.on('-C','--config CONFIG',String,'Use specific Collins config yaml for Collins::Client') {|v| @options[:config] = v}
+        opts.on('-h','--help',"Help") {puts opts ; exit 0}
+        opts.separator ""
+        opts.separator "Allowed values (uppercase or lowercase is accepted):"
+        opts.separator <<_EOF_
+  Status (-S,--set-status):
+    #{VALID_STATUSES.join(', ')}
+  States (-S,--set-status):
+    #{VALID_STATES.keys.map {|k| "#{k} ->\n      #{VALID_STATES[k].join(', ')}"}.join "\n    "}
+  Log levels (-L,--level):
+    #{LOG_LEVELS.join(', ')}
+_EOF_
+        opts.separator ""
+        opts.separator "Examples:"
+        opts.separator <<_EOF_
+  Set an attribute on some hosts:
+    #{PROG_NAME} -t 001234,004567 -a my_attribute:true
+  Delete an attribute on some hosts:
+    #{PROG_NAME} -t 001234,004567 -d my_attribute
+  Delete and add attribute at same time:
+    #{PROG_NAME} -t 001234,004567 -a new_attr:test -d old_attr
+  Set machine into maintenace noop:
+    #{PROG_NAME} -t 001234 -S maintenance:maint_noop -r "I do what I want"
+  Set machine back to allocated:
+    #{PROG_NAME} -t 001234 -S allocated:running -r "Back to allocated"
+  Set machine back to new without setting state:
+    #{PROG_NAME} -t 001234 -S new -r "Dunno why you would want this"
+  Create a log entry:
+    #{PROG_NAME} -t 001234 -l'computers are broken and everything is horrible' -Lwarning
+  Read from stdin:
+    cf -n develnode | #{PROG_NAME} -d my_attribute
+    cf -n develnode -S allocated | #{PROG_NAME} -a collectd_version:5.2.1-52
+    echo -e "001234\\n001235\\n001236"| #{PROG_NAME} -a test_attribute:'hello world'
+_EOF_
+      end.parse!(argv)
+      if options[:tags].nil? or options[:tags].empty?
+        # read tags from stdin. first field on the line is the tag
+        input = ARGF.readlines
+        @options[:tags] = input.map{|l| l.split(/\s+/)[0] rescue nil}.compact.uniq
+      end
+      @parsed = true
+      self
+    end
+
+    def validate!
+      raise "See --help for #{PROG_NAME} usage" if options[:attributes].empty? and options[:delete_attributes].empty? and options[:status].nil? and options[:log_message].nil?
+      raise "You need to provide a --reason when changing asset states!" if not options[:status].nil? and options[:reason].nil?
+      #TODO this is never checked because we are making option parser vet our options for levels. Catch OptionParser::InvalidArgument?
+      raise "Log level #{options[:log_level]} is invalid! Use one of #{LOG_LEVELS.join(', ')}" unless Collins::Api::Logging::Severity.valid?(options[:log_level])
+
+      # if any statuses or states, validate them against allowed values
+      unless options[:status].nil?
+        raise "Invalid status #{options[:status]} (Should be in #{VALID_STATUSES.join(', ')})" unless VALID_STATUSES.include? options[:status]
+      states_for_status = VALID_STATES["ANY"].concat((VALID_STATES[options[:status]].nil?) ? [] : VALID_STATES[options[:status]])
+        raise "State #{options[:state]} doesn't apply to status #{options[:status]} (Should be one of #{states_for_status.join(', ')})" unless options[:state].nil? or states_for_status.include?(options[:state])
+      end
+
+
+      @validated = true
+      self
+    end
+
+    def run!
+      exit_clean = true
+      options[:tags].each do |t|
+        if options[:log_message]
+          exit_clean = api_call("logging #{options[:log_level].downcase} #{options[:log_message].inspect}", :log!, t, options[:log_message], options[:log_level]) && exit_clean
+        end
+        options[:attributes].each do |k,v|
+          exit_clean = api_call("setting #{k}=#{v}", :set_attribute!, t, k, v) && exit_clean
+        end
+        options[:delete_attributes].each do |k|
+          exit_clean = api_call("deleting #{k}", :delete_attribute!, t, k) && exit_clean
+        end
+        if options[:status]
+          exit_clean = api_call("changing status to #{options[:status]}#{options[:state] ? ":#{options[:state]}" : ''}", :set_status!, t, :status => options[:status], :state => options[:state], :reason => options[:reason]) && exit_clean
+        end
+      end
+      exit_clean
+    end
+
+  end
+end
+

data/lib/collins/cli/power.rb

@@ -0,0 +1,77 @@
+require 'collins-cli'
+
+module Collins::CLI
+  class Power
+    include Mixins
+    PROG_NAME = 'collins power'
+    ALLOWABLE_POWER_ACTIONS = ['reboot','rebootsoft','reboothard','on','off','poweron','poweroff','identify']
+    DEFAULT_OPTIONS = {
+      :timeout => 120,
+    }
+
+    attr_reader :options
+
+    def initialize
+      @options = DEFAULT_OPTIONS.clone
+      @parsed, @validated = false, false
+      @parser = nil
+    end
+
+    def parse!(argv = ARGV)
+      @parser = OptionParser.new do |opts|
+        opts.banner = "Usage: #{PROG_NAME} [options]"
+        opts.separator ""
+        opts.on('-s','--status',"Show IPMI power status") {|v| @options[:mode] = :status }
+        opts.on('-p','--power ACTION',String,"Perform IPMI power ACTION") {|v| @options[:mode] = :power ; @options[:power] = v.downcase }
+
+        opts.separator ""
+        opts.separator "General:"
+        opts.on('-t','--tags TAG[,...]',Array,"Tags to work on, comma separated") {|v| @options[:tags] = v.map(&:to_sym)}
+        opts.on('-C','--config CONFIG',String,'Use specific Collins config yaml for Collins::Client') {|v| @options[:config] = v}
+        opts.on('-h','--help',"Help") {puts opts ; exit 0}
+
+        opts.separator ""
+        opts.separator "Examples:"
+        opts.separator "  Reset some machines:"
+        opts.separator "    #{PROG_NAME} -t 001234,003456,007895 -p reboot"
+      end.parse!(argv)
+
+      # convert what we allow to be specified to what collins::power allows
+      @options[:power] = 'rebootsoft' if @options[:power] == 'reboot'
+
+      if options[:tags].nil? or options[:tags].empty?
+        # read tags from stdin. first field on the line is the tag
+        input = ARGF.readlines
+        @options[:tags] = input.map{|l| l.split(/\s+/)[0] rescue nil}.compact.uniq
+      end
+      @parsed = true
+      self
+    end
+
+    def validate!
+      raise "You need to tell me to do something!" if @options[:mode].nil?
+      if options[:mode] == :power
+        abort "Unknown power action #{options[:power]}, expecting one of #{ALLOWABLE_POWER_ACTIONS.join(',')}" unless ALLOWABLE_POWER_ACTIONS.include? options[:power]
+        # TODO this arguably shouldnt be in validate. Maybe #parse!?
+        @options[:power] = Collins::Power.normalize_action @options[:power]
+      end
+      self
+    end
+
+    def run!
+      success = true
+      options[:tags].each do |t|
+        case options[:mode]
+        when :status
+          res = api_call("checking power status",:power_status,t) {|status| status}
+          success = false if !res
+        when :power
+          success &&= api_call("performing #{options[:power]}", :power!, t, options[:power])
+        end
+      end
+      success
+    end
+
+  end
+end
+

data/lib/collins/cli/provision.rb

@@ -0,0 +1,80 @@
+require 'collins-cli'
+require 'etc'
+
+#TODO help should be an action done in run
+
+module Collins::CLI
+  class Provision
+    include Mixins
+    PROG_NAME = 'collins provision'
+    DEFAULT_OPTIONS = {
+      :timeout => 120,
+      :provision => { }
+    }
+
+    attr_reader :options
+
+    def initialize
+      @options = DEFAULT_OPTIONS.clone
+      @parsed, @validated = false, false
+      @options[:build_contact] = Etc.getlogin
+      @parser = nil
+    end
+
+    def parse!(argv = ARGV)
+      @parser = OptionParser.new do |opts|
+        opts.banner = "Usage: #{PROG_NAME} [options]"
+        #TODO -s to show provisoining_profiles
+        opts.separator ""
+        opts.on('-n','--nodeclass NODECLASS',String,"Nodeclass to provision as. (Required)") {|v| @options[:provision][:nodeclass] = v }
+        opts.on('-p','--pool POOL',String,"Provision with pool POOL.") {|v| @options[:provision][:pool] = v }
+        opts.on('-r','--role ROLE',String,"Provision with primary role ROLE.") {|v| @options[:provision][:primary_role] = v }
+        opts.on('-R','--secondary-role ROLE',String,"Provision with secondary role ROLE.") {|v| @options[:provision][:secondary_role] = v }
+        opts.on('-s','--suffix SUFFIX',String,"Provision with suffix SUFFIX.") {|v| @options[:provision][:suffix] = v }
+        opts.on('-a','--activate',"Activate server on provision (useful with SL plugin) (Default: ignored)") {|v| @options[:provision][:activate] = true }
+        opts.on('-b','--build-contact USER',String,"Build contact. (Default: #{@options[:build_contact]})") {|v| @options[:build_contact] = v }
+
+        opts.separator ""
+        opts.separator "General:"
+        opts.on('-t','--tags TAG[,...]',Array,"Tags to work on, comma separated") {|v| @options[:tags] = v.map(&:to_sym)}
+        opts.on('-C','--config CONFIG',String,'Use specific Collins config yaml for Collins::Client') {|v| @options[:config] = v}
+        opts.on('-h','--help',"Help") {puts opts ; exit 0}
+
+        opts.separator ""
+        opts.separator "Examples:\n  Provision some machines:\n    collins find -Sunallocated -arack_position:716|#{PROG_NAME} -P -napiwebnode6 -RALL"
+      end.parse!(argv)
+
+      if @options[:tags].nil? or @options[:tags].empty?
+        # read tags from stdin. first field on the line is the tag
+        input = ARGF.readlines
+        @options[:tags] = input.map{|l| l.split(/\s+/)[0] rescue nil}.compact.uniq
+      end
+      @parsed = true
+      self
+    end
+
+    def validate!
+      raise "You need to specify at least a nodeclass when provisioning" if options[:provision][:nodeclass].nil?
+      self
+    end
+
+    def run!
+      action_successes = []
+      options[:tags].each do |t|
+        action_string = "#{t} provisioning with #{options[:provision].map{|k,v| "#{k}:#{v}"}.join(" ")} by #{options[:build_contact]}... "
+        printf action_string
+        begin
+          res = collins.provision(t, options[:provision][:nodeclass], options[:build_contact], options[:provision])
+          puts (res ? SUCCESS : ERROR )
+          action_successes << res
+        rescue => e
+          puts "#{ERROR} (#{e.message})"
+          action_successes << false
+        end
+      end
+      action_successes.all?
+    end
+
+  end
+end
+

data/lib/collins-cli.rb

@@ -0,0 +1,13 @@
+$:.unshift(File.dirname(__FILE__))
+
+require 'collins_auth'
+require 'yaml'
+require 'json'
+require 'optparse'
+require 'colorize'
+
+['mixins','formatter','log','modify','find','power','provision','ipam'].
+  each {|r| require File.join('collins/cli',r) }
+
+module Collins ; module CLI ; end ; end
+

data/spec/collins__cli__find_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Collins::CLI::Find do
+  before(:each) do
+    Collins::CLI::Find.stub(:format_assets).and_return(true)
+    Collins::CLI::Find.stub_chain(:collins,:find).and_return([])
+    subject { Collins::CLI::Find.new }
+  end
+  context "#parse!" do
+    [
+      %w|-h|,
+      %w|-S allocated,maintenance|,
+      %w|-n testnode -ais_vm:true|,
+      %w|hostname|,
+      %w|hostname -c tag|,
+    ].each do |args|
+      it "Should parse #{args.inspect} successfully" do
+        expect{subject.parse!(args)}.to_not raise_error
+      end
+    end
+    [
+      %w|-ZZZZZZZ|,
+      %w|-K -Z_ LJIFJ?=I)|,
+    ].each do |args|
+      it "Should fail to parse unknown flags #{args.inspect}" do
+        expect{subject.parse!(args)}.to raise_error
+      end
+    end
+    it "requires arguments" do
+      expect{subject.parse!([])}.to raise_error(/See --help/)
+    end
+  end
+
+  context "#validate!" do
+    it "raises if not yet parsed" do
+      expect{subject.validate!}.to raise_error(/not yet parsed/)
+    end
+  end
+
+  context "#run!" do
+    it "raises if not yet parsed" do
+      expect{subject.run!}.to raise_error(/not yet parsed/)
+    end
+    it "raises if not yet validated" do
+      expect{subject.parse!(%w|-n nodeclass|).run!}.to raise_error(/not yet validated/)
+    end
+  end
+end

data/spec/collins__cli__log_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe Collins::CLI::Log do
+end

data/spec/collins__cli__modify_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe Collins::CLI::Modify do
+end

data/spec/collins__cli__power_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe Collins::CLI::Power do
+end

data/spec/collins__cli__provision_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe Collins::CLI::Provision do
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'collins-cli'
+