puppet 6.0.10-universal-darwin → 6.1.0-universal-darwin

data/spec/unit/type/component_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 component = Puppet::Type.type(:component)

data/spec/unit/type/exec_spec.rb

@@ -1,10 +1,11 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
-RSpec.describe Puppet::Type.type(:exec) do
+describe Puppet::Type.type(:exec) do
   include PuppetSpec::Files
 
   def exec_tester(command, exitstatus = 0, rest = {})
-    allow(Puppet.features).to receive(:root?).and_return(true)
+    Puppet.features.stubs(:root?).returns(true)
 
     output = rest.delete(:output) || ''
 
@@ -20,44 +21,16 @@ RSpec.describe Puppet::Type.type(:exec) do
     }.merge(rest)
 
     exec = Puppet::Type.type(:exec).new(type_args)
-    expect(Puppet::Util::Execution).to receive(:execute) do |cmd, options|
-      expect(cmd).to eq(command)
-      expect(options[:override_locale]).to eq(false)
-      expect(options).to have_key(:custom_environment)
 
-      output
-    end.exactly(tries).times
+    Puppet::Util::Execution.expects(:execute).times(tries).with() do |*args|
+      args[0] == command &&
+      args[1][:override_locale] == false &&
+      args[1].has_key?(:custom_environment)
+    end.returns(output)
 
     return exec
   end
 
-  def exec_stub(options = {})
-    command = options.delete(:command) || @command
-    #unless_val = options.delete(:unless) || :true
-    type_args = {
-      :name   => command,
-      #:unless => unless_val,
-    }.merge(options)
-
-    # Chicken, meet egg:
-    # Provider methods have to be stubbed before resource init or checks fail
-    # We have to set 'unless' in resource init or it can not be marked sensitive correctly.
-    # So: we create a dummy ahead of time and use 'any_instance' to stub out provider methods.
-    dummy = Puppet::Type.type(:exec).new(:name => @command)
-    allow_any_instance_of(dummy.provider.class).to receive(:validatecmd)
-    allow_any_instance_of(dummy.provider.class).to receive(:checkexe).and_return(true)
-    pass_status = double('status', :exitstatus => 0, :split => ["pass output"])
-    fail_status = double('status', :exitstatus => 1, :split => ["fail output"])
-    allow(Puppet::Util::Execution).to receive(:execute).with(:true, anything).and_return(pass_status)
-    allow(Puppet::Util::Execution).to receive(:execute).with(:false, anything).and_return(fail_status)
-
-    test = Puppet::Type.type(:exec).new(type_args)
-
-    Puppet::Util::Log.level = :debug
-
-    return test
-  end
-
   before do
     @command = make_absolute('/bin/true whatever')
     @executable = make_absolute('/bin/true')
@@ -203,26 +176,6 @@ RSpec.describe Puppet::Type.type(:exec) do
       expect(@logs).to eq([])
     end
 
-    describe "when checks stop execution when debugging" do
-      [[:unless, :true], [:onlyif, :false]].each do |check, result|
-        it "should log a message with the command when #{check} is #{result}" do
-          output = "'#{@command}' won't be executed because of failed check '#{check}'"
-          test = exec_stub({:command => @command, check => result})
-          expect(test.check_all_attributes).to eq(false)
-          expect(@logs).to include(an_object_having_attributes(level: :debug, message: output))
-        end
-
-        it "should log a message with a redacted command and check if #{check} is sensitive" do
-          output1 = "Executing check '[redacted]'"
-          output2 = "'[command redacted]' won't be executed because of failed check '#{check}'"
-          test = exec_stub({:command => @command, check => result, :sensitive_parameters => [check]})
-          expect(test.check_all_attributes).to eq(false)
-          expect(@logs).to include(an_object_having_attributes(level: :debug, message: output1))
-          expect(@logs).to include(an_object_having_attributes(level: :debug, message: output2))
-        end
-      end
-    end
-
     describe " when multiple tries are set," do
       it "should repeat the command attempt 'tries' times on failure and produce an error" do
         tries = 5
@@ -280,15 +233,15 @@ RSpec.describe Puppet::Type.type(:exec) do
   describe "when setting user" do
     describe "on POSIX systems", :if => Puppet.features.posix? do
       it "should fail if we are not root" do
-        allow(Puppet.features).to receive(:root?).and_return(false)
+        Puppet.features.stubs(:root?).returns(false)
         expect {
           Puppet::Type.type(:exec).new(:name => '/bin/true whatever', :user => 'input')
         }.to raise_error Puppet::Error, /Parameter user failed/
       end
 
       it "accepts the current user" do
-        allow(Puppet.features).to receive(:root?).and_return(false)
-        allow(Etc).to receive(:getpwuid).and_return(Struct::Passwd.new('input'))
+        Puppet.features.stubs(:root?).returns(false)
+        Etc.stubs(:getpwuid).returns(Struct::Passwd.new('input'))
 
         type = Puppet::Type.type(:exec).new(:name => '/bin/true whatever', :user => 'input')
 
@@ -297,7 +250,7 @@ RSpec.describe Puppet::Type.type(:exec) do
 
       ['one', 2, 'root', 4294967295, 4294967296].each do |value|
         it "should accept '#{value}' as user if we are root" do
-          allow(Puppet.features).to receive(:root?).and_return(true)
+          Puppet.features.stubs(:root?).returns(true)
           type = Puppet::Type.type(:exec).new(:name => '/bin/true whatever', :user => value)
           expect(type[:user]).to eq(value)
         end
@@ -306,7 +259,7 @@ RSpec.describe Puppet::Type.type(:exec) do
 
     describe "on Windows systems", :if => Puppet::Util::Platform.windows? do
       before :each do
-        allow(Puppet.features).to receive(:root?).and_return(true)
+        Puppet.features.stubs(:root?).returns(true)
       end
 
       it "should reject user parameter" do
@@ -328,16 +281,12 @@ RSpec.describe Puppet::Type.type(:exec) do
     end
 
     describe "when running as root" do
-      before(:each) do
-        allow(Puppet.features).to receive(:root?).and_return(true)
-      end
+      before :each do Puppet.features.stubs(:root?).returns(true) end
       it_behaves_like "exec[:group]"
     end
 
     describe "when not running as root" do
-      before(:each) do
-        allow(Puppet.features).to receive(:root?).and_return(false)
-      end
+      before :each do Puppet.features.stubs(:root?).returns(false) end
       it_behaves_like "exec[:group]"
     end
   end
@@ -365,9 +314,9 @@ RSpec.describe Puppet::Type.type(:exec) do
             instance = Puppet::Type.type(:exec).new(:name => @executable)
           end
           if valid then
-            expect(instance.provider).to receive(:validatecmd).and_return(true)
+            instance.provider.expects(:validatecmd).returns(true)
           else
-            expect(instance.provider).to receive(:validatecmd).and_raise(Puppet::Error, "from a stub")
+            instance.provider.expects(:validatecmd).raises(Puppet::Error, "from a stub")
           end
           instance[@param] = command
         end
@@ -392,16 +341,16 @@ RSpec.describe Puppet::Type.type(:exec) do
 
       it "should accept the array when all commands return valid" do
         input = %w{one two three}
-        expect(@test.provider).to receive(:validatecmd).exactly(input.length).times.and_return(true)
+        @test.provider.expects(:validatecmd).times(input.length).returns(true)
         @test[param] = input
         expect(@test[param]).to eq(input)
       end
 
       it "should reject the array when any commands return invalid" do
         input = %w{one two three}
-        expect(@test.provider).to receive(:validatecmd).with(input.first).and_return(false)
+        @test.provider.expects(:validatecmd).with(input.first).returns(false)
         input[1..-1].each do |cmd|
-          expect(@test.provider).to receive(:validatecmd).with(cmd).and_return(true)
+          @test.provider.expects(:validatecmd).with(cmd).returns(true)
         end
         @test[param] = input
         expect(@test[param]).to eq(input)
@@ -409,7 +358,7 @@ RSpec.describe Puppet::Type.type(:exec) do
 
       it "should reject the array when all commands return invalid" do
         input = %w{one two three}
-        expect(@test.provider).to receive(:validatecmd).exactly(input.length).times.and_return(false)
+        @test.provider.expects(:validatecmd).times(input.length).returns(false)
         @test[param] = input
         expect(@test[param]).to eq(input)
       end
@@ -490,7 +439,7 @@ RSpec.describe Puppet::Type.type(:exec) do
 
         context 'on POSIX', :unless => Puppet::Util::Platform.windows? || RUBY_PLATFORM == 'java' do
           it 'sends a SIGTERM and raises a Puppet::Error' do
-            expect(Process).to receive(:kill).at_least(:once)
+            Process.expects(:kill).at_least_once
             expect { subject.refresh }.to raise_error Puppet::Error, "Command exceeded timeout"
           end
         end
@@ -696,15 +645,15 @@ RSpec.describe Puppet::Type.type(:exec) do
           @pass = make_absolute("/magic/pass")
           @fail = make_absolute("/magic/fail")
 
-          @pass_status = double('status', :exitstatus => sense[:pass] ? 0 : 1)
-          @fail_status = double('status', :exitstatus => sense[:fail] ? 0 : 1)
+          @pass_status = stub('status', :exitstatus => sense[:pass] ? 0 : 1)
+          @fail_status = stub('status', :exitstatus => sense[:fail] ? 0 : 1)
 
-          allow(@test.provider).to receive(:checkexe).and_return(true)
+          @test.provider.stubs(:checkexe).returns(true)
           [true, false].each do |check|
-            allow(@test.provider).to receive(:run).with(@pass, check).
-              and_return(['test output', @pass_status])
-            allow(@test.provider).to receive(:run).with(@fail, check).
-              and_return(['test output', @fail_status])
+            @test.provider.stubs(:run).with(@pass, check).
+              returns(['test output', @pass_status])
+            @test.provider.stubs(:run).with(@fail, check).
+              returns(['test output', @fail_status])
           end
         end
 
@@ -765,17 +714,17 @@ RSpec.describe Puppet::Type.type(:exec) do
     end
 
     it "should return :notrun when check_all_attributes returns true" do
-      allow(@exec_resource).to receive(:check_all_attributes).and_return(true)
+      @exec_resource.stubs(:check_all_attributes).returns true
       expect(@exec_resource.retrieve[:returns]).to eq(:notrun)
     end
 
     it "should return default exit code 0 when check_all_attributes returns false" do
-      allow(@exec_resource).to receive(:check_all_attributes).and_return(false)
+      @exec_resource.stubs(:check_all_attributes).returns false
       expect(@exec_resource.retrieve[:returns]).to eq(['0'])
     end
 
     it "should return the specified exit code when check_all_attributes returns false" do
-      allow(@exec_resource).to receive(:check_all_attributes).and_return(false)
+      @exec_resource.stubs(:check_all_attributes).returns false
       @exec_resource[:returns] = 42
       expect(@exec_resource.retrieve[:returns]).to eq(["42"])
     end
@@ -787,11 +736,11 @@ RSpec.describe Puppet::Type.type(:exec) do
     end
 
     it "should return the provider's run output" do
-      provider = double('provider')
-      status = double('process_status')
-      allow(status).to receive(:exitstatus).and_return("0")
-      expect(provider).to receive(:run).and_return(["silly output", status])
-      allow(@exec_resource).to receive(:provider).and_return(provider)
+      provider = stub 'provider'
+      status = stubs "process_status"
+      status.stubs(:exitstatus).returns("0")
+      provider.expects(:run).returns(["silly output", status])
+      @exec_resource.stubs(:provider).returns(provider)
 
       @exec_resource.refresh
       expect(@exec_resource.output).to eq('silly output')
@@ -805,29 +754,29 @@ RSpec.describe Puppet::Type.type(:exec) do
 
     it "should call provider run with the refresh parameter if it is set" do
       myother_bogus_cmd = make_absolute('/myother/bogus/cmd')
-      provider = double('provider')
-      allow(@exec_resource).to receive(:provider).and_return(provider)
-      allow(@exec_resource).to receive(:[]).with(:refresh).and_return(myother_bogus_cmd)
-      expect(provider).to receive(:run).with(myother_bogus_cmd)
+      provider = stub 'provider'
+      @exec_resource.stubs(:provider).returns(provider)
+      @exec_resource.stubs(:[]).with(:refresh).returns(myother_bogus_cmd)
+      provider.expects(:run).with(myother_bogus_cmd)
 
       @exec_resource.refresh
     end
 
     it "should call provider run with the specified command if the refresh parameter is not set" do
-      provider = double('provider')
-      status = double('process_status')
-      allow(status).to receive(:exitstatus).and_return("0")
-      expect(provider).to receive(:run).with(@bogus_cmd).and_return(["silly output", status])
-      allow(@exec_resource).to receive(:provider).and_return(provider)
+      provider = stub 'provider'
+      status = stubs "process_status"
+      status.stubs(:exitstatus).returns("0")
+      provider.expects(:run).with(@bogus_cmd).returns(["silly output", status])
+      @exec_resource.stubs(:provider).returns(provider)
 
       @exec_resource.refresh
     end
 
     it "should not run the provider if check_all_attributes is false" do
-      allow(@exec_resource).to receive(:check_all_attributes).and_return(false)
-      provider = double('provider')
-      expect(provider).not_to receive(:run)
-      allow(@exec_resource).to receive(:provider).and_return(provider)
+      @exec_resource.stubs(:check_all_attributes).returns false
+      provider = stub 'provider'
+      provider.expects(:run).never
+      @exec_resource.stubs(:provider).returns(provider)
 
       @exec_resource.refresh
     end

data/spec/unit/type/file/checksum_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 checksum = Puppet::Type.type(:file).attrclass(:checksum)
@@ -14,12 +15,12 @@ describe checksum do
 
   it "should use its current value when asked to sum content" do
     @checksum.value = :md5lite
-    expect(@checksum).to receive(:md5lite).with("foobar").and_return("yay")
+    @checksum.expects(:md5lite).with("foobar").returns "yay"
     @checksum.sum("foobar")
   end
 
   it "should use :md5 to sum when no value is set" do
-    expect(@checksum).to receive(:md5).with("foobar").and_return("yay")
+    @checksum.expects(:md5).with("foobar").returns "yay"
     @checksum.sum("foobar")
   end
 
@@ -53,36 +54,36 @@ describe checksum do
 
   it "should use its current value when asked to sum a file's content" do
     @checksum.value = :md5lite
-    expect(@checksum).to receive(:md5lite_file).with(@path).and_return("yay")
+    @checksum.expects(:md5lite_file).with(@path).returns "yay"
     @checksum.sum_file(@path)
   end
 
   it "should use :md5 to sum a file when no value is set" do
-    expect(@checksum).to receive(:md5_file).with(@path).and_return("yay")
+    @checksum.expects(:md5_file).with(@path).returns "yay"
     @checksum.sum_file(@path)
   end
 
   it "should convert all sums to strings when summing files" do
     @checksum.value = :mtime
-    expect(@checksum).to receive(:mtime_file).with(@path).and_return(Time.now)
+    @checksum.expects(:mtime_file).with(@path).returns Time.now
     expect { @checksum.sum_file(@path) }.not_to raise_error
   end
 
   it "should return the summed contents of a file with a checksum label" do
     @resource[:checksum] = :md5
-    expect(@checksum).to receive(:md5_file).and_return("mysum")
+    @checksum.expects(:md5_file).returns "mysum"
     expect(@checksum.sum_file(@path)).to eq("{md5}mysum")
   end
 
   it "should return the summed contents of a stream with a checksum label" do
     @resource[:checksum] = :md5
-    expect(@checksum).to receive(:md5_stream).and_return("mysum")
+    @checksum.expects(:md5_stream).returns "mysum"
     expect(@checksum.sum_stream).to eq("{md5}mysum")
   end
 
   it "should yield the sum_stream block to the underlying checksum" do
     @resource[:checksum] = :md5
-    expect(@checksum).to receive(:md5_stream).and_yield("something").and_return("mysum")
+    @checksum.expects(:md5_stream).yields("something").returns("mysum")
     @checksum.sum_stream do |sum|
       expect(sum).to eq("something")
     end
@@ -95,7 +96,7 @@ describe checksum do
   end
 
   it 'rejects md5 checksums in FIPS mode' do
-    allow(Puppet::Util::Platform).to receive(:fips_enabled?).and_return(true)
+    Puppet::Util::Platform.stubs(:fips_enabled?).returns true
     expect {
       @resource[:checksum] = :md5
     }.to raise_error(Puppet::ResourceError,

data/spec/unit/type/file/checksum_value_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums => true do
@@ -18,7 +19,7 @@ describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums =>
     let(:checksum_value) { described_class.new(:resource => resource) }
 
     it "should not compute a checksum if source is absent" do
-      expect(resource).not_to receive(:stat)
+      resource.expects(:stat).never
       expect(checksum_value.retrieve).to be_nil
     end
 
@@ -28,21 +29,21 @@ describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums =>
       end
 
       it "should return :absent if the target does not exist" do
-        expect(resource).to receive(:stat).and_return(nil)
+        resource.expects(:stat).returns nil
 
         expect(checksum_value.retrieve).to eq(:absent)
       end
 
       it "should not manage content on directories" do
-        stat = double('stat', :ftype => "directory")
-        expect(resource).to receive(:stat).and_return(stat)
+        stat = mock 'stat', :ftype => "directory"
+        resource.expects(:stat).returns stat
 
         expect(checksum_value.retrieve).to be_nil
       end
 
       it "should not manage content on links" do
-        stat = double('stat', :ftype => "link")
-        expect(resource).to receive(:stat).and_return(stat)
+        stat = mock 'stat', :ftype => "link"
+        resource.expects(:stat).returns stat
 
         expect(checksum_value.retrieve).to be_nil
       end
@@ -50,11 +51,11 @@ describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums =>
       it "should always return the checksum as a string" do
         resource[:checksum] = :mtime
 
-        stat = double('stat', :ftype => "file")
-        expect(resource).to receive(:stat).and_return(stat)
+        stat = mock 'stat', :ftype => "file"
+        resource.expects(:stat).returns stat
 
         time = Time.now
-        expect(resource.parameter(:checksum)).to receive(:mtime_file).with(resource[:path]).and_return(time)
+        resource.parameter(:checksum).expects(:mtime_file).with(resource[:path]).returns time
 
         expect(checksum_value.retrieve).to eq(time.to_s)
       end
@@ -62,9 +63,9 @@ describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums =>
 
     with_digest_algorithms do
       it "should return the checksum of the target if it exists and is a normal file" do
-        stat = double('stat', :ftype => "file")
-        expect(resource).to receive(:stat).and_return(stat)
-        expect(resource.parameter(:checksum)).to receive("#{digest_algorithm}_file".intern).with(resource[:path]).and_return("mysum")
+        stat = mock 'stat', :ftype => "file"
+        resource.expects(:stat).returns stat
+        resource.parameter(:checksum).expects("#{digest_algorithm}_file".intern).with(resource[:path]).returns "mysum"
         resource[:source] = source_file
 
         expect(checksum_value.retrieve).to eq("mysum")
@@ -95,7 +96,7 @@ describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums =>
         end
 
         it "should return true if the resource shouldn't be a regular file" do
-          expect(resource).to receive(:should_be_file?).and_return(false)
+          resource.expects(:should_be_file?).returns false
           checksum_value.should = "foo"
           expect(checksum_value).to be_safe_insync("whatever")
         end
@@ -106,7 +107,7 @@ describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums =>
         end
 
         it "should return false if the file should be a file but is not present" do
-          expect(resource).to receive(:should_be_file?).and_return(true)
+          resource.expects(:should_be_file?).returns true
           checksum_value.should = "foo"
 
           expect(checksum_value).not_to be_safe_insync(:absent)
@@ -114,7 +115,7 @@ describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums =>
 
         describe "and the file exists" do
           before do
-            allow(resource).to receive(:stat).and_return(double("stat"))
+            resource.stubs(:stat).returns mock("stat")
             checksum_value.should = "somechecksum"
           end
 
@@ -134,19 +135,19 @@ describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums =>
             describe "and Puppet[:show_diff] is #{cfg} and show_diff => #{param}" do
               before do
                 Puppet[:show_diff] = cfg
-                allow(resource).to receive(:show_diff?).and_return(param)
+                resource.stubs(:show_diff?).returns param
                 resource[:loglevel] = "debug"
               end
 
               if cfg and param
                 it "should display a diff" do
-                  expect(checksum_value).to receive(:diff).and_return("my diff").once
-                  expect(checksum_value).to receive(:debug).with("\nmy diff").once
+                  checksum_value.expects(:diff).returns("my diff").once
+                  checksum_value.expects(:debug).with("\nmy diff").once
                   expect(checksum_value).not_to be_safe_insync("otherchecksum")
                 end
               else
                 it "should not display a diff" do
-                  expect(checksum_value).not_to receive(:diff)
+                  checksum_value.expects(:diff).never
                   expect(checksum_value).not_to be_safe_insync("otherchecksum")
                 end
               end
@@ -201,17 +202,17 @@ describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums =>
 
       describe "and :replace is false" do
         before do
-          allow(resource).to receive(:replace?).and_return(false)
+          resource.stubs(:replace?).returns false
         end
 
         it "should be insync if the file exists and the checksum_value is different" do
-          allow(resource).to receive(:stat).and_return(double('stat'))
+          resource.stubs(:stat).returns mock('stat')
 
           expect(checksum_value).to be_safe_insync("whatever")
         end
 
         it "should be insync if the file exists and the checksum_value is right" do
-          allow(resource).to receive(:stat).and_return(double('stat'))
+          resource.stubs(:stat).returns mock('stat')
 
           expect(checksum_value).to be_safe_insync("something")
         end
@@ -230,7 +231,7 @@ describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums =>
         before do
           @new_resource = Puppet::Type.type(:file).new :ensure => :file, :path => path, :catalog => catalog,
             :checksum_value => checksum, :checksum => checksum_type, :source => source_file
-          allow(@new_resource).to receive(:stat).and_return(double('stat'))
+          @new_resource.stubs(:stat).returns mock('stat')
         end
 
         it "should return false if the current checksum_value is different from the desired checksum_value" do
@@ -248,12 +249,12 @@ describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums =>
     let(:checksum_value) { described_class.new(:resource => resource) }
 
     before do
-      allow(resource).to receive(:[]).with(:path).and_return("/boo")
-      allow(resource).to receive(:stat).and_return("eh")
+      resource.stubs(:[]).with(:path).returns "/boo"
+      resource.stubs(:stat).returns "eh"
     end
 
     it "should raise if source is absent" do
-      expect(resource).not_to receive(:write)
+      resource.expects(:write).never
 
       expect { checksum_value.sync }.to raise_error "checksum_value#sync should not be called without a source parameter"
     end
@@ -264,20 +265,20 @@ describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums =>
       end
 
       it "should use the file's :write method to write the checksum_value" do
-        expect(resource).to receive(:write).with(resource.parameter(:source))
+        resource.expects(:write).with(resource.parameter(:source))
 
         checksum_value.sync
       end
 
       it "should return :file_changed if the file already existed" do
-        expect(resource).to receive(:stat).and_return("something")
-        allow(resource).to receive(:write)
+        resource.expects(:stat).returns "something"
+        resource.stubs(:write)
         expect(checksum_value.sync).to eq(:file_changed)
       end
 
       it "should return :file_created if the file did not exist" do
-        expect(resource).to receive(:stat).and_return(nil)
-        allow(resource).to receive(:write)
+        resource.expects(:stat).returns nil
+        resource.stubs(:write)
         expect(checksum_value.sync).to eq(:file_created)
       end
     end