← Back to branch summary

~ubuntu-branches/ubuntu/quantal/puppet/quantal

« back to all changes in this revision

Viewing changes to spec/unit/type/cron_spec.rb

  • Committer: Package Import Robot
  • Author(s): Marc Deslauriers
  • Date: 2012-07-14 01:56:30 UTC
  • mfrom: (1.1.29) (3.1.43 sid)
  • Revision ID: package-import@ubuntu.com-20120714015630-ntj41rkvkq4zph4y
Tags: 2.7.18-1ubuntu1
https://launchpad.net/bugs/1023931
* Resynchronise with Debian. (LP: #1023931) Remaining changes:
  - debian/puppetmaster-passenger.postinst: Make sure we error if puppet
    config print doesn't work
  - debian/puppetmaster-passenger.postinst: Ensure upgrades from
    <= 2.7.11-1 fixup passenger apache configuration.
* Dropped upstreamed patches:
  - debian/patches/CVE-2012-1906_CVE-2012-1986_to_CVE-2012-1989.patch
  - debian/patches/puppet-12844
  - debian/patches/2.7.17-Puppet-July-2012-CVE-fixes.patch
* Drop Build-Depends on ruby-rspec (in universe):
  - debian/control: remove ruby-rspec from Build-Depends
  - debian/patches/no-rspec.patch: make Rakefile work anyway if rspec
    isn't installed so we can use it in debian/rules.

Show diffs side-by-side

added added

removed removed

Lines of Context:
spec/unit/type/cron_spec.rb
1
1
#!/usr/bin/env rspec
 
2
 
2
3
require 'spec_helper'
3
4
 
4
5
describe Puppet::Type.type(:cron), :unless => Puppet.features.microsoft_windows? do
5
6
  before do
6
 
    @class = Puppet::Type.type(:cron)
7
 
 
8
 
    # Init a fake provider
9
 
    @provider_class = stub 'provider_class', :ancestors => [], :name => 'fake', :suitable? => true, :supports_parameter? => true
10
 
    @class.stubs(:defaultprovider).returns @provider_class
11
 
    @class.stubs(:provider).returns @provider_class
12
 
 
13
 
    @provider = stub 'provider', :class => @provider_class, :clean => nil
14
 
    @provider.stubs(:is_a?).returns false
15
 
    @provider_class.stubs(:new).returns @provider
16
 
 
17
 
    @cron = @class.new( :name => "foo" )
 
7
    @provider_class = described_class.provide(:simple) { mk_resource_methods }
 
8
    @provider_class.stubs(:suitable?).returns true
 
9
    described_class.stubs(:defaultprovider).returns @provider_class
18
10
  end
19
11
 
20
12
  it "should have :name be its namevar" do
21
 
    @class.key_attributes.should == [:name]
 
13
    described_class.key_attributes.should == [:name]
22
14
  end
23
15
 
24
16
  describe "when validating attributes" do
25
 
 
26
17
    [:name, :provider].each do |param|
27
18
      it "should have a #{param} parameter" do
28
 
        @class.attrtype(param).should == :param
 
19
        described_class.attrtype(param).should == :param
29
20
      end
30
21
    end
31
22
 
32
23
    [:command, :special, :minute, :hour, :weekday, :month, :monthday, :environment, :user, :target].each do |property|
33
24
      it "should have a #{property} property" do
34
 
        @class.attrtype(property).should == :property
 
25
        described_class.attrtype(property).should == :property
35
26
      end
36
27
    end
37
28
 
38
29
    [:command, :minute, :hour, :weekday, :month, :monthday].each do |cronparam|
39
30
      it "should have #{cronparam} of type CronParam" do
40
 
        @class.attrclass(cronparam).ancestors.should include CronParam
 
31
        described_class.attrclass(cronparam).ancestors.should include CronParam
41
32
      end
42
33
    end
43
 
 
44
34
  end
45
35
 
46
36
 
47
 
  describe "when validating attribute" do
 
37
  describe "when validating values" do
48
38
 
49
39
    describe "ensure" do
50
40
      it "should support present as a value for ensure" do
51
 
        proc { @class.new(:name => 'foo', :ensure => :present) }.should_not raise_error
 
41
        proc { described_class.new(:name => 'foo', :ensure => :present) }.should_not raise_error
52
42
      end
53
43
 
54
44
      it "should support absent as a value for ensure" do
55
 
        proc { @class.new(:name => 'foo', :ensure => :present) }.should_not raise_error
 
45
        proc { described_class.new(:name => 'foo', :ensure => :present) }.should_not raise_error
 
46
      end
 
47
 
 
48
      it "should not support other values" do
 
49
        proc { described_class.new(:name => 'foo', :ensure => :foo) }.should raise_error(Puppet::Error, /Invalid value/)
56
50
      end
57
51
    end
58
52
 
59
53
    describe "minute" do
60
 
 
61
54
      it "should support absent" do
62
 
        proc { @class.new(:name => 'foo', :minute => 'absent') }.should_not raise_error
 
55
        proc { described_class.new(:name => 'foo', :minute => 'absent') }.should_not raise_error
63
56
      end
64
57
 
65
58
      it "should support *" do
66
 
        proc { @class.new(:name => 'foo', :minute => '*') }.should_not raise_error
 
59
        proc { described_class.new(:name => 'foo', :minute => '*') }.should_not raise_error
67
60
      end
68
61
 
69
62
      it "should translate absent to :absent" do
70
 
        @class.new(:name => 'foo', :minute => 'absent')[:minute].should == :absent
 
63
        described_class.new(:name => 'foo', :minute => 'absent')[:minute].should == :absent
71
64
      end
72
65
 
73
66
      it "should translate * to :absent" do
74
 
        @class.new(:name => 'foo', :minute => '*')[:minute].should == :absent
 
67
        described_class.new(:name => 'foo', :minute => '*')[:minute].should == :absent
75
68
      end
76
69
 
77
70
      it "should support valid single values" do
78
 
        proc { @class.new(:name => 'foo', :minute => '0') }.should_not raise_error
79
 
        proc { @class.new(:name => 'foo', :minute => '1') }.should_not raise_error
80
 
        proc { @class.new(:name => 'foo', :minute => '59') }.should_not raise_error
 
71
        proc { described_class.new(:name => 'foo', :minute => '0') }.should_not raise_error
 
72
        proc { described_class.new(:name => 'foo', :minute => '1') }.should_not raise_error
 
73
        proc { described_class.new(:name => 'foo', :minute => '59') }.should_not raise_error
81
74
      end
82
75
 
83
76
      it "should not support non numeric characters" do
84
 
        proc { @class.new(:name => 'foo', :minute => 'z59') }.should raise_error(Puppet::Error)
85
 
        proc { @class.new(:name => 'foo', :minute => '5z9') }.should raise_error(Puppet::Error)
86
 
        proc { @class.new(:name => 'foo', :minute => '59z') }.should raise_error(Puppet::Error)
 
77
        proc { described_class.new(:name => 'foo', :minute => 'z59') }.should raise_error(Puppet::Error, /z59 is not a valid minute/)
 
78
        proc { described_class.new(:name => 'foo', :minute => '5z9') }.should raise_error(Puppet::Error, /5z9 is not a valid minute/)
 
79
        proc { described_class.new(:name => 'foo', :minute => '59z') }.should raise_error(Puppet::Error, /59z is not a valid minute/)
87
80
      end
88
81
 
89
82
      it "should not support single values out of range" do
90
83
 
91
 
        proc { @class.new(:name => 'foo', :minute => '-1') }.should raise_error(Puppet::Error)
92
 
        proc { @class.new(:name => 'foo', :minute => '60') }.should raise_error(Puppet::Error)
93
 
        proc { @class.new(:name => 'foo', :minute => '61') }.should raise_error(Puppet::Error)
94
 
        proc { @class.new(:name => 'foo', :minute => '120') }.should raise_error(Puppet::Error)
 
84
        proc { described_class.new(:name => 'foo', :minute => '-1') }.should raise_error(Puppet::Error, /-1 is not a valid minute/)
 
85
        proc { described_class.new(:name => 'foo', :minute => '60') }.should raise_error(Puppet::Error, /60 is not a valid minute/)
 
86
        proc { described_class.new(:name => 'foo', :minute => '61') }.should raise_error(Puppet::Error, /61 is not a valid minute/)
 
87
        proc { described_class.new(:name => 'foo', :minute => '120') }.should raise_error(Puppet::Error, /120 is not a valid minute/)
95
88
      end
96
89
 
97
90
      it "should support valid multiple values" do
98
 
        proc { @class.new(:name => 'foo', :minute => ['0','1','59'] ) }.should_not raise_error
99
 
        proc { @class.new(:name => 'foo', :minute => ['40','30','20'] ) }.should_not raise_error
100
 
        proc { @class.new(:name => 'foo', :minute => ['10','30','20'] ) }.should_not raise_error
 
91
        proc { described_class.new(:name => 'foo', :minute => ['0','1','59'] ) }.should_not raise_error
 
92
        proc { described_class.new(:name => 'foo', :minute => ['40','30','20'] ) }.should_not raise_error
 
93
        proc { described_class.new(:name => 'foo', :minute => ['10','30','20'] ) }.should_not raise_error
101
94
      end
102
95
 
103
96
      it "should not support multiple values if at least one is invalid" do
104
97
        # one invalid
105
 
        proc { @class.new(:name => 'foo', :minute => ['0','1','60'] ) }.should raise_error(Puppet::Error)
106
 
        proc { @class.new(:name => 'foo', :minute => ['0','120','59'] ) }.should raise_error(Puppet::Error)
107
 
        proc { @class.new(:name => 'foo', :minute => ['-1','1','59'] ) }.should raise_error(Puppet::Error)
 
98
        proc { described_class.new(:name => 'foo', :minute => ['0','1','60'] ) }.should raise_error(Puppet::Error, /60 is not a valid minute/)
 
99
        proc { described_class.new(:name => 'foo', :minute => ['0','120','59'] ) }.should raise_error(Puppet::Error, /120 is not a valid minute/)
 
100
        proc { described_class.new(:name => 'foo', :minute => ['-1','1','59'] ) }.should raise_error(Puppet::Error, /-1 is not a valid minute/)
108
101
        # two invalid
109
 
        proc { @class.new(:name => 'foo', :minute => ['0','61','62'] ) }.should raise_error(Puppet::Error)
 
102
        proc { described_class.new(:name => 'foo', :minute => ['0','61','62'] ) }.should raise_error(Puppet::Error, /(61|62) is not a valid minute/)
110
103
        # all invalid
111
 
        proc { @class.new(:name => 'foo', :minute => ['-1','61','62'] ) }.should raise_error(Puppet::Error)
 
104
        proc { described_class.new(:name => 'foo', :minute => ['-1','61','62'] ) }.should raise_error(Puppet::Error, /(-1|61|62) is not a valid minute/)
112
105
      end
113
106
 
114
107
      it "should support valid step syntax" do
115
 
        proc { @class.new(:name => 'foo', :minute => '*/2' ) }.should_not raise_error
116
 
        proc { @class.new(:name => 'foo', :minute => '10-16/2' ) }.should_not raise_error
 
108
        proc { described_class.new(:name => 'foo', :minute => '*/2' ) }.should_not raise_error
 
109
        proc { described_class.new(:name => 'foo', :minute => '10-16/2' ) }.should_not raise_error
117
110
      end
118
111
 
119
112
      it "should not support invalid steps" do
120
 
        proc { @class.new(:name => 'foo', :minute => '*/A' ) }.should raise_error(Puppet::Error)
121
 
        proc { @class.new(:name => 'foo', :minute => '*/2A' ) }.should raise_error(Puppet::Error)
 
113
        proc { described_class.new(:name => 'foo', :minute => '*/A' ) }.should raise_error(Puppet::Error, /\*\/A is not a valid minute/)
 
114
        proc { described_class.new(:name => 'foo', :minute => '*/2A' ) }.should raise_error(Puppet::Error, /\*\/2A is not a valid minute/)
122
115
        # As it turns out cron does not complaining about steps that exceed the valid range
123
 
        # proc { @class.new(:name => 'foo', :minute => '*/120' ) }.should raise_error(Puppet::Error)
 
116
        # proc { described_class.new(:name => 'foo', :minute => '*/120' ) }.should raise_error(Puppet::Error, /is not a valid minute/)
124
117
      end
125
 
 
126
118
    end
127
119
 
128
120
    describe "hour" do
129
 
 
130
 
     it "should support absent" do
131
 
        proc { @class.new(:name => 'foo', :hour => 'absent') }.should_not raise_error
 
121
      it "should support absent" do
 
122
        proc { described_class.new(:name => 'foo', :hour => 'absent') }.should_not raise_error
132
123
      end
133
124
 
134
125
      it "should support *" do
135
 
        proc { @class.new(:name => 'foo', :hour => '*') }.should_not raise_error
 
126
        proc { described_class.new(:name => 'foo', :hour => '*') }.should_not raise_error
136
127
      end
137
128
 
138
129
      it "should translate absent to :absent" do
139
 
        @class.new(:name => 'foo', :hour => 'absent')[:hour].should == :absent
 
130
        described_class.new(:name => 'foo', :hour => 'absent')[:hour].should == :absent
140
131
      end
141
132
 
142
133
      it "should translate * to :absent" do
143
 
        @class.new(:name => 'foo', :hour => '*')[:hour].should == :absent
 
134
        described_class.new(:name => 'foo', :hour => '*')[:hour].should == :absent
144
135
      end
145
136
 
146
137
      it "should support valid single values" do
147
 
        proc { @class.new(:name => 'foo', :hour => '0') }.should_not raise_error
148
 
        proc { @class.new(:name => 'foo', :hour => '11') }.should_not raise_error
149
 
        proc { @class.new(:name => 'foo', :hour => '12') }.should_not raise_error
150
 
        proc { @class.new(:name => 'foo', :hour => '13') }.should_not raise_error
151
 
        proc { @class.new(:name => 'foo', :hour => '23') }.should_not raise_error
 
138
        proc { described_class.new(:name => 'foo', :hour => '0') }.should_not raise_error
 
139
        proc { described_class.new(:name => 'foo', :hour => '11') }.should_not raise_error
 
140
        proc { described_class.new(:name => 'foo', :hour => '12') }.should_not raise_error
 
141
        proc { described_class.new(:name => 'foo', :hour => '13') }.should_not raise_error
 
142
        proc { described_class.new(:name => 'foo', :hour => '23') }.should_not raise_error
152
143
      end
153
144
 
154
145
      it "should not support non numeric characters" do
155
 
        proc { @class.new(:name => 'foo', :hour => 'z15') }.should raise_error(Puppet::Error)
156
 
        proc { @class.new(:name => 'foo', :hour => '1z5') }.should raise_error(Puppet::Error)
157
 
        proc { @class.new(:name => 'foo', :hour => '15z') }.should raise_error(Puppet::Error)
 
146
        proc { described_class.new(:name => 'foo', :hour => 'z15') }.should raise_error(Puppet::Error, /z15 is not a valid hour/)
 
147
        proc { described_class.new(:name => 'foo', :hour => '1z5') }.should raise_error(Puppet::Error, /1z5 is not a valid hour/)
 
148
        proc { described_class.new(:name => 'foo', :hour => '15z') }.should raise_error(Puppet::Error, /15z is not a valid hour/)
158
149
      end
159
150
 
160
151
      it "should not support single values out of range" do
161
 
        proc { @class.new(:name => 'foo', :hour => '-1') }.should raise_error(Puppet::Error)
162
 
        proc { @class.new(:name => 'foo', :hour => '24') }.should raise_error(Puppet::Error)
163
 
        proc { @class.new(:name => 'foo', :hour => '120') }.should raise_error(Puppet::Error)
 
152
        proc { described_class.new(:name => 'foo', :hour => '-1') }.should raise_error(Puppet::Error, /-1 is not a valid hour/)
 
153
        proc { described_class.new(:name => 'foo', :hour => '24') }.should raise_error(Puppet::Error, /24 is not a valid hour/)
 
154
        proc { described_class.new(:name => 'foo', :hour => '120') }.should raise_error(Puppet::Error, /120 is not a valid hour/)
164
155
      end
165
156
 
166
157
      it "should support valid multiple values" do
167
 
        proc { @class.new(:name => 'foo', :hour => ['0','1','23'] ) }.should_not raise_error
168
 
        proc { @class.new(:name => 'foo', :hour => ['5','16','14'] ) }.should_not raise_error
169
 
        proc { @class.new(:name => 'foo', :hour => ['16','13','9'] ) }.should_not raise_error
 
158
        proc { described_class.new(:name => 'foo', :hour => ['0','1','23'] ) }.should_not raise_error
 
159
        proc { described_class.new(:name => 'foo', :hour => ['5','16','14'] ) }.should_not raise_error
 
160
        proc { described_class.new(:name => 'foo', :hour => ['16','13','9'] ) }.should_not raise_error
170
161
      end
171
162
 
172
163
      it "should not support multiple values if at least one is invalid" do
173
164
        # one invalid
174
 
        proc { @class.new(:name => 'foo', :hour => ['0','1','24'] ) }.should raise_error(Puppet::Error)
175
 
        proc { @class.new(:name => 'foo', :hour => ['0','-1','5'] ) }.should raise_error(Puppet::Error)
176
 
        proc { @class.new(:name => 'foo', :hour => ['-1','1','23'] ) }.should raise_error(Puppet::Error)
 
165
        proc { described_class.new(:name => 'foo', :hour => ['0','1','24'] ) }.should raise_error(Puppet::Error, /24 is not a valid hour/)
 
166
        proc { described_class.new(:name => 'foo', :hour => ['0','-1','5'] ) }.should raise_error(Puppet::Error, /-1 is not a valid hour/)
 
167
        proc { described_class.new(:name => 'foo', :hour => ['-1','1','23'] ) }.should raise_error(Puppet::Error, /-1 is not a valid hour/)
177
168
        # two invalid
178
 
        proc { @class.new(:name => 'foo', :hour => ['0','25','26'] ) }.should raise_error(Puppet::Error)
 
169
        proc { described_class.new(:name => 'foo', :hour => ['0','25','26'] ) }.should raise_error(Puppet::Error, /(25|26) is not a valid hour/)
179
170
        # all invalid
180
 
        proc { @class.new(:name => 'foo', :hour => ['-1','24','120'] ) }.should raise_error(Puppet::Error)
 
171
        proc { described_class.new(:name => 'foo', :hour => ['-1','24','120'] ) }.should raise_error(Puppet::Error, /(-1|24|120) is not a valid hour/)
181
172
      end
182
173
 
183
174
      it "should support valid step syntax" do
184
 
        proc { @class.new(:name => 'foo', :hour => '*/2' ) }.should_not raise_error
185
 
        proc { @class.new(:name => 'foo', :hour => '10-18/4' ) }.should_not raise_error
 
175
        proc { described_class.new(:name => 'foo', :hour => '*/2' ) }.should_not raise_error
 
176
        proc { described_class.new(:name => 'foo', :hour => '10-18/4' ) }.should_not raise_error
186
177
      end
187
178
 
188
179
      it "should not support invalid steps" do
189
 
        proc { @class.new(:name => 'foo', :hour => '*/A' ) }.should raise_error(Puppet::Error)
190
 
        proc { @class.new(:name => 'foo', :hour => '*/2A' ) }.should raise_error(Puppet::Error)
 
180
        proc { described_class.new(:name => 'foo', :hour => '*/A' ) }.should raise_error(Puppet::Error, /\*\/A is not a valid hour/)
 
181
        proc { described_class.new(:name => 'foo', :hour => '*/2A' ) }.should raise_error(Puppet::Error, /\*\/2A is not a valid hour/)
191
182
        # As it turns out cron does not complaining about steps that exceed the valid range
192
 
        # proc { @class.new(:name => 'foo', :hour => '*/26' ) }.should raise_error(Puppet::Error)
 
183
        # proc { described_class.new(:name => 'foo', :hour => '*/26' ) }.should raise_error(Puppet::Error, /is not a valid hour/)
193
184
      end
194
 
 
195
185
    end
196
186
 
197
 
   describe "weekday" do
198
 
 
 
187
    describe "weekday" do
199
188
      it "should support absent" do
200
 
        proc { @class.new(:name => 'foo', :weekday => 'absent') }.should_not raise_error
 
189
        proc { described_class.new(:name => 'foo', :weekday => 'absent') }.should_not raise_error
201
190
      end
202
191
 
203
192
      it "should support *" do
204
 
        proc { @class.new(:name => 'foo', :weekday => '*') }.should_not raise_error
 
193
        proc { described_class.new(:name => 'foo', :weekday => '*') }.should_not raise_error
205
194
      end
206
195
 
207
196
      it "should translate absent to :absent" do
208
 
        @class.new(:name => 'foo', :weekday => 'absent')[:weekday].should == :absent
 
197
        described_class.new(:name => 'foo', :weekday => 'absent')[:weekday].should == :absent
209
198
      end
210
199
 
211
200
      it "should translate * to :absent" do
212
 
        @class.new(:name => 'foo', :weekday => '*')[:weekday].should == :absent
 
201
        described_class.new(:name => 'foo', :weekday => '*')[:weekday].should == :absent
213
202
      end
214
203
 
215
204
      it "should support valid numeric weekdays" do
216
 
        proc { @class.new(:name => 'foo', :weekday => '0') }.should_not raise_error
217
 
        proc { @class.new(:name => 'foo', :weekday => '1') }.should_not raise_error
218
 
        proc { @class.new(:name => 'foo', :weekday => '6') }.should_not raise_error
 
205
        proc { described_class.new(:name => 'foo', :weekday => '0') }.should_not raise_error
 
206
        proc { described_class.new(:name => 'foo', :weekday => '1') }.should_not raise_error
 
207
        proc { described_class.new(:name => 'foo', :weekday => '6') }.should_not raise_error
219
208
        # According to http://www.manpagez.com/man/5/crontab 7 is also valid (Sunday)
220
 
        proc { @class.new(:name => 'foo', :weekday => '7') }.should_not raise_error
221
 
      end
222
 
 
223
 
      it "should support valid weekdays as words (3 character version)" do
224
 
        proc { @class.new(:name => 'foo', :weekday => 'Monday') }.should_not raise_error
225
 
        proc { @class.new(:name => 'foo', :weekday => 'Tuesday') }.should_not raise_error
226
 
        proc { @class.new(:name => 'foo', :weekday => 'Wednesday') }.should_not raise_error
227
 
        proc { @class.new(:name => 'foo', :weekday => 'Thursday') }.should_not raise_error
228
 
        proc { @class.new(:name => 'foo', :weekday => 'Friday') }.should_not raise_error
229
 
        proc { @class.new(:name => 'foo', :weekday => 'Saturday') }.should_not raise_error
230
 
        proc { @class.new(:name => 'foo', :weekday => 'Sunday') }.should_not raise_error
231
 
      end
232
 
 
233
 
      it "should support valid weekdays as words (3 character version)" do
234
 
        proc { @class.new(:name => 'foo', :weekday => 'Mon') }.should_not raise_error
235
 
        proc { @class.new(:name => 'foo', :weekday => 'Tue') }.should_not raise_error
236
 
        proc { @class.new(:name => 'foo', :weekday => 'Wed') }.should_not raise_error
237
 
        proc { @class.new(:name => 'foo', :weekday => 'Thu') }.should_not raise_error
238
 
        proc { @class.new(:name => 'foo', :weekday => 'Fri') }.should_not raise_error
239
 
        proc { @class.new(:name => 'foo', :weekday => 'Sat') }.should_not raise_error
240
 
        proc { @class.new(:name => 'foo', :weekday => 'Sun') }.should_not raise_error
 
209
        proc { described_class.new(:name => 'foo', :weekday => '7') }.should_not raise_error
 
210
      end
 
211
 
 
212
      it "should support valid weekdays as words (long version)" do
 
213
        proc { described_class.new(:name => 'foo', :weekday => 'Monday') }.should_not raise_error
 
214
        proc { described_class.new(:name => 'foo', :weekday => 'Tuesday') }.should_not raise_error
 
215
        proc { described_class.new(:name => 'foo', :weekday => 'Wednesday') }.should_not raise_error
 
216
        proc { described_class.new(:name => 'foo', :weekday => 'Thursday') }.should_not raise_error
 
217
        proc { described_class.new(:name => 'foo', :weekday => 'Friday') }.should_not raise_error
 
218
        proc { described_class.new(:name => 'foo', :weekday => 'Saturday') }.should_not raise_error
 
219
        proc { described_class.new(:name => 'foo', :weekday => 'Sunday') }.should_not raise_error
 
220
      end
 
221
 
 
222
      it "should support valid weekdays as words (3 character version)" do
 
223
        proc { described_class.new(:name => 'foo', :weekday => 'Mon') }.should_not raise_error
 
224
        proc { described_class.new(:name => 'foo', :weekday => 'Tue') }.should_not raise_error
 
225
        proc { described_class.new(:name => 'foo', :weekday => 'Wed') }.should_not raise_error
 
226
        proc { described_class.new(:name => 'foo', :weekday => 'Thu') }.should_not raise_error
 
227
        proc { described_class.new(:name => 'foo', :weekday => 'Fri') }.should_not raise_error
 
228
        proc { described_class.new(:name => 'foo', :weekday => 'Sat') }.should_not raise_error
 
229
        proc { described_class.new(:name => 'foo', :weekday => 'Sun') }.should_not raise_error
241
230
      end
242
231
 
243
232
      it "should not support numeric values out of range" do
244
 
        proc { @class.new(:name => 'foo', :weekday => '-1') }.should raise_error(Puppet::Error)
245
 
        proc { @class.new(:name => 'foo', :weekday => '8') }.should raise_error(Puppet::Error)
 
233
        proc { described_class.new(:name => 'foo', :weekday => '-1') }.should raise_error(Puppet::Error, /-1 is not a valid weekday/)
 
234
        proc { described_class.new(:name => 'foo', :weekday => '8') }.should raise_error(Puppet::Error, /8 is not a valid weekday/)
246
235
      end
247
236
 
248
237
      it "should not support invalid weekday names" do
249
 
        proc { @class.new(:name => 'foo', :weekday => 'Sar') }.should raise_error(Puppet::Error)
 
238
        proc { described_class.new(:name => 'foo', :weekday => 'Sar') }.should raise_error(Puppet::Error, /Sar is not a valid weekday/)
250
239
      end
251
240
 
252
241
      it "should support valid multiple values" do
253
 
        proc { @class.new(:name => 'foo', :weekday => ['0','1','6'] ) }.should_not raise_error
254
 
        proc { @class.new(:name => 'foo', :weekday => ['Mon','Wed','Friday'] ) }.should_not raise_error
 
242
        proc { described_class.new(:name => 'foo', :weekday => ['0','1','6'] ) }.should_not raise_error
 
243
        proc { described_class.new(:name => 'foo', :weekday => ['Mon','Wed','Friday'] ) }.should_not raise_error
255
244
      end
256
245
 
257
246
      it "should not support multiple values if at least one is invalid" do
258
247
        # one invalid
259
 
        proc { @class.new(:name => 'foo', :weekday => ['0','1','8'] ) }.should raise_error(Puppet::Error)
260
 
        proc { @class.new(:name => 'foo', :weekday => ['Mon','Fii','Sat'] ) }.should raise_error(Puppet::Error)
 
248
        proc { described_class.new(:name => 'foo', :weekday => ['0','1','8'] ) }.should raise_error(Puppet::Error, /8 is not a valid weekday/)
 
249
        proc { described_class.new(:name => 'foo', :weekday => ['Mon','Fii','Sat'] ) }.should raise_error(Puppet::Error, /Fii is not a valid weekday/)
261
250
        # two invalid
262
 
        proc { @class.new(:name => 'foo', :weekday => ['Mos','Fii','Sat'] ) }.should raise_error(Puppet::Error)
 
251
        proc { described_class.new(:name => 'foo', :weekday => ['Mos','Fii','Sat'] ) }.should raise_error(Puppet::Error, /(Mos|Fii) is not a valid weekday/)
263
252
        # all invalid
264
 
        proc { @class.new(:name => 'foo', :weekday => ['Mos','Fii','Saa'] ) }.should raise_error(Puppet::Error)
265
 
        proc { @class.new(:name => 'foo', :weekday => ['-1','8','11'] ) }.should raise_error(Puppet::Error)
 
253
        proc { described_class.new(:name => 'foo', :weekday => ['Mos','Fii','Saa'] ) }.should raise_error(Puppet::Error, /(Mos|Fii|Saa) is not a valid weekday/)
 
254
        proc { described_class.new(:name => 'foo', :weekday => ['-1','8','11'] ) }.should raise_error(Puppet::Error, /(-1|8|11) is not a valid weekday/)
266
255
      end
267
256
 
268
257
      it "should support valid step syntax" do
269
 
        proc { @class.new(:name => 'foo', :weekday => '*/2' ) }.should_not raise_error
270
 
        proc { @class.new(:name => 'foo', :weekday => '0-4/2' ) }.should_not raise_error
 
258
        proc { described_class.new(:name => 'foo', :weekday => '*/2' ) }.should_not raise_error
 
259
        proc { described_class.new(:name => 'foo', :weekday => '0-4/2' ) }.should_not raise_error
271
260
      end
272
261
 
273
262
      it "should not support invalid steps" do
274
 
        proc { @class.new(:name => 'foo', :weekday => '*/A' ) }.should raise_error(Puppet::Error)
275
 
        proc { @class.new(:name => 'foo', :weekday => '*/2A' ) }.should raise_error(Puppet::Error)
 
263
        proc { described_class.new(:name => 'foo', :weekday => '*/A' ) }.should raise_error(Puppet::Error, /\*\/A is not a valid weekday/)
 
264
        proc { described_class.new(:name => 'foo', :weekday => '*/2A' ) }.should raise_error(Puppet::Error, /\*\/2A is not a valid weekday/)
276
265
        # As it turns out cron does not complaining about steps that exceed the valid range
277
 
        # proc { @class.new(:name => 'foo', :weekday => '*/9' ) }.should raise_error(Puppet::Error)
 
266
        # proc { described_class.new(:name => 'foo', :weekday => '*/9' ) }.should raise_error(Puppet::Error, /is not a valid weekday/)
278
267
      end
279
 
 
280
268
    end
281
269
 
282
270
    describe "month" do
283
 
 
284
271
      it "should support absent" do
285
 
        proc { @class.new(:name => 'foo', :month => 'absent') }.should_not raise_error
 
272
        proc { described_class.new(:name => 'foo', :month => 'absent') }.should_not raise_error
286
273
      end
287
274
 
288
275
      it "should support *" do
289
 
        proc { @class.new(:name => 'foo', :month => '*') }.should_not raise_error
 
276
        proc { described_class.new(:name => 'foo', :month => '*') }.should_not raise_error
290
277
      end
291
278
 
292
279
      it "should translate absent to :absent" do
293
 
        @class.new(:name => 'foo', :month => 'absent')[:month].should == :absent
 
280
        described_class.new(:name => 'foo', :month => 'absent')[:month].should == :absent
294
281
      end
295
282
 
296
283
      it "should translate * to :absent" do
297
 
        @class.new(:name => 'foo', :month => '*')[:month].should == :absent
 
284
        described_class.new(:name => 'foo', :month => '*')[:month].should == :absent
298
285
      end
299
286
 
300
287
      it "should support valid numeric values" do
301
 
        proc { @class.new(:name => 'foo', :month => '1') }.should_not raise_error
302
 
        proc { @class.new(:name => 'foo', :month => '12') }.should_not raise_error
 
288
        proc { described_class.new(:name => 'foo', :month => '1') }.should_not raise_error
 
289
        proc { described_class.new(:name => 'foo', :month => '12') }.should_not raise_error
303
290
      end
304
291
 
305
292
      it "should support valid months as words" do
306
 
        proc { @class.new(:name => 'foo', :month => 'January') }.should_not raise_error
307
 
        proc { @class.new(:name => 'foo', :month => 'February') }.should_not raise_error
308
 
        proc { @class.new(:name => 'foo', :month => 'March') }.should_not raise_error
309
 
        proc { @class.new(:name => 'foo', :month => 'April') }.should_not raise_error
310
 
        proc { @class.new(:name => 'foo', :month => 'May') }.should_not raise_error
311
 
        proc { @class.new(:name => 'foo', :month => 'June') }.should_not raise_error
312
 
        proc { @class.new(:name => 'foo', :month => 'July') }.should_not raise_error
313
 
        proc { @class.new(:name => 'foo', :month => 'August') }.should_not raise_error
314
 
        proc { @class.new(:name => 'foo', :month => 'September') }.should_not raise_error
315
 
        proc { @class.new(:name => 'foo', :month => 'October') }.should_not raise_error
316
 
        proc { @class.new(:name => 'foo', :month => 'November') }.should_not raise_error
317
 
        proc { @class.new(:name => 'foo', :month => 'December') }.should_not raise_error
 
293
        proc { described_class.new(:name => 'foo', :month => 'January') }.should_not raise_error
 
294
        proc { described_class.new(:name => 'foo', :month => 'February') }.should_not raise_error
 
295
        proc { described_class.new(:name => 'foo', :month => 'March') }.should_not raise_error
 
296
        proc { described_class.new(:name => 'foo', :month => 'April') }.should_not raise_error
 
297
        proc { described_class.new(:name => 'foo', :month => 'May') }.should_not raise_error
 
298
        proc { described_class.new(:name => 'foo', :month => 'June') }.should_not raise_error
 
299
        proc { described_class.new(:name => 'foo', :month => 'July') }.should_not raise_error
 
300
        proc { described_class.new(:name => 'foo', :month => 'August') }.should_not raise_error
 
301
        proc { described_class.new(:name => 'foo', :month => 'September') }.should_not raise_error
 
302
        proc { described_class.new(:name => 'foo', :month => 'October') }.should_not raise_error
 
303
        proc { described_class.new(:name => 'foo', :month => 'November') }.should_not raise_error
 
304
        proc { described_class.new(:name => 'foo', :month => 'December') }.should_not raise_error
318
305
      end
319
306
 
320
307
      it "should support valid months as words (3 character short version)" do
321
 
        proc { @class.new(:name => 'foo', :month => 'Jan') }.should_not raise_error
322
 
        proc { @class.new(:name => 'foo', :month => 'Feb') }.should_not raise_error
323
 
        proc { @class.new(:name => 'foo', :month => 'Mar') }.should_not raise_error
324
 
        proc { @class.new(:name => 'foo', :month => 'Apr') }.should_not raise_error
325
 
        proc { @class.new(:name => 'foo', :month => 'May') }.should_not raise_error
326
 
        proc { @class.new(:name => 'foo', :month => 'Jun') }.should_not raise_error
327
 
        proc { @class.new(:name => 'foo', :month => 'Jul') }.should_not raise_error
328
 
        proc { @class.new(:name => 'foo', :month => 'Aug') }.should_not raise_error
329
 
        proc { @class.new(:name => 'foo', :month => 'Sep') }.should_not raise_error
330
 
        proc { @class.new(:name => 'foo', :month => 'Oct') }.should_not raise_error
331
 
        proc { @class.new(:name => 'foo', :month => 'Nov') }.should_not raise_error
332
 
        proc { @class.new(:name => 'foo', :month => 'Dec') }.should_not raise_error
 
308
        proc { described_class.new(:name => 'foo', :month => 'Jan') }.should_not raise_error
 
309
        proc { described_class.new(:name => 'foo', :month => 'Feb') }.should_not raise_error
 
310
        proc { described_class.new(:name => 'foo', :month => 'Mar') }.should_not raise_error
 
311
        proc { described_class.new(:name => 'foo', :month => 'Apr') }.should_not raise_error
 
312
        proc { described_class.new(:name => 'foo', :month => 'May') }.should_not raise_error
 
313
        proc { described_class.new(:name => 'foo', :month => 'Jun') }.should_not raise_error
 
314
        proc { described_class.new(:name => 'foo', :month => 'Jul') }.should_not raise_error
 
315
        proc { described_class.new(:name => 'foo', :month => 'Aug') }.should_not raise_error
 
316
        proc { described_class.new(:name => 'foo', :month => 'Sep') }.should_not raise_error
 
317
        proc { described_class.new(:name => 'foo', :month => 'Oct') }.should_not raise_error
 
318
        proc { described_class.new(:name => 'foo', :month => 'Nov') }.should_not raise_error
 
319
        proc { described_class.new(:name => 'foo', :month => 'Dec') }.should_not raise_error
333
320
      end
334
321
 
335
322
      it "should not support numeric values out of range" do
336
 
        proc { @class.new(:name => 'foo', :month => '-1') }.should raise_error(Puppet::Error)
337
 
        proc { @class.new(:name => 'foo', :month => '0') }.should raise_error(Puppet::Error)
338
 
        proc { @class.new(:name => 'foo', :month => '13') }.should raise_error(Puppet::Error)
 
323
        proc { described_class.new(:name => 'foo', :month => '-1') }.should raise_error(Puppet::Error, /-1 is not a valid month/)
 
324
        proc { described_class.new(:name => 'foo', :month => '0') }.should raise_error(Puppet::Error, /0 is not a valid month/)
 
325
        proc { described_class.new(:name => 'foo', :month => '13') }.should raise_error(Puppet::Error, /13 is not a valid month/)
339
326
      end
340
327
 
341
328
      it "should not support words that are not valid months" do
342
 
        proc { @class.new(:name => 'foo', :month => 'Jal') }.should raise_error(Puppet::Error)
 
329
        proc { described_class.new(:name => 'foo', :month => 'Jal') }.should raise_error(Puppet::Error, /Jal is not a valid month/)
343
330
      end
344
331
 
345
332
      it "should not support single values out of range" do
346
333
 
347
 
        proc { @class.new(:name => 'foo', :month => '-1') }.should raise_error(Puppet::Error)
348
 
        proc { @class.new(:name => 'foo', :month => '60') }.should raise_error(Puppet::Error)
349
 
        proc { @class.new(:name => 'foo', :month => '61') }.should raise_error(Puppet::Error)
350
 
        proc { @class.new(:name => 'foo', :month => '120') }.should raise_error(Puppet::Error)
 
334
        proc { described_class.new(:name => 'foo', :month => '-1') }.should raise_error(Puppet::Error, /-1 is not a valid month/)
 
335
        proc { described_class.new(:name => 'foo', :month => '60') }.should raise_error(Puppet::Error, /60 is not a valid month/)
 
336
        proc { described_class.new(:name => 'foo', :month => '61') }.should raise_error(Puppet::Error, /61 is not a valid month/)
 
337
        proc { described_class.new(:name => 'foo', :month => '120') }.should raise_error(Puppet::Error, /120 is not a valid month/)
351
338
      end
352
339
 
353
340
      it "should support valid multiple values" do
354
 
        proc { @class.new(:name => 'foo', :month => ['1','9','12'] ) }.should_not raise_error
355
 
        proc { @class.new(:name => 'foo', :month => ['Jan','March','Jul'] ) }.should_not raise_error
 
341
        proc { described_class.new(:name => 'foo', :month => ['1','9','12'] ) }.should_not raise_error
 
342
        proc { described_class.new(:name => 'foo', :month => ['Jan','March','Jul'] ) }.should_not raise_error
356
343
      end
357
344
 
358
345
      it "should not support multiple values if at least one is invalid" do
359
346
        # one invalid
360
 
        proc { @class.new(:name => 'foo', :month => ['0','1','12'] ) }.should raise_error(Puppet::Error)
361
 
        proc { @class.new(:name => 'foo', :month => ['1','13','10'] ) }.should raise_error(Puppet::Error)
362
 
        proc { @class.new(:name => 'foo', :month => ['Jan','Feb','Jxx'] ) }.should raise_error(Puppet::Error)
 
347
        proc { described_class.new(:name => 'foo', :month => ['0','1','12'] ) }.should raise_error(Puppet::Error, /0 is not a valid month/)
 
348
        proc { described_class.new(:name => 'foo', :month => ['1','13','10'] ) }.should raise_error(Puppet::Error, /13 is not a valid month/)
 
349
        proc { described_class.new(:name => 'foo', :month => ['Jan','Feb','Jxx'] ) }.should raise_error(Puppet::Error, /Jxx is not a valid month/)
363
350
        # two invalid
364
 
        proc { @class.new(:name => 'foo', :month => ['Jan','Fex','Jux'] ) }.should raise_error(Puppet::Error)
 
351
        proc { described_class.new(:name => 'foo', :month => ['Jan','Fex','Jux'] ) }.should raise_error(Puppet::Error, /(Fex|Jux) is not a valid month/)
365
352
        # all invalid
366
 
        proc { @class.new(:name => 'foo', :month => ['-1','0','13'] ) }.should raise_error(Puppet::Error)
367
 
        proc { @class.new(:name => 'foo', :month => ['Jax','Fex','Aux'] ) }.should raise_error(Puppet::Error)
 
353
        proc { described_class.new(:name => 'foo', :month => ['-1','0','13'] ) }.should raise_error(Puppet::Error, /(-1|0|13) is not a valid month/)
 
354
        proc { described_class.new(:name => 'foo', :month => ['Jax','Fex','Aux'] ) }.should raise_error(Puppet::Error, /(Jax|Fex|Aux) is not a valid month/)
368
355
      end
369
356
 
370
357
      it "should support valid step syntax" do
371
 
        proc { @class.new(:name => 'foo', :month => '*/2' ) }.should_not raise_error
372
 
        proc { @class.new(:name => 'foo', :month => '1-12/3' ) }.should_not raise_error
 
358
        proc { described_class.new(:name => 'foo', :month => '*/2' ) }.should_not raise_error
 
359
        proc { described_class.new(:name => 'foo', :month => '1-12/3' ) }.should_not raise_error
373
360
      end
374
361
 
375
362
      it "should not support invalid steps" do
376
 
        proc { @class.new(:name => 'foo', :month => '*/A' ) }.should raise_error(Puppet::Error)
377
 
        proc { @class.new(:name => 'foo', :month => '*/2A' ) }.should raise_error(Puppet::Error)
 
363
        proc { described_class.new(:name => 'foo', :month => '*/A' ) }.should raise_error(Puppet::Error, /\*\/A is not a valid month/)
 
364
        proc { described_class.new(:name => 'foo', :month => '*/2A' ) }.should raise_error(Puppet::Error, /\*\/2A is not a valid month/)
378
365
        # As it turns out cron does not complaining about steps that exceed the valid range
379
 
        # proc { @class.new(:name => 'foo', :month => '*/13' ) }.should raise_error(Puppet::Error)
 
366
        # proc { described_class.new(:name => 'foo', :month => '*/13' ) }.should raise_error(Puppet::Error, /is not a valid month/)
380
367
      end
381
 
 
382
368
    end
383
369
 
384
370
    describe "monthday" do
385
 
 
386
371
      it "should support absent" do
387
 
        proc { @class.new(:name => 'foo', :monthday => 'absent') }.should_not raise_error
 
372
        proc { described_class.new(:name => 'foo', :monthday => 'absent') }.should_not raise_error
388
373
      end
389
374
 
390
375
      it "should support *" do
391
 
        proc { @class.new(:name => 'foo', :monthday => '*') }.should_not raise_error
 
376
        proc { described_class.new(:name => 'foo', :monthday => '*') }.should_not raise_error
392
377
      end
393
378
 
394
379
      it "should translate absent to :absent" do
395
 
        @class.new(:name => 'foo', :monthday => 'absent')[:monthday].should == :absent
 
380
        described_class.new(:name => 'foo', :monthday => 'absent')[:monthday].should == :absent
396
381
      end
397
382
 
398
383
      it "should translate * to :absent" do
399
 
        @class.new(:name => 'foo', :monthday => '*')[:monthday].should == :absent
 
384
        described_class.new(:name => 'foo', :monthday => '*')[:monthday].should == :absent
400
385
      end
401
386
 
402
387
      it "should support valid single values" do
403
 
        proc { @class.new(:name => 'foo', :monthday => '1') }.should_not raise_error
404
 
        proc { @class.new(:name => 'foo', :monthday => '30') }.should_not raise_error
405
 
        proc { @class.new(:name => 'foo', :monthday => '31') }.should_not raise_error
 
388
        proc { described_class.new(:name => 'foo', :monthday => '1') }.should_not raise_error
 
389
        proc { described_class.new(:name => 'foo', :monthday => '30') }.should_not raise_error
 
390
        proc { described_class.new(:name => 'foo', :monthday => '31') }.should_not raise_error
406
391
      end
407
392
 
408
393
      it "should not support non numeric characters" do
409
 
        proc { @class.new(:name => 'foo', :monthday => 'z23') }.should raise_error(Puppet::Error)
410
 
        proc { @class.new(:name => 'foo', :monthday => '2z3') }.should raise_error(Puppet::Error)
411
 
        proc { @class.new(:name => 'foo', :monthday => '23z') }.should raise_error(Puppet::Error)
 
394
        proc { described_class.new(:name => 'foo', :monthday => 'z23') }.should raise_error(Puppet::Error, /z23 is not a valid monthday/)
 
395
        proc { described_class.new(:name => 'foo', :monthday => '2z3') }.should raise_error(Puppet::Error, /2z3 is not a valid monthday/)
 
396
        proc { described_class.new(:name => 'foo', :monthday => '23z') }.should raise_error(Puppet::Error, /23z is not a valid monthday/)
412
397
      end
413
398
 
414
399
      it "should not support single values out of range" do
415
 
        proc { @class.new(:name => 'foo', :monthday => '-1') }.should raise_error(Puppet::Error)
416
 
        proc { @class.new(:name => 'foo', :monthday => '0') }.should raise_error(Puppet::Error)
417
 
        proc { @class.new(:name => 'foo', :monthday => '32') }.should raise_error(Puppet::Error)
 
400
        proc { described_class.new(:name => 'foo', :monthday => '-1') }.should raise_error(Puppet::Error, /-1 is not a valid monthday/)
 
401
        proc { described_class.new(:name => 'foo', :monthday => '0') }.should raise_error(Puppet::Error, /0 is not a valid monthday/)
 
402
        proc { described_class.new(:name => 'foo', :monthday => '32') }.should raise_error(Puppet::Error, /32 is not a valid monthday/)
418
403
      end
419
404
 
420
405
      it "should support valid multiple values" do
421
 
        proc { @class.new(:name => 'foo', :monthday => ['1','23','31'] ) }.should_not raise_error
422
 
        proc { @class.new(:name => 'foo', :monthday => ['31','23','1'] ) }.should_not raise_error
423
 
        proc { @class.new(:name => 'foo', :monthday => ['1','31','23'] ) }.should_not raise_error
 
406
        proc { described_class.new(:name => 'foo', :monthday => ['1','23','31'] ) }.should_not raise_error
 
407
        proc { described_class.new(:name => 'foo', :monthday => ['31','23','1'] ) }.should_not raise_error
 
408
        proc { described_class.new(:name => 'foo', :monthday => ['1','31','23'] ) }.should_not raise_error
424
409
      end
425
410
 
426
411
      it "should not support multiple values if at least one is invalid" do
427
412
        # one invalid
428
 
        proc { @class.new(:name => 'foo', :monthday => ['1','23','32'] ) }.should raise_error(Puppet::Error)
429
 
        proc { @class.new(:name => 'foo', :monthday => ['-1','12','23'] ) }.should raise_error(Puppet::Error)
430
 
        proc { @class.new(:name => 'foo', :monthday => ['13','32','30'] ) }.should raise_error(Puppet::Error)
 
413
        proc { described_class.new(:name => 'foo', :monthday => ['1','23','32'] ) }.should raise_error(Puppet::Error, /32 is not a valid monthday/)
 
414
        proc { described_class.new(:name => 'foo', :monthday => ['-1','12','23'] ) }.should raise_error(Puppet::Error, /-1 is not a valid monthday/)
 
415
        proc { described_class.new(:name => 'foo', :monthday => ['13','32','30'] ) }.should raise_error(Puppet::Error, /32 is not a valid monthday/)
431
416
        # two invalid
432
 
        proc { @class.new(:name => 'foo', :monthday => ['-1','0','23'] ) }.should raise_error(Puppet::Error)
 
417
        proc { described_class.new(:name => 'foo', :monthday => ['-1','0','23'] ) }.should raise_error(Puppet::Error, /(-1|0) is not a valid monthday/)
433
418
        # all invalid
434
 
        proc { @class.new(:name => 'foo', :monthday => ['-1','0','32'] ) }.should raise_error(Puppet::Error)
 
419
        proc { described_class.new(:name => 'foo', :monthday => ['-1','0','32'] ) }.should raise_error(Puppet::Error, /(-1|0|32) is not a valid monthday/)
435
420
      end
436
421
 
437
422
      it "should support valid step syntax" do
438
 
        proc { @class.new(:name => 'foo', :monthday => '*/2' ) }.should_not raise_error
439
 
        proc { @class.new(:name => 'foo', :monthday => '10-16/2' ) }.should_not raise_error
 
423
        proc { described_class.new(:name => 'foo', :monthday => '*/2' ) }.should_not raise_error
 
424
        proc { described_class.new(:name => 'foo', :monthday => '10-16/2' ) }.should_not raise_error
440
425
      end
441
426
 
442
427
      it "should not support invalid steps" do
443
 
        proc { @class.new(:name => 'foo', :monthday => '*/A' ) }.should raise_error(Puppet::Error)
444
 
        proc { @class.new(:name => 'foo', :monthday => '*/2A' ) }.should raise_error(Puppet::Error)
 
428
        proc { described_class.new(:name => 'foo', :monthday => '*/A' ) }.should raise_error(Puppet::Error, /\*\/A is not a valid monthday/)
 
429
        proc { described_class.new(:name => 'foo', :monthday => '*/2A' ) }.should raise_error(Puppet::Error, /\*\/2A is not a valid monthday/)
445
430
        # As it turns out cron does not complaining about steps that exceed the valid range
446
 
        # proc { @class.new(:name => 'foo', :monthday => '*/32' ) }.should raise_error(Puppet::Error)
 
431
        # proc { described_class.new(:name => 'foo', :monthday => '*/32' ) }.should raise_error(Puppet::Error, /is not a valid monthday/)
447
432
      end
448
 
 
449
433
    end
450
434
 
451
435
    describe "environment" do
452
 
 
453
436
      it "it should accept an :environment that looks like a path" do
454
437
        lambda do
455
 
          @cron[:environment] = 'PATH=/bin:/usr/bin:/usr/sbin'
 
438
          described_class.new(:name => 'foo',:environment => 'PATH=/bin:/usr/bin:/usr/sbin')
456
439
        end.should_not raise_error
457
440
      end
458
441
 
459
442
      it "should not accept environment variables that do not contain '='" do
460
443
        lambda do
461
 
          @cron[:environment] = "INVALID"
462
 
        end.should raise_error(Puppet::Error)
 
444
          described_class.new(:name => 'foo',:environment => 'INVALID')
 
445
        end.should raise_error(Puppet::Error, /Invalid environment setting "INVALID"/)
463
446
      end
464
447
 
465
448
      it "should accept empty environment variables that do not contain '='" do
466
449
        lambda do
467
 
          @cron[:environment] = "MAILTO="
 
450
          described_class.new(:name => 'foo',:environment => 'MAILTO=')
468
451
        end.should_not raise_error(Puppet::Error)
469
452
      end
470
453
 
471
454
      it "should accept 'absent'" do
472
455
        lambda do
473
 
          @cron[:environment] = 'absent'
 
456
          described_class.new(:name => 'foo',:environment => 'absent')
474
457
        end.should_not raise_error(Puppet::Error)
475
458
      end
476
459
 
477
460
    end
478
 
 
 
461
  end
 
462
 
 
463
  describe "when autorequiring resources" do
 
464
 
 
465
    before :each do
 
466
      @user_bob = Puppet::Type.type(:user).new(:name => 'bob', :ensure => :present)
 
467
      @user_alice = Puppet::Type.type(:user).new(:name => 'alice', :ensure => :present)
 
468
      @catalog = Puppet::Resource::Catalog.new
 
469
      @catalog.add_resource @user_bob, @user_alice
 
470
    end
 
471
 
 
472
    it "should autorequire the user" do
 
473
      @resource = described_class.new(:name => 'dummy', :command => '/usr/bin/uptime', :user => 'alice')
 
474
      @catalog.add_resource @resource
 
475
      req = @resource.autorequire
 
476
      req.size.should == 1
 
477
      req[0].target.must == @resource
 
478
      req[0].source.must == @user_alice
 
479
    end
479
480
  end
480
481
 
481
482
  it "should require a command when adding an entry" do
482
 
    entry = @class.new(:name => "test_entry", :ensure => :present)
483
 
    expect { entry.value(:command) }.should raise_error(/No command/)
 
483
    entry = described_class.new(:name => "test_entry", :ensure => :present)
 
484
    expect { entry.value(:command) }.should raise_error(Puppet::Error, /No command/)
484
485
  end
485
486
 
486
487
  it "should not require a command when removing an entry" do
487
 
    entry = @class.new(:name => "test_entry", :ensure => :absent)
 
488
    entry = described_class.new(:name => "test_entry", :ensure => :absent)
488
489
    entry.value(:command).should == nil
489
490
  end
 
491
 
 
492
  it "should default to user => root if Etc.getpwuid(Process.uid) returns nil (#12357)" do
 
493
    Etc.expects(:getpwuid).returns(nil)
 
494
    entry = described_class.new(:name => "test_entry", :ensure => :present)
 
495
    entry.value(:user).should eql "root"
 
496
  end
490
497
end