spec/unit/util/pidlock_spec.rb


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
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218

#! /usr/bin/env ruby
require 'spec_helper'

require 'puppet/util/pidlock'

describe Puppet::Util::Pidlock do
  require 'puppet_spec/files'
  include PuppetSpec::Files

  before(:each) do
    @lockfile = tmpfile("lock")
    @lock = Puppet::Util::Pidlock.new(@lockfile)
  end

  describe "#lock" do
    it "should not be locked at start" do
      @lock.should_not be_locked
    end

    it "should not be mine at start" do
      @lock.should_not be_mine
    end

    it "should become locked" do
      @lock.lock
      @lock.should be_locked
    end

    it "should become mine" do
      @lock.lock
      @lock.should be_mine
    end

    it "should be possible to lock multiple times" do
      @lock.lock
      lambda { @lock.lock }.should_not raise_error
    end

    it "should return true when locking" do
      @lock.lock.should be_true
    end

    it "should return true if locked by me" do
      @lock.lock
      @lock.lock.should be_true
    end

    it "should create a lock file" do
      @lock.lock
      Puppet::FileSystem.exist?(@lockfile).should be_true
    end

    it 'should create an empty lock file even when pid is missing' do
      Process.stubs(:pid).returns('')
      @lock.lock
      Puppet::FileSystem.exist?(@lock.file_path).should be_true
      Puppet::FileSystem.read(@lock.file_path).should be_empty
    end

    it 'should replace an existing empty lockfile with a pid, given a subsequent lock call made against a valid pid' do
      # empty pid results in empty lockfile
      Process.stubs(:pid).returns('')
      @lock.lock
      Puppet::FileSystem.exist?(@lock.file_path).should be_true

      # next lock call with valid pid kills existing empty lockfile
      Process.stubs(:pid).returns(1234)
      @lock.lock
      Puppet::FileSystem.exist?(@lock.file_path).should be_true
      Puppet::FileSystem.read(@lock.file_path).should == '1234'
    end

    it "should expose the lock file_path" do
      @lock.file_path.should == @lockfile
    end
  end

  describe "#unlock" do
    it "should not be locked anymore" do
      @lock.lock
      @lock.unlock
      @lock.should_not be_locked
    end

    it "should return false if not locked" do
      @lock.unlock.should be_false
    end

    it "should return true if properly unlocked" do
      @lock.lock
      @lock.unlock.should be_true
    end

    it "should get rid of the lock file" do
      @lock.lock
      @lock.unlock
      Puppet::FileSystem.exist?(@lockfile).should be_false
    end
  end

  describe "#locked?" do
    it "should return true if locked" do
      @lock.lock
      @lock.should be_locked
    end

    it "should remove the lockfile when pid is missing" do
      Process.stubs(:pid).returns('')
      @lock.lock
      @lock.locked?.should be_false
      Puppet::FileSystem.exist?(@lock.file_path).should be_false
    end
  end

  describe '#lock_pid' do
    it 'should return nil if the pid is empty' do
      # fake pid to get empty lockfile
      Process.stubs(:pid).returns('')
      @lock.lock
      @lock.lock_pid.should == nil
    end
  end

  describe "with a stale lock" do
    before(:each) do
      # fake our pid to be 1234
      Process.stubs(:pid).returns(1234)
      # lock the file
      @lock.lock
      # fake our pid to be a different pid, to simulate someone else
      #  holding the lock
      Process.stubs(:pid).returns(6789)

      Process.stubs(:kill).with(0, 6789)
      Process.stubs(:kill).with(0, 1234).raises(Errno::ESRCH)
    end

    it "should not be locked" do
      @lock.should_not be_locked
    end

    describe "#lock" do
      it "should clear stale locks" do
        @lock.locked?.should be_false
        Puppet::FileSystem.exist?(@lockfile).should be_false
      end

      it "should replace with new locks" do
        @lock.lock
        Puppet::FileSystem.exist?(@lockfile).should be_true
        @lock.lock_pid.should == 6789
        @lock.should be_mine
        @lock.should be_locked
      end
    end

    describe "#unlock" do
      it "should not be allowed" do
        @lock.unlock.should be_false
      end

      it "should not remove the lock file" do
        @lock.unlock
        Puppet::FileSystem.exist?(@lockfile).should be_true
      end
    end
  end

  describe "with another process lock" do
    before(:each) do
      # fake our pid to be 1234
      Process.stubs(:pid).returns(1234)
      # lock the file
      @lock.lock
      # fake our pid to be a different pid, to simulate someone else
      #  holding the lock
      Process.stubs(:pid).returns(6789)

      Process.stubs(:kill).with(0, 6789)
      Process.stubs(:kill).with(0, 1234)
    end

    it "should be locked" do
      @lock.should be_locked
    end

    it "should not be mine" do
      @lock.should_not be_mine
    end

    describe "#lock" do
      it "should not be possible" do
        @lock.lock.should be_false
      end

      it "should not overwrite the lock" do
        @lock.lock
        @lock.should_not be_mine
      end
    end

    describe "#unlock" do
      it "should not be possible" do
        @lock.unlock.should be_false
      end

      it "should not remove the lock file" do
        @lock.unlock
        Puppet::FileSystem.exist?(@lockfile).should be_true
      end

      it "should still not be our lock" do
        @lock.unlock
        @lock.should_not be_mine
      end
    end
  end
end