Module: DSL

Included in:
Case
Defined in:
lib/teuton/case/dsl/getset.rb,
lib/teuton/case/dsl/log.rb,
lib/teuton/case/dsl/goto.rb,
lib/teuton/case/dsl/send.rb,
lib/teuton/case/dsl/macro.rb,
lib/teuton/case/dsl/expect.rb,
lib/teuton/case/dsl/target.rb,
lib/teuton/case/dsl/unique.rb

Overview

DSL#target

Instance Method Summary collapse

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method, args = {}) ⇒ Object

If a method call is missing, then:

  • delegate to concept parent.

  • Invoke macro (assert)



32
33
34
35
36
37
38
39
 
# File 'lib/teuton/case/dsl/macro.rb', line 32

def method_missing(method, args = {})
  a = method.to_s
  if a.start_with?("_")
    return instance_eval("get(:#{a[1, a.size - 1]})", __FILE__, __LINE__)
  end
  return macro a[6, a.size], args if a[0, 6] == "macro_"
  macro a, args
end

Instance Method Details

#expect(input, args = {}) ⇒ Object

expect <condition>, :weight => <value>



8
9
10
11
12
13
14
15
16
 
# File 'lib/teuton/case/dsl/expect.rb', line 8

def expect(input, args = {})
  if input.instance_of?(TrueClass) || input.instance_of?(FalseClass)
    expect2(input, args)
  elsif input.instance_of?(String) || input.instance_of?(Regexp) || input.instance_of?(Array)
    expect_any input
  else
    puts Rainbow("[TypeError] expect #{input} (#{input.class})").red
  end
end

#expect2(cond, args = {}) ⇒ Object 



18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
# File 'lib/teuton/case/dsl/expect.rb', line 18

def expect2(cond, args = {})
  @action_counter += 1
  @action[:id] = @action_counter
  if @result.exitcode < 0
    @action[:check] = false
    @action[:result] = @action[:output]
  else
    @action[:check] = cond
    @action[:result] = (args[:value] || @result.value)
  end

  @action[:alterations] = @result.alterations
  @action[:expected] = (args[:expected] || @result.expected)
  @report.lines << @action.clone
  weight(1.0)

  c = Settings.letter[:bad]
  c = Settings.letter[:good] if cond
  verbose Rainbow(c).green
end

#expect_any(input, args = {}) ⇒ Object 



39
40
41
42
43
44
45
46
 
# File 'lib/teuton/case/dsl/expect.rb', line 39

def expect_any(input, args = {})
  if input.instance_of? Array
    input.each { |i| result.find(i) }
  else
    result.find(input)
  end
  expect2 result.count.gt(0), args
end

#expect_exit(value) ⇒ Object 



48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/teuton/case/dsl/expect.rb', line 48

def expect_exit(value)
  @result.alterations = "Read exit code"
  real_value = result.exitcode
  cond = if value.is_a? Range
    expect_value = "With range #{value}"
    value.to_a.include? real_value
  elsif value.is_a? Array
    expect_value = "Inside list #{value}"
    value.include? real_value
  else
    expect_value = value
    (real_value == value.to_i)
  end
  expect2 cond, value: real_value, expected: expect_value
end

#expect_fail ⇒ Object 



64
65
66
67
68
69
70
 
# File 'lib/teuton/case/dsl/expect.rb', line 64

def expect_fail
  @result.alterations = "Read exit code"
  real_value = result.exitcode
  expect_value = "Greater than 0"
  cond = (real_value > 0)
  expect2 cond, value: real_value, expected: expect_value
end

#expect_first(input, args = {}) ⇒ Object 



72
73
74
75
76
77
 
# File 'lib/teuton/case/dsl/expect.rb', line 72

def expect_first(input, args = {})
  @result.first
  output = input
  output = args[:expected] if args[:expected]
  expect2 input, expected: output
end

#expect_last(input, args = {}) ⇒ Object 



79
80
81
82
83
84
 
# File 'lib/teuton/case/dsl/expect.rb', line 79

def expect_last(input, args = {})
  @result.last
  output = input
  output = args[:expected] if args[:expected]
  expect2 input, expected: output
end

#expect_none(input = nil, args = {}) ⇒ Object 



90
91
92
93
94
95
96
97
98
99
 
# File 'lib/teuton/case/dsl/expect.rb', line 90

def expect_none(input = nil, args = {})
  if input.nil?
    # nothing to do
  elsif input.instance_of? Array
    input.each { |i| result.find(i) }
  else
    result.find(input)
  end
  expect2 result.count.eq(0), args
end

#expect_nothing(args = {}) ⇒ Object 



86
87
88
 
# File 'lib/teuton/case/dsl/expect.rb', line 86

def expect_nothing(args = {})
  expect2 result.count.eq(0), args
end

#expect_ok ⇒ Object 



110
111
112
 
# File 'lib/teuton/case/dsl/expect.rb', line 110

def expect_ok
  expect_exit 0
end

#expect_one(input, args = {}) ⇒ Object 



101
102
103
104
105
106
107
108
 
# File 'lib/teuton/case/dsl/expect.rb', line 101

def expect_one(input, args = {})
  if input.instance_of? Array
    input.each { |i| result.find(i) }
  else
    result.find(input)
  end
  expect2 result.count.eq(1), args
end

#get(option) ⇒ Object

Read param option from [running, config or global] Hash data



6
7
8
 
# File 'lib/teuton/case/dsl/getset.rb', line 6

def get(option)
  @config.get(option)
end

#gett(option) ⇒ Object 



10
11
12
13
 
# File 'lib/teuton/case/dsl/getset.rb', line 10

def gett(option)
  value = get(option)
  "#{value} (#{option})"
end

#goto(host = :localhost, args = {}) ⇒ Object Also known as: on

Run command from the host identify as “host” goto :host1, :execute => “command”



20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
# File 'lib/teuton/case/dsl/goto.rb', line 20

def goto(host = :localhost, args = {})
  @result.reset
  args[:on] = host unless args[:on]
  @action[:command] = args[:execute].to_s if args[:execute]
  @action[:command] = args[:exec].to_s if args[:exec]
  tempfile(args[:tempfile]) if args[:tempfile]
  @action[:encoding] = args[:encoding] || "UTF-8"

  ExecuteManager.new(self).call(host)
  @action[:output] = if @result.content.size < 2
    @result.value.clone
  else
    "(#{@result.content.size} lines)"
  end
end

#log(text = "", type = :info) ⇒ Object Also known as: msg

Record log message

Parameters:

  • text (String) (defaults to: "")
  • type (Symbol) (defaults to: :info) —

    Values :info, :warn or :error



8
9
10
11
12
13
14
15
16
17
 
# File 'lib/teuton/case/dsl/log.rb', line 8

def log(text = "", type = :info)
  s = " INFO"
  s = Rainbow("WARN!").color(:yellow) if type == :warn
  s = Rainbow("ERROR").bg(:red) if type == :error
  t = Time.now
  f = format("%<hour>02d:%<min>02d:%<sec>02d", {hour: t.hour, min: t.min, sec: t.sec})
  msg = "[#{f}] #{s}: #{text}"
  msg = "[#{f}] #{text}" if s == ""
  @report.lines << msg
end

#macro(name, input = {}) ⇒ Object

Invoke macro

Parameters:

  • name (String) —

    Macro name

  • input (Hash) (defaults to: {}) —

    Macro params



10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
# File 'lib/teuton/case/dsl/macro.rb', line 10

def macro(name, input = {})
  macros = Project.value[:macros]
  unless macros[name]
    log("Macro #{name} not found!", :error)
    return
  end
  input.each_pair { |k, v| set(k, v) }
  errors = []
  macros[name][:args].each do |i|
    errors << i if get(i) == "NODATA"
  end
  if errors.count > 0
    log("Macro #{name} => required params #{errors.join(",")}", :error)
  else
    instance_eval(&macros[name][:block])
  end
  input.each_pair { |k, v| unset(k) }
end

#readme(_text) ⇒ Object 



5
6
7
 
# File 'lib/teuton/case/dsl/target.rb', line 5

def readme(_text)
  # Usefull only for "teuton reamde" command action.
end

#remote_tempdir ⇒ Object 



63
64
65
 
# File 'lib/teuton/case/dsl/send.rb', line 63

def remote_tempdir
  File.join("/", "tmp") # TODO: Remove this?
end

#remote_tempfile ⇒ Object 



59
60
61
 
# File 'lib/teuton/case/dsl/send.rb', line 59

def remote_tempfile
  @action[:remote_tempfile]
end

#respond_to_missing?(method) ⇒ Boolean

Returns:

  • (Boolean) 


41
42
43
 
# File 'lib/teuton/case/dsl/macro.rb', line 41

def respond_to_missing?(method, *)
  true
end

#run(command, args = {}) ⇒ Object

DSL run and goto run: It’s the same as goto :localhost

Parameters:

  • command (String)
  • args (Hash) (defaults to: {}) 


11
12
13
14
15
16
 
# File 'lib/teuton/case/dsl/goto.rb', line 11

def run(command, args = {})
  args[:exec] = command.to_s
  host = :localhost
  host = args[:on] if args[:on]
  goto(host, args)
end

#send(args = {}) ⇒ Object

  • send, tempfile, tempdir, remote_tempdir, remote_tempfile



5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/teuton/case/dsl/send.rb', line 5

def send(args = {})
  return if skip?

  return unless args[:copy_to]

  host = args[:copy_to].to_s
  return unless @conn_status[host].nil?

  ip = get((host + "_ip").to_sym)
  username = get((host + "_username").to_sym).to_s
  password = get((host + "_password").to_sym).to_s
  port = get((host + "_port").to_sym).to_i
  port = 22 if port.zero?

  filename = "#{@report.filename}.#{@report.format}"
  filename = "#{@report.filename}.txt" if @report.format == :colored_text
  localfilepath = File.join(@report.output_dir, filename)
  filename = args[:prefix].to_s + filename if args[:prefix]

  remotefilepath = if args[:dir]
    File.join(args[:dir], filename)
  else
    File.join(".", filename)
  end

  # Upload a file or directory to the remote host
  begin
    Net::SFTP.start(ip, username, password: password, port: port) do |sftp|
      sftp.upload!(localfilepath, remotefilepath)
    end
    msg = Rainbow("==> Case #{get(:tt_members)}: report (#{remotefilepath}) copy to (#{ip})").green
    verboseln(msg)
  rescue
    msg = Rainbow("==> [FAIL] #{get(:tt_members)}: 'scp #{localfilepath}' to #{remotefilepath}").red
    verboseln(msg)
  end
end

#set(key, value) ⇒ Object 



15
16
17
 
# File 'lib/teuton/case/dsl/getset.rb', line 15

def set(key, value)
  @config.set(key, value)
end

#target(desc, args = {}) ⇒ Object Also known as: goal 



9
10
11
12
13
14
 
# File 'lib/teuton/case/dsl/target.rb', line 9

def target(desc, args = {})
  @action[:description] = desc.to_s
  @action[:asset] = args[:asset].to_s if args[:asset]
  w = args[:weight] || 1.0
  weight(w)
end

#tempdir ⇒ Object 



55
56
57
 
# File 'lib/teuton/case/dsl/send.rb', line 55

def tempdir
  @tmpdir
end

#tempfile(input = nil) ⇒ Object 



43
44
45
46
47
48
49
50
51
52
53
 
# File 'lib/teuton/case/dsl/send.rb', line 43

def tempfile(input = nil)
  return @action[:tempfile] if input.nil?

  name = input
  name = "teuton.tmp" if input == :default

  @action[:tempfile] = File.join(@tmpdir, name)
  @action[:remote_tempfile] = File.join(remote_tempdir, name)

  @action[:tempfile]
end

#unique(key, value) ⇒ Object 



4
5
6
7
8
 
# File 'lib/teuton/case/dsl/unique.rb', line 4

def unique(key, value)
  return if value.nil?

  @uniques << "#{key}=#{value}".to_sym
end

#unset(key) ⇒ Object 



19
20
21
 
# File 'lib/teuton/case/dsl/getset.rb', line 19

def unset(key)
  @config.unset(key)
end

#weight(value = nil) ⇒ Object 



114
115
116
117
118
119
120
121
122
123
 
# File 'lib/teuton/case/dsl/expect.rb', line 114

def weight(value = nil)
  # Set weight value for the action
  if value.nil?
    @action[:weight]
  elsif value == :default
    @action[:weight] = 1.0
  else
    @action[:weight] = value.to_f
  end
end