1
2
3
4
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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
|
#! /usr/bin/env ruby
require 'spec_helper'
require 'puppet/application/resource'
require 'puppet_spec/character_encoding'
describe Puppet::Application::Resource do
include PuppetSpec::Files
before :each do
@resource_app = Puppet::Application[:resource]
Puppet::Util::Log.stubs(:newdestination)
end
describe "in preinit" do
it "should init extra_params to empty array" do
@resource_app.preinit
expect(@resource_app.extra_params).to eq([])
end
end
describe "when handling options" do
[:debug, :verbose, :edit].each do |option|
it "should store argument value when calling handle_#{option}" do
@resource_app.options.expects(:[]=).with(option, 'arg')
@resource_app.send("handle_#{option}".to_sym, 'arg')
end
end
it "should load a display all types with types option" do
type1 = stub_everything 'type1', :name => :type1
type2 = stub_everything 'type2', :name => :type2
Puppet::Type.stubs(:loadall)
Puppet::Type.stubs(:eachtype).multiple_yields(type1,type2)
@resource_app.expects(:puts).with(['type1','type2'])
expect { @resource_app.handle_types(nil) }.to exit_with 0
end
it "should add param to extra_params list" do
@resource_app.extra_params = [ :param1 ]
@resource_app.handle_param("whatever")
expect(@resource_app.extra_params).to eq([ :param1, :whatever ])
end
it "should get a parameter in the printed data if extra_params are passed" do
tty = stub("tty", :tty? => true )
path = tmpfile('testfile')
command_line = Puppet::Util::CommandLine.new("puppet", [ 'resource', 'file', path ], tty )
@resource_app.stubs(:command_line).returns command_line
# provider is a parameter that should always be available
@resource_app.extra_params = [ :provider ]
expect { @resource_app.main }.to have_printed(/provider\s+=>/)
end
end
describe "during setup" do
before :each do
Puppet::Log.stubs(:newdestination)
end
it "should set console as the log destination" do
Puppet::Log.expects(:newdestination).with(:console)
@resource_app.setup
end
it "should set log level to debug if --debug was passed" do
@resource_app.options.stubs(:[]).with(:debug).returns(true)
@resource_app.setup
expect(Puppet::Log.level).to eq(:debug)
end
it "should set log level to info if --verbose was passed" do
@resource_app.options.stubs(:[]).with(:debug).returns(false)
@resource_app.options.stubs(:[]).with(:verbose).returns(true)
@resource_app.setup
expect(Puppet::Log.level).to eq(:info)
end
end
describe "when running" do
before :each do
@type = stub_everything 'type', :properties => []
@resource_app.command_line.stubs(:args).returns(['mytype'])
Puppet::Type.stubs(:type).returns(@type)
@res = stub_everything "resource"
@res.stubs(:prune_parameters).returns(@res)
@res.stubs(:to_manifest).returns("resource")
@report = stub_everything "report"
@resource_app.stubs(:puts)
Puppet::Resource.indirection.stubs(:find ).never
Puppet::Resource.indirection.stubs(:search).never
Puppet::Resource.indirection.stubs(:save ).never
end
it "should raise an error if no type is given" do
@resource_app.command_line.stubs(:args).returns([])
expect { @resource_app.main }.to raise_error(RuntimeError, "You must specify the type to display")
end
it "should raise an error if the type is not found" do
Puppet::Type.stubs(:type).returns(nil)
expect { @resource_app.main }.to raise_error(RuntimeError, 'Could not find type mytype')
end
it "should search for resources" do
Puppet::Resource.indirection.expects(:search).with('mytype/', {}).returns([])
@resource_app.main
end
it "should describe the given resource" do
@resource_app.command_line.stubs(:args).returns(['type','name'])
Puppet::Resource.indirection.expects(:find).with('type/name').returns(@res)
@resource_app.main
end
it "should add given parameters to the object" do
@resource_app.command_line.stubs(:args).returns(['type','name','param=temp'])
Puppet::Resource.indirection.expects(:save).with(@res, 'type/name').returns([@res, @report])
Puppet::Resource.expects(:new).with('type', 'name', :parameters => {'param' => 'temp'}).returns(@res)
@resource_app.main
end
end
describe "when printing output" do
it "should ensure all values to be printed are in the external encoding" do
resources = [
Puppet::Type.type(:user).new(:name => "\u2603".force_encoding(Encoding::UTF_8)).to_resource,
Puppet::Type.type(:user).new(:name => "Jos\xE9".force_encoding(Encoding::ISO_8859_1)).to_resource
]
Puppet::Resource.indirection.expects(:search).with('user/', {}).returns(resources)
@resource_app.command_line.stubs(:args).returns(['user'])
# All of our output should be in external encoding
@resource_app.expects(:puts).with { |args| expect(args.encoding).to eq(Encoding::ISO_8859_1) }
# This would raise an error if we weren't handling it
PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::ISO_8859_1) do
expect { @resource_app.main }.not_to raise_error
end
end
end
describe "when handling file type" do
before :each do
Facter.stubs(:loadfacts)
@resource_app.preinit
end
it "should raise an exception if no file specified" do
@resource_app.command_line.stubs(:args).returns(['file'])
expect { @resource_app.main }.to raise_error(RuntimeError, /Listing all file instances is not supported/)
end
it "should output a file resource when given a file path" do
path = File.expand_path('/etc')
res = Puppet::Type.type(:file).new(:path => path).to_resource
Puppet::Resource.indirection.expects(:find).returns(res)
@resource_app.command_line.stubs(:args).returns(['file', path])
@resource_app.expects(:puts).with do |args|
expect(args).to match(/file \{ '#{Regexp.escape(path)}'/m)
end
@resource_app.main
end
end
describe 'when handling a custom type' do
it 'the Puppet::Pops::Loaders instance is available' do
Puppet::Type.newtype(:testing) do
newparam(:name) do
isnamevar
end
def self.instances
fail('Loader not found') unless Puppet::Pops::Loaders.find_loader(nil).is_a?(Puppet::Pops::Loader::Loader)
@instances ||= [new(:name => name)]
end
end
@resource_app.command_line.stubs(:args).returns(['testing', 'hello'])
@resource_app.expects(:puts).with { |args| expect(args).to eql("testing { 'hello':\n}") }
expect { @resource_app.main }.not_to raise_error
end
end
end
|
