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
|
require 'spec_helper'
require 'puppet/interface'
describe Puppet::Interface::Option do
let :face do Puppet::Interface.new(:option_testing, '0.0.1') end
describe "#optparse_to_name" do
["", "=BAR", " BAR", "=bar", " bar"].each do |postfix|
{ "--foo" => :foo, "-f" => :f }.each do |base, expect|
input = base + postfix
it "should map #{input.inspect} to #{expect.inspect}" do
option = Puppet::Interface::Option.new(face, input)
expect(option.name).to eq(expect)
end
end
end
[:foo, 12, nil, {}, []].each do |input|
it "should fail sensible when given #{input.inspect}" do
expect {
Puppet::Interface::Option.new(face, input)
}.to raise_error ArgumentError, /is not valid for an option argument/
end
end
["-foo", "-foo=BAR", "-foo BAR"].each do |input|
it "should fail with a single dash for long option #{input.inspect}" do
expect {
Puppet::Interface::Option.new(face, input)
}.to raise_error ArgumentError, /long options need two dashes \(--\)/
end
end
end
it "requires a face when created" do
expect {
Puppet::Interface::Option.new
}.to raise_error ArgumentError, /wrong number of arguments/
end
it "also requires some declaration arguments when created" do
expect {
Puppet::Interface::Option.new(face)
}.to raise_error ArgumentError, /No option declarations found/
end
it "should infer the name from an optparse string" do
option = Puppet::Interface::Option.new(face, "--foo")
expect(option.name).to eq(:foo)
end
it "should infer the name when multiple optparse string are given" do
option = Puppet::Interface::Option.new(face, "--foo", "-f")
expect(option.name).to eq(:foo)
end
it "should prefer the first long option name over a short option name" do
option = Puppet::Interface::Option.new(face, "-f", "--foo")
expect(option.name).to eq(:foo)
end
it "should create an instance when given a face and name" do
expect(Puppet::Interface::Option.new(face, "--foo")).
to be_instance_of Puppet::Interface::Option
end
Puppet.settings.each do |name, value|
it "should fail when option #{name.inspect} already exists in puppet core" do
expect do
Puppet::Interface::Option.new(face, "--#{name}")
end.to raise_error ArgumentError, /already defined/
end
end
describe "#to_s" do
it "should transform a symbol into a string" do
option = Puppet::Interface::Option.new(face, "--foo")
expect(option.name).to eq(:foo)
expect(option.to_s).to eq("foo")
end
it "should use - rather than _ to separate words in strings but not symbols" do
option = Puppet::Interface::Option.new(face, "--foo-bar")
expect(option.name).to eq(:foo_bar)
expect(option.to_s).to eq("foo-bar")
end
end
%w{before after}.each do |side|
describe "#{side} hooks" do
subject { Puppet::Interface::Option.new(face, "--foo") }
let :proc do Proc.new do :from_proc end end
it { is_expected.to respond_to "#{side}_action" }
it { is_expected.to respond_to "#{side}_action=" }
it "should set the #{side}_action hook" do
expect(subject.send("#{side}_action")).to be_nil
subject.send("#{side}_action=", proc)
expect(subject.send("#{side}_action")).to be_an_instance_of UnboundMethod
end
data = [1, "foo", :foo, Object.new, method(:hash), method(:hash).unbind]
data.each do |input|
it "should fail if a #{input.class} is added to the #{side} hooks" do
expect { subject.send("#{side}_action=", input) }.
to raise_error ArgumentError, /not a proc/
end
end
end
end
context "defaults" do
subject { Puppet::Interface::Option.new(face, "--foo") }
it "should work sanely if member variables are used for state" do
subject.default = proc { @foo ||= 0; @foo += 1 }
expect(subject.default).to eq(1)
expect(subject.default).to eq(2)
expect(subject.default).to eq(3)
end
context "with no default" do
it { is_expected.not_to be_has_default }
its :default do should be_nil end
it "should set a proc as default" do
expect { subject.default = proc { 12 } }.to_not raise_error
end
[1, {}, [], Object.new, "foo"].each do |input|
it "should reject anything but a proc (#{input.class})" do
expect { subject.default = input }.to raise_error ArgumentError, /not a proc/
end
end
end
context "with a default" do
before :each do subject.default = proc { [:foo] } end
it { is_expected.to be_has_default }
its :default do should == [:foo] end
it "should invoke the block every time" do
expect(subject.default.object_id).not_to eq(subject.default.object_id)
expect(subject.default).to eq(subject.default)
end
it "should allow replacing the default proc" do
expect(subject.default).to eq([:foo])
subject.default = proc { :bar }
expect(subject.default).to eq(:bar)
end
end
end
end
|
