puppet 4.0.0 → 4.10.0

data/spec/unit/etc_spec.rb

@@ -0,0 +1,234 @@
+require 'puppet'
+require 'spec_helper'
+
+# The Ruby::Etc module is largely non-functional on Windows - many methods
+# simply return nil regardless of input, the Etc::Group struct is not defined,
+# and Etc::Passwd is missing fields
+describe Puppet::Etc, :if => !Puppet.features.microsoft_windows? do
+  let(:bin) { 'bin'.force_encoding(Encoding::ISO_8859_1) }
+  let(:root) { 'root'.force_encoding(Encoding::ISO_8859_1) }
+  let(:x) { 'x'.force_encoding(Encoding::ISO_8859_1) }
+  let(:daemon) { 'daemon'.force_encoding(Encoding::ISO_8859_1) }
+  let(:root_comment) { 'i am the root user'.force_encoding(Encoding::ISO_8859_1) }
+  let(:user_struct_iso_8859_1) { Etc::Passwd.new(root, x, 0, 0, root_comment) }
+  let(:group_struct_iso_8859_1) { Etc::Group.new(bin, x, 1, [root, bin, daemon]) }
+
+  # http://www.fileformat.info/info/unicode/char/5e0c/index.htm
+  # 希 Han Character 'rare; hope, expect, strive for'
+  # In EUC_KR: \xfd \xf1 - 253 241
+  # Not convertible to UTF-8, likely to be read in as BINARY by Ruby unless system is in EUC_KR
+  let(:not_convertible) { [254, 241].pack('C*') }
+
+  # characters representing different UTF-8 widths
+  # 1-byte A
+  # 2-byte ۿ - http://www.fileformat.info/info/unicode/char/06ff/index.htm - 0xDB 0xBF / 219 191
+  # 3-byte ᚠ - http://www.fileformat.info/info/unicode/char/16A0/index.htm - 0xE1 0x9A 0xA0 / 225 154 160
+  # 4-byte 𠜎 - http://www.fileformat.info/info/unicode/char/2070E/index.htm - 0xF0 0xA0 0x9C 0x8E / 240 160 156 142
+  #
+  # Should all convert cleanly to UTF-8
+  # Unless the system is in UTF-8, these will likely be read in as BINARY by Ruby
+  let(:convertible_utf8) { "A\u06FF\u16A0\u{2070E}" } # Aۿᚠ𠜎
+  let(:convertible_binary) { "A\u06FF\u16A0\u{2070E}".force_encoding(Encoding::BINARY) }
+
+  # For the methods described which actually expect an encoding conversion, we
+  # only superficially test via #force_encoding - the deeper level testing is in
+  # character_encoding_spec.rb which handles testing transcoding etc.
+
+  describe "getgrent" do
+    context "given an original system Etc Group struct with ISO-8850-1 string values" do
+      before { Etc.expects(:getgrent).returns(group_struct_iso_8859_1) }
+      let(:converted) { Puppet::Etc.getgrent }
+
+      it "should return a struct with :name and :passwd field values converted to UTF-8" do
+        [converted.name, converted.passwd].each do |value|
+          expect(value.encoding).to eq(Encoding::UTF_8)
+        end
+      end
+
+      it "should return a struct with a :mem array with all field values converted to UTF-8" do
+        converted.mem.each { |elem| expect(elem.encoding).to eq(Encoding::UTF_8) }
+      end
+    end
+
+    context "given an original Etc::Group struct with field values that cannot be converted to UTF-8" do
+      let(:group) { Etc::Group.new }
+      before do
+        # group membership contains valid and invalid UTF-8
+        group.mem = [convertible_binary, not_convertible]
+        # group name contains a value that is invalid UTF-8
+        group.name = not_convertible
+        # group passwd field is valid UTF-8
+        group.passwd = convertible_binary
+
+        Etc.expects(:getgrent).returns(group)
+      end
+
+      let(:converted) { Puppet::Etc.getgrent }
+
+      it "should convert convertible values in arrays to UTF-8" do
+        expect(converted.mem[0]).to eq("A\u06FF\u16A0\u{2070E}")
+        expect(converted.mem[0].encoding).to eq(Encoding::UTF_8) # just being explicit
+      end
+
+      it "should leave the unconvertible values unmodified" do
+        expect(converted.name).to eq([254, 241].pack('C*'))
+        expect(converted.name.encoding).to eq(Encoding::BINARY) # just being explicit
+      end
+
+      it "should leave unconvertible values in arrays unmodifed" do
+        expect(converted.mem[1]).to eq([254, 241].pack('C*'))
+        expect(converted.mem[1].encoding).to eq(Encoding::BINARY) # just being explicit
+      end
+
+      it "should convert values that can be converted to UTf-8" do
+        expect(converted.passwd).to eq("A\u06FF\u16A0\u{2070E}")
+        expect(converted.passwd.encoding).to eq(Encoding::UTF_8) # just being explicit
+      end
+    end
+  end
+
+  describe "endgrent" do
+    it "should call Etc.getgrent" do
+      Etc.expects(:getgrent)
+      Puppet::Etc.getgrent
+    end
+  end
+
+  describe "setgrent" do
+    it "should call Etc.setgrent" do
+      Etc.expects(:setgrent)
+      Puppet::Etc.setgrent
+    end
+  end
+
+  describe "getpwent" do
+    context "given an original system Etc Passwd struct with ISO-8859-1 string values" do
+      before { Etc.expects(:getpwent).returns(user_struct_iso_8859_1) }
+      let(:converted) { Puppet::Etc.getpwent }
+
+      it "should return an Etc Passwd struct with field values converted to UTF-8" do
+        [converted.name, converted.passwd, converted.gecos].each do |value|
+          expect(value.encoding).to eq(Encoding::UTF_8)
+        end
+      end
+    end
+
+    context "given an original Etc::Passwd struct with field values that cannot be converted to UTF-8" do
+      let(:user) { Etc::Passwd.new }
+      before do
+        # user comment field cannot be converted to UTF-8
+        user.gecos =  not_convertible
+        # user passwd field is valid UTF-8
+        user.passwd = convertible_binary
+
+        Etc.expects(:getpwent).returns(user)
+      end
+
+      let(:converted) { Puppet::Etc.getpwent }
+
+      it "should leave the unconvertible values unmodified" do
+        expect(converted.gecos).to eq([254, 241].pack('C*'))
+        expect(converted.gecos.encoding).to eq(Encoding::BINARY) # just being explicit
+      end
+
+      it "should convert values that can be converted to UTf-8" do
+        expect(converted.passwd).to eq("A\u06FF\u16A0\u{2070E}")
+        expect(converted.passwd.encoding).to eq(Encoding::UTF_8) # just being explicit
+      end
+    end
+  end
+
+  describe "endpwent" do
+    it "should call Etc.endpwent" do
+      Etc.expects(:endpwent)
+      Puppet::Etc.endpwent
+    end
+  end
+
+  describe "setpwent" do
+    it "should call Etc.setpwent" do
+      Etc.expects(:setpwent)
+      Puppet::Etc.setpwent
+    end
+  end
+
+  describe "getpwnam" do
+    context "given a username to query" do
+      it "should call Etc.getpwnam with that username" do
+        Etc.expects(:getpwnam).with('foo')
+        Puppet::Etc.getpwnam('foo')
+      end
+    end
+
+    context "given an original system Etc Passwd struct with ISO-8859-1 string values" do
+      it "should return an Etc Passwd struct with field values converted to UTF-8" do
+        Etc.expects(:getpwnam).with('root').returns(user_struct_iso_8859_1)
+        converted = Puppet::Etc.getpwnam('root')
+        [converted.name, converted.passwd, converted.gecos].each do |value|
+          expect(value.encoding).to eq(Encoding::UTF_8)
+        end
+      end
+    end
+  end
+
+  describe "getgrnam" do
+    context "given a group name to query" do
+      it "should call Etc.getgrnam with that group name" do
+        Etc.expects(:getgrnam).with('foo')
+        Puppet::Etc.getgrnam('foo')
+      end
+    end
+
+    context "given an original system Etc Group struct with ISO-8859-1 string values" do
+      it "should return an Etc Group struct with field values converted to UTF-8" do
+        Etc.expects(:getgrnam).with('bin').returns(group_struct_iso_8859_1)
+        converted = Puppet::Etc.getgrnam('bin')
+        [converted.name, converted.passwd].each do |value|
+          expect(value.encoding).to eq(Encoding::UTF_8)
+        end
+        converted.mem.each { |elem| expect(elem.encoding).to eq(Encoding::UTF_8) }
+      end
+    end
+  end
+
+  describe "getgrgid" do
+    context "given a group ID to query" do
+      it "should call Etc.getgrgid with the id" do
+        Etc.expects(:getgrgid).with(0)
+        Puppet::Etc.getgrgid(0)
+      end
+    end
+
+    context "given an original Etc Group struct with field values in ISO-8859-1" do
+      it "should return an Etc Group struct with field values converted to UTF-8" do
+        Etc.expects(:getgrgid).with(1).returns(group_struct_iso_8859_1)
+        converted = Puppet::Etc.getgrgid(1)
+        [converted.name, converted.passwd].each do |value|
+          expect(value.encoding).to eq(Encoding::UTF_8)
+        end
+        converted.mem.each { |elem| expect(elem.encoding).to eq(Encoding::UTF_8) }
+      end
+    end
+  end
+
+  describe "getpwid" do
+    context "given a UID to query" do
+      it "should call Etc.getpwuid with the id" do
+        Etc.expects(:getpwuid).with(2)
+        Puppet::Etc.getpwuid(2)
+      end
+    end
+  end
+
+  context "given an orginal Etc Passwd struct with field values in ISO-8859-1" do
+    it "should return an Etc Passwd struct with field values converted to UTF-8" do
+      Etc.expects(:getpwuid).with(0).returns(user_struct_iso_8859_1)
+      converted = Puppet::Etc.getpwuid(0)
+      [converted.name, converted.passwd, converted.gecos].each do |value|
+        expect(value.encoding).to eq(Encoding::UTF_8)
+      end
+    end
+  end
+
+
+end

data/spec/unit/face/ca_spec.rb

@@ -0,0 +1,10 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/face'
+
+describe Puppet::Face[:ca, '0.1.0'] do
+  it "should be deprecated" do
+    expect(subject.deprecated?).to be_truthy
+  end
+end
+

data/spec/unit/face/certificate_request_spec.rb

@@ -0,0 +1,10 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/face'
+
+describe Puppet::Face[:certificate_request, '0.0.1'] do
+  it "should be deprecated" do
+    expect(subject.deprecated?).to be_truthy
+  end
+end
+

data/spec/unit/face/certificate_revocation_list_spec.rb

@@ -0,0 +1,10 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/face'
+
+describe Puppet::Face[:certificate_revocation_list, '0.0.1'] do
+  it "should be deprecated" do
+    expect(subject.deprecated?).to be_truthy
+  end
+end
+

data/spec/unit/face/certificate_spec.rb

@@ -9,6 +9,13 @@ describe Puppet::Face[:certificate, '0.0.1'] do
 
   let(:ca) { Puppet::SSL::CertificateAuthority.instance }
 
+  # different UTF-8 widths
+  # 1-byte A
+  # 2-byte ۿ - http://www.fileformat.info/info/unicode/char/06ff/index.htm - 0xDB 0xBF / 219 191
+  # 3-byte ᚠ - http://www.fileformat.info/info/unicode/char/16A0/index.htm - 0xE1 0x9A 0xA0 / 225 154 160
+  # 4-byte ܎ - http://www.fileformat.info/info/unicode/char/2070E/index.htm - 0xF0 0xA0 0x9C 0x8E / 240 160 156 142
+  let (:mixed_utf8) { "A\u06FF\u16A0\u{2070E}" } # Aۿᚠ܎
+
   before :each do
     Puppet[:confdir] = tmpdir('conf')
     Puppet::SSL::CertificateAuthority.stubs(:ca?).returns true
@@ -84,9 +91,10 @@ describe Puppet::Face[:certificate, '0.0.1'] do
       it "should add the provided dns_alt_names if they are specified" do
         Puppet[:dns_alt_names] = 'from,the,config'
 
-        subject.generate(hostname, options.merge(:dns_alt_names => 'explicit,alt,names'))
+        subject.generate(hostname, options.merge(:dns_alt_names => "explicit,alt,#{mixed_utf8}"))
 
-        expected = %W[DNS:explicit DNS:alt DNS:names DNS:#{hostname}]
+        # CSRs will return subject_alt_names as BINARY strings
+        expected = %W[DNS:explicit DNS:alt DNS:#{mixed_utf8.force_encoding(Encoding::BINARY)} DNS:#{hostname}]
 
         expect(csr.subject_alt_names).to match_array(expected)
       end

data/spec/unit/face/config_spec.rb

@@ -44,6 +44,53 @@ syslogfacility = file
     subject.print('all')
   end
 
+  context "when setting config values" do
+    let(:config_file) { '/foo/puppet.conf' }
+    let(:path) { Pathname.new(config_file).expand_path }
+    before(:each) do
+      Puppet[:config] = config_file
+      Puppet::FileSystem.stubs(:pathname).with(path.to_s).returns(path)
+      Puppet::FileSystem.stubs(:touch)
+    end
+
+    it "writes to the correct puppet config file" do
+      Puppet::FileSystem.expects(:open).with(path, anything, anything)
+      subject.set('foo', 'bar')
+    end
+
+    it "creates a config file if one does not exist" do
+      Puppet::FileSystem.stubs(:open).with(path, anything, anything).yields(StringIO.new)
+      Puppet::FileSystem.expects(:touch).with(path)
+      subject.set('foo', 'bar')
+    end
+
+    it "sets the supplied config/value in the default section (main)" do
+      Puppet::FileSystem.stubs(:open).with(path, anything, anything).yields(StringIO.new)
+      config = Puppet::Settings::IniFile.new([Puppet::Settings::IniFile::DefaultSection.new])
+      manipulator = Puppet::Settings::IniFile::Manipulator.new(config)
+      Puppet::Settings::IniFile::Manipulator.stubs(:new).returns(manipulator)
+
+      manipulator.expects(:set).with("main", "foo", "bar")
+      subject.set('foo', 'bar')
+    end
+
+    it "sets the value in the supplied section" do
+      Puppet::FileSystem.stubs(:open).with(path, anything, anything).yields(StringIO.new)
+      config = Puppet::Settings::IniFile.new([Puppet::Settings::IniFile::DefaultSection.new])
+      manipulator = Puppet::Settings::IniFile::Manipulator.new(config)
+      Puppet::Settings::IniFile::Manipulator.stubs(:new).returns(manipulator)
+
+      manipulator.expects(:set).with("baz", "foo", "bar")
+      subject.set('foo', 'bar', {:section => "baz"})
+
+    end
+
+    it "opens the file with UTF-8 encoding" do
+      Puppet::FileSystem.expects(:open).with(path, nil, 'r+:UTF-8')
+      subject.set('foo', 'bar')
+    end
+  end
+
   shared_examples_for :config_printing_a_section do |section|
 
     def add_section_option(args, section)

data/spec/unit/face/epp_face_spec.rb

@@ -102,9 +102,6 @@ describe Puppet::Face[:epp, :current] do
     end
   end
 
-  context "render" do
-
-  end
 
   context "dump" do
     it "prints the AST of a template given with the -e option" do
@@ -150,7 +147,7 @@ describe Puppet::Face[:epp, :current] do
       dir = dir_containing('templates', { template_name => "<% 1 2 3 %>" })
       template = File.join(dir, template_name)
       expect(eppface.dump(template, :validate => true)).to eq("")
-      expect(@logs.join).to match(/This Literal Integer has no effect.* line 1:4/)
+      expect(@logs.join).to match(/This Literal Integer has no effect.*\/template1.epp:1:4/)
     end
 
     it "validated content by default" do
@@ -158,7 +155,7 @@ describe Puppet::Face[:epp, :current] do
       dir = dir_containing('templates', { template_name => "<% 1 2 3 %>" })
       template = File.join(dir, template_name)
       expect(eppface.dump(template)).to eq("")
-      expect(@logs.join).to match(/This Literal Integer has no effect.* line 1:4/)
+      expect(@logs.join).to match(/This Literal Integer has no effect.*\/template1.epp:1:4/)
     end
 
     it "informs the user of files that don't exist" do
@@ -232,6 +229,28 @@ describe Puppet::Face[:epp, :current] do
         ).to eq("goodbye mr Y")
     end
 
+    it "sets $facts" do
+      expect(eppface.render({ :e => 'facts is hash: <%= $facts =~ Hash %>' })).to eql("facts is hash: true")
+    end
+
+    it "sets $trusted" do
+      expect(eppface.render({ :e => 'trusted is hash: <%= $trusted =~ Hash %>' })).to eql("trusted is hash: true")
+    end
+
+    it "facts can be added to" do
+      expect(eppface.render({
+        :facts => {'the_crux' => 'biscuit'},
+        :e     => '<%= $facts[the_crux] %>', 
+      })).to eql("biscuit")
+    end
+
+    it "facts can be overridden" do
+      expect(eppface.render({
+        :facts => {'operatingsystem' => 'Merwin'},
+        :e     => '<%= $facts[operatingsystem] %>', 
+      })).to eql("Merwin")
+    end
+
     context "in an environment with templates" do
       let(:dir) do
         dir_containing('environments', { 'production' => { 'modules' => {

data/spec/unit/face/file_spec.rb

@@ -7,4 +7,8 @@ describe Puppet::Face[:file, '0.0.1'] do
     it { is_expected.to be_action action }
     it { is_expected.to respond_to action }
   end
+
+  it "should be deprecated" do
+    expect(subject.deprecated?).to be_truthy
+  end
 end

data/spec/unit/face/generate_spec.rb

@@ -0,0 +1,230 @@
+require 'spec_helper'
+require 'puppet_spec/files'
+
+require 'puppet/face'
+
+describe Puppet::Face[:generate, :current] do
+  include PuppetSpec::Files
+
+  let(:genface) { Puppet::Face[:generate, :current] }
+
+  # * Format is 'pcore' by default
+  # * Format is accepted as 'pcore'
+  # * Any format expect 'pcore' is an error
+  # * Produces output to '<envroot>/.resource_types'
+  # * Produces all types found on the module path (that are not in puppet core)
+  # * Output files match input
+  # * Removes files for which there is no input
+  # * Updates a pcore file if it is out of date
+  # * The --force flag overwrite the output even if it is up to date
+  # * Environment is set with --environment (setting) (not tested explicitly)
+  # Writes output for:
+  #   - isomorphic
+  #   - parameters
+  #   - properties
+  #   - title patterns
+  #   - type information is written when the type is X, Y, or Z
+  #
+  # Additional features
+  #   - blacklist? whitelist? types to exclude/include
+  #   - generate one resource type (somewhere on modulepath)
+  #   - output to directory of choice
+  #   - clean, clean the output directory (similar to force)
+  #
+
+  [:types].each do |action|
+    it { is_expected.to be_action(action) }
+    it { is_expected.to respond_to(action) }
+  end
+
+  context "when used from an interactive terminal" do
+    before :each do
+      from_an_interactive_terminal
+    end
+
+    context "in an environment with two modules containing resource types" do
+      let(:dir) do
+        dir_containing('environments', { 'testing_generate' => {
+          'environment.conf' => "modulepath = modules",
+          'manifests' => { 'site.pp' => "" },
+          'modules' => {
+            'm1' => {
+              'lib' => { 'puppet' => { 'type' => {
+                'test1.rb' => <<-EOF
+                module Puppet
+                Type.newtype(:test1) do
+                  @doc = "Docs for resource"
+                  newproperty(:message) do
+                    desc "Docs for 'message' property"
+                  end
+                  newparam(:name) do
+                    desc "Docs for 'name' parameter"
+                    isnamevar
+                  end
+                end; end
+                EOF
+               } }
+            },
+          },
+          'm2' => { 
+            'lib' => { 'puppet' => { 'type' => {
+              'test2.rb' => <<-EOF
+              module Puppet
+              Type.newtype(:test2) do
+                @doc = "Docs for resource"
+                newproperty(:message) do
+                  desc "Docs for 'message' property"
+                end
+                newparam(:name) do
+                  desc "Docs for 'name' parameter"
+                  isnamevar
+                end
+              end;end
+              EOF
+             } } },
+          }
+        }}})
+      end
+
+      let(:modulepath) do
+        File.join(dir, 'testing_generate', 'modules')
+      end
+
+      let(:m1) do
+        File.join(modulepath, 'm1')
+      end
+
+      let(:m2) do
+        File.join(modulepath, 'm2')
+      end
+
+      let(:outputdir) do
+        File.join(dir, 'testing_generate', '.resource_types')
+      end
+
+      around(:each) do |example|
+        Puppet.settings.initialize_global_settings
+        Puppet[:manifest] = ''
+        loader = Puppet::Environments::Directories.new(dir, [])
+        Puppet.override(:environments => loader) do
+          Puppet.override(:current_environment => loader.get('testing_generate')) do
+            example.run
+          end
+        end
+      end
+
+      it 'error if format is given as something other than pcore' do
+        expect {
+          genface.types(:format => 'json')
+        }.to raise_exception(ArgumentError, /'json' is not a supported format for type generation/)
+      end
+
+      it 'accepts --format pcore as a format' do
+        expect {
+          genface.types(:format => 'pcore')
+        }.not_to raise_error
+      end
+
+      it 'sets pcore as the default format' do
+        Puppet::Generate::Type.expects(:find_inputs).with(:pcore).returns([])
+        genface.types()
+      end
+
+      it 'finds all files to generate types for' do
+        # using expects and returning what the side effect should have been
+        # (There is no way to call the original when mocking expected parameters).
+        input1 = Puppet::Generate::Type::Input.new(m1, File.join(m1, 'lib', 'puppet', 'type', 'test1.rb'), :pcore)
+        input2 = Puppet::Generate::Type::Input.new(m1, File.join(m2, 'lib', 'puppet', 'type', 'test2.rb'), :pcore)
+        Puppet::Generate::Type::Input.expects(:new).with(m1, File.join(m1, 'lib', 'puppet', 'type', 'test1.rb'), :pcore).returns(input1)
+        Puppet::Generate::Type::Input.expects(:new).with(m2, File.join(m2, 'lib', 'puppet', 'type', 'test2.rb'), :pcore).returns(input2)
+        genface.types
+      end
+
+      it 'creates output directory <env>/.resource_types/ if it does not exist' do
+        expect(Puppet::FileSystem.exist?(outputdir)).to be(false)
+        genface.types
+        expect(Puppet::FileSystem.dir_exist?(outputdir)).to be(true)
+      end
+
+      it 'creates output with matching names for each input' do
+        expect(Puppet::FileSystem.exist?(outputdir)).to be(false)
+        genface.types
+        children = Puppet::FileSystem.children(outputdir).map {|p| Puppet::FileSystem.basename_string(p) }
+        expect(children.sort).to eql(['test1.pp', 'test2.pp'])
+      end
+
+      it 'tolerates that <env>/.resource_types/ directory exists' do
+        Puppet::FileSystem.mkpath(outputdir)
+        expect(Puppet::FileSystem.exist?(outputdir)).to be(true)
+        genface.types
+        expect(Puppet::FileSystem.dir_exist?(outputdir)).to be(true)
+      end
+
+      it 'errors if <env>/.resource_types exists and is not a directory' do
+        expect(Puppet::FileSystem.exist?(outputdir)).to be(false) # assert it is not already there
+        Puppet::FileSystem.touch(outputdir)
+        expect(Puppet::FileSystem.exist?(outputdir)).to be(true)
+        expect(Puppet::FileSystem.directory?(outputdir)).to be(false)
+        expect {
+          genface.types
+        }.to raise_error(ArgumentError, /The output directory '#{outputdir}' exists and is not a directory/)
+      end
+
+      it 'does not overwrite if files exists and are up to date' do
+        # create them (first run)
+        genface.types
+        stats_before = [Puppet::FileSystem.stat(File.join(outputdir, 'test1.pp')), Puppet::FileSystem.stat(File.join(outputdir, 'test2.pp'))]
+        # generate again
+        genface.types
+        stats_after = [Puppet::FileSystem.stat(File.join(outputdir, 'test1.pp')), Puppet::FileSystem.stat(File.join(outputdir, 'test2.pp'))]
+        expect(stats_before <=> stats_after).to be(0)
+      end
+
+      it 'overwrites if files exists that are not up to date while keeping up to date files' do
+        # create them (first run)
+        genface.types
+        stats_before = [Puppet::FileSystem.stat(File.join(outputdir, 'test1.pp')), Puppet::FileSystem.stat(File.join(outputdir, 'test2.pp'))]
+        # fake change in input test1 - sorry about the sleep (which there was a better way to change the modtime
+        sleep(1)
+        Puppet::FileSystem.touch(File.join(m1, 'lib', 'puppet', 'type', 'test1.rb'))
+        # generate again
+        genface.types
+        # assert that test1 was overwritten (later) but not test2 (same time)
+        stats_after = [Puppet::FileSystem.stat(File.join(outputdir, 'test1.pp')), Puppet::FileSystem.stat(File.join(outputdir, 'test2.pp'))]
+        expect(stats_before[1] <=> stats_after[1]).to be(0)
+        expect(stats_before[0] <=> stats_after[0]).to be(-1)
+      end
+
+      it 'overwrites all files when called with --force' do
+        # create them (first run)
+        genface.types
+        stats_before = [Puppet::FileSystem.stat(File.join(outputdir, 'test1.pp')), Puppet::FileSystem.stat(File.join(outputdir, 'test2.pp'))]
+        # generate again
+        sleep(1) # sorry, if there is no delay the stats will be the same
+        genface.types(:force => true)
+        stats_after = [Puppet::FileSystem.stat(File.join(outputdir, 'test1.pp')), Puppet::FileSystem.stat(File.join(outputdir, 'test2.pp'))]
+        expect(stats_before <=> stats_after).to be(-1)
+      end
+
+      it 'removes previously generated files from output when there is no input for it' do
+        # create them (first run)
+        genface.types
+        stat_before = Puppet::FileSystem.stat(File.join(outputdir, 'test2.pp'))
+        # remove input
+        Puppet::FileSystem.unlink(File.join(m1, 'lib', 'puppet', 'type', 'test1.rb'))
+        # generate again
+        genface.types
+        # assert that test1 was deleted but not test2 (same time)
+        expect(Puppet::FileSystem.exist?(File.join(outputdir, 'test1.pp'))).to be(false)
+        stats_after = Puppet::FileSystem.stat(File.join(outputdir, 'test2.pp'))
+        expect(stat_before <=> stats_after).to be(0)
+      end
+
+    end
+  end
+
+  def from_an_interactive_terminal
+    STDIN.stubs(:tty?).returns(true)
+  end
+
+end