puppet 6.0.5-x64-mingw32 → 8.8.1-x64-mingw32

data/spec/unit/face/epp_face_spec.rb

@@ -1,386 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/files'
-
-require 'puppet/face'
-
-describe Puppet::Face[:epp, :current] do
-  include PuppetSpec::Files
-
-  let(:eppface) { Puppet::Face[:epp, :current] }
-
-  context "validate" do
-    context "from an interactive terminal" do
-      before :each do
-        from_an_interactive_terminal
-      end
-
-      it "validates the template referenced as an absolute file" do
-        template_name = 'template1.epp'
-        dir = dir_containing('templates', { template_name => "<%= |$a $b |%>" })
-        template = File.join(dir, template_name)
-        expect { eppface.validate(template) }.to raise_exception(Puppet::Error, /Errors while validating epp/)
-      end
-
-      it "runs error free when there are no validation errors from an absolute file" do
-        template_name = 'template1.epp'
-        dir = dir_containing('templates', { template_name => "just text" })
-        template = File.join(dir, template_name)
-        expect { eppface.validate(template) }.to_not raise_exception()
-      end
-
-      it "reports missing files" do
-        expect do
-          eppface.validate("missing.epp")
-        end.to raise_error(Puppet::Error, /One or more file\(s\) specified did not exist.*missing\.epp/m)
-      end
-
-      context "in an environment with templates" do
-        let(:dir) do
-          dir_containing('environments', { 'production' => { 'modules' => {
-            'm1' => { 'templates' => {
-              'greetings.epp' => "<% |$subject = world| %>hello <%= $subject -%>",
-              'broken.epp'    => "<% | $a $b | %> I am broken",
-              'broken2.epp'   => "<% | $a $b | %> I am broken too"
-            }},
-            'm2' => { 'templates' => {
-              'goodbye.epp'   => "<% | $subject = world |%>goodbye <%= $subject -%>",
-              'broken3.epp'   => "<% | $a $b | %> I am broken too"
-            }}
-          }}})
-
-        end
-
-        around(:each) do |example|
-          Puppet.settings.initialize_global_settings
-          loader = Puppet::Environments::Directories.new(dir, [])
-          Puppet.override(:environments => loader) do
-            example.run
-          end
-        end
-
-        it "parses supplied template files in different modules of a directory environment" do
-          expect(eppface.validate('m1/greetings.epp')).to be_nil
-          expect(eppface.validate('m2/goodbye.epp')).to be_nil
-        end
-
-        it "finds errors in supplied template file in the context of a directory environment" do
-          expect { eppface.validate('m1/broken.epp') }.to raise_exception(Puppet::Error, /Errors while validating epp/)
-          expect(@logs.join).to match(/Syntax error at 'b'/)
-        end
-
-        it "stops on first error by default" do
-          expect { eppface.validate('m1/broken.epp', 'm1/broken2.epp') }.to raise_exception(Puppet::Error, /Errors while validating epp/)
-          expect(@logs.join).to match(/Syntax error at 'b'.*broken\.epp/)
-          expect(@logs.join).to_not match(/Syntax error at 'b'.*broken2\.epp/)
-        end
-
-        it "continues after error when --continue_on_error is given" do
-          expect { eppface.validate('m1/broken.epp', 'm1/broken2.epp', :continue_on_error => true) }.to raise_exception(Puppet::Error, /Errors while validating epp/)
-          expect(@logs.join).to match(/Syntax error at 'b'.*broken\.epp/)
-          expect(@logs.join).to match(/Syntax error at 'b'.*broken2\.epp/)
-        end
-
-        it "validates all templates in the environment" do
-          pending "NOT IMPLEMENTED YET"
-          expect { eppface.validate(:continue_on_error => true) }.to raise_exception(Puppet::Error, /Errors while validating epp/)
-          expect(@logs.join).to match(/Syntax error at 'b'.*broken\.epp/)
-          expect(@logs.join).to match(/Syntax error at 'b'.*broken2\.epp/)
-          expect(@logs.join).to match(/Syntax error at 'b'.*broken3\.epp/)
-        end
-      end
-    end
-
-    it "validates the contents of STDIN when no files given and STDIN is not a tty" do
-      from_a_piped_input_of("<% | $a $oh_no | %> I am broken")
-      expect { eppface.validate() }.to raise_exception(Puppet::Error, /Errors while validating epp/)
-      expect(@logs.join).to match(/Syntax error at 'oh_no'/)
-    end
-
-    it "validates error free contents of STDIN when no files given and STDIN is not a tty" do
-      from_a_piped_input_of("look, just text")
-      expect(eppface.validate()).to be_nil
-    end
-  end
-
-
-  context "dump" do
-    it "prints the AST of a template given with the -e option" do
-      expect(eppface.dump({ :e => 'hello world' })).to eq("(lambda (epp (block\n  (render-s 'hello world')\n)))\n")
-    end
-
-    it "prints the AST of a template given as an absolute file" do
-      template_name = 'template1.epp'
-      dir = dir_containing('templates', { template_name => "hello world" })
-      template = File.join(dir, template_name)
-      expect(eppface.dump(template)).to eq("(lambda (epp (block\n  (render-s 'hello world')\n)))\n")
-    end
-
-    it "adds a header between dumps by default" do
-      template_name1 = 'template1.epp'
-      template_name2 = 'template2.epp'
-      dir = dir_containing('templates', { template_name1 => "hello world", template_name2 => "hello again"} )
-      template1 = File.join(dir, template_name1)
-      template2 = File.join(dir, template_name2)
-
-      # Do not move the text block, the left margin and indentation matters
-      expect(eppface.dump(template1, template2)).to eq( <<-"EOT" )
---- #{template1}
-(lambda (epp (block
-  (render-s 'hello world')
-)))
---- #{template2}
-(lambda (epp (block
-  (render-s 'hello again')
-)))
-      EOT
-    end
-
-    it "dumps non validated content when given --no-validate" do
-      template_name = 'template1.epp'
-      dir = dir_containing('templates', { template_name => "<% 1 2 3 %>" })
-      template = File.join(dir, template_name)
-      expect(eppface.dump(template, :validate => false)).to eq("(lambda (epp (block\n  1\n  2\n  3\n)))\n")
-    end
-
-    it "validated content when given --validate" do
-      template_name = 'template1.epp'
-      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.*\(file: .*\/template1\.epp, line: 1, column: 4\)/)
-    end
-
-    it "validated content by default" do
-      template_name = 'template1.epp'
-      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.*\(file: .*\/template1\.epp, line: 1, column: 4\)/)
-    end
-
-    it "informs the user of files that don't exist" do
-      expected_message = /One or more file\(s\) specified did not exist:\n\s*does_not_exist_here\.epp/m
-      expect { eppface.dump('does_not_exist_here.epp') }.to raise_exception(Puppet::Error, expected_message)
-    end
-
-    it "dumps the AST of STDIN when no files given and STDIN is not a tty" do
-      from_a_piped_input_of("hello world")
-      expect(eppface.dump()).to eq("(lambda (epp (block\n  (render-s 'hello world')\n)))\n")
-    end
-
-    it "logs an error if the input cannot be parsed even if validation is off" do
-      from_a_piped_input_of("<% |$a  $b| %> oh no")
-      expect(eppface.dump(:validate => false)).to eq("")
-      expect(@logs[0].message).to match(/Syntax error at 'b'/)
-      expect(@logs[0].level).to eq(:err)
-    end
-
-    context "using 'pn' format" do
-      it "prints the AST of the given expression in PN format" do
-        expect(eppface.dump({ :format => 'pn', :e => 'hello world' })).to eq(
-          '(lambda {:body [(epp (render-s "hello world"))]})')
-      end
-
-      it "pretty prints the AST of the given expression in PN format when --pretty is given" do
-        expect(eppface.dump({ :pretty => true, :format => 'pn', :e => 'hello world' })).to eq(<<-RESULT.unindent[0..-2])
-        (lambda
-          {
-            :body [
-              (epp
-                (render-s
-                  "hello world"))]})
-        RESULT
-      end
-    end
-
-    context "using 'json' format" do
-      it "prints the AST of the given expression in JSON based on the PN format" do
-        expect(eppface.dump({ :format => 'json', :e => 'hello world' })).to eq(
-          '{"^":["lambda",{"#":["body",[{"^":["epp",{"^":["render-s","hello world"]}]}]]}]}')
-      end
-
-      it "pretty prints the AST of the given expression in JSON based on the PN format when --pretty is given" do
-        expect(eppface.dump({ :pretty => true, :format => 'json', :e => 'hello world' })).to eq(<<-RESULT.unindent[0..-2])
-        {
-          "^": [
-            "lambda",
-            {
-              "#": [
-                "body",
-                [
-                  {
-                    "^": [
-                      "epp",
-                      {
-                        "^": [
-                          "render-s",
-                          "hello world"
-                        ]
-                      }
-                    ]
-                  }
-                ]
-              ]
-            }
-          ]
-        }
-        RESULT
-      end
-    end
-  end
-
-  context "render" do
-    it "renders input from stdin" do
-      from_a_piped_input_of("hello world")
-      expect(eppface.render()).to eq("hello world")
-    end
-
-    it "renders input from command line" do
-      expect(eppface.render(:e => 'hello world')).to eq("hello world")
-    end
-
-    it "renders input from an absolute file" do
-      template_name = 'template1.epp'
-      dir = dir_containing('templates', { template_name => "absolute world" })
-      template = File.join(dir, template_name)
-      expect(eppface.render(template)).to eq("absolute world")
-    end
-
-    it "renders expressions" do
-      expect(eppface.render(:e => '<% $x = "mr X"%>hello <%= $x %>')).to eq("hello mr X")
-    end
-
-    it "adds values given in a puppet hash given on command line with --values" do
-      expect(eppface.render(:e => 'hello <%= $x %>', :values => '{x => "mr X"}')).to eq("hello mr X")
-    end
-
-    it "adds fully qualified values given in a puppet hash given on command line with --values" do
-      expect(eppface.render(:e => 'hello <%= $mr::x %>', :values => '{mr::x => "mr X"}')).to eq("hello mr X")
-    end
-
-    it "adds fully qualified values with leading :: given in a puppet hash given on command line with --values" do
-      expect(eppface.render(:e => 'hello <%= $::mr %>', :values => '{"::mr" => "mr X"}')).to eq("hello mr X")
-    end
-
-    it "adds values given in a puppet hash produced by a .pp file given with --values_file" do
-      file_name = 'values.pp'
-      dir = dir_containing('values', { file_name => '{x => "mr X"}' })
-      values_file = File.join(dir, file_name)
-      expect(eppface.render(:e => 'hello <%= $x %>', :values_file => values_file)).to eq("hello mr X")
-    end
-
-    it "adds values given in a yaml hash given with --values_file" do
-      file_name = 'values.yaml'
-      dir = dir_containing('values', { file_name => "---\n x: 'mr X'" })
-      values_file = File.join(dir, file_name)
-      expect(eppface.render(:e => 'hello <%= $x %>', :values_file => values_file)).to eq("hello mr X")
-    end
-
-    it "merges values from values file and command line with command line having higher precedence" do
-      file_name = 'values.yaml'
-      dir = dir_containing('values', { file_name => "---\n x: 'mr X'\n word: 'goodbye'" })
-      values_file = File.join(dir, file_name)
-      expect(eppface.render(:e => '<%= $word %> <%= $x %>',
-        :values_file => values_file,
-        :values => '{x => "mr Y"}')
-        ).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 'initializes the 4x loader' do
-      expect(eppface.render({ :e => <<-EPP.unindent })).to eql("\nString\n\nInteger\n\nBoolean\n")
-        <% $data = [type('a',generalized), type(2,generalized), type(true,generalized)] -%>
-        <% $data.each |$value| { %>
-        <%= $value %>
-        <% } -%>
-      EPP
-    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' => {
-          'm1' => { 'templates' => {
-            'greetings.epp' => "<% |$subject = world| %>hello <%= $subject -%>",
-            'factshash.epp' => "fact = <%= $facts[the_fact] -%>",
-            'fact.epp'      => "fact = <%= $the_fact -%>",
-          }},
-          'm2' => { 'templates' => {
-            'goodbye.epp'   => "<% | $subject = world |%>goodbye <%= $subject -%>",
-          }}
-        },
-          'extra' => {
-            'facts.yaml' => "---\n the_fact: 42"
-          }
-        }})
-
-      end
-
-      around(:each) do |example|
-        Puppet.settings.initialize_global_settings
-        loader = Puppet::Environments::Directories.new(dir, [])
-        Puppet.override(:environments => loader) do
-          example.run
-        end
-      end
-
-      it "renders supplied template files in different modules of a directory environment" do
-        expect(eppface.render('m1/greetings.epp')).to eq("hello world")
-        expect(eppface.render('m2/goodbye.epp')).to eq("goodbye world")
-      end
-
-      it "makes facts available in $facts" do
-        facts_file = File.join(dir, 'production', 'extra', 'facts.yaml')
-        expect(eppface.render('m1/factshash.epp', :facts => facts_file)).to eq("fact = 42")
-      end
-
-      it "makes facts available individually" do
-        facts_file = File.join(dir, 'production', 'extra', 'facts.yaml')
-        expect(eppface.render('m1/fact.epp', :facts => facts_file)).to eq("fact = 42")
-      end
-
-      it "renders multiple files separated by headers by default" do
-        # chomp the last newline, it is put there by heredoc
-        expect(eppface.render('m1/greetings.epp', 'm2/goodbye.epp')).to eq(<<-EOT.chomp)
---- m1/greetings.epp
-hello world
---- m2/goodbye.epp
-goodbye world
-        EOT
-      end
-
-      it "outputs multiple files verbatim when --no-headers is given" do
-        expect(eppface.render('m1/greetings.epp', 'm2/goodbye.epp', :header => false)).to eq("hello worldgoodbye world")
-      end
-    end
-  end
-
-  def from_an_interactive_terminal
-    STDIN.stubs(:tty?).returns(true)
-  end
-
-  def from_a_piped_input_of(contents)
-    STDIN.stubs(:tty?).returns(false)
-    STDIN.stubs(:read).returns(contents)
-  end
-end

data/spec/unit/face/facts_spec.rb

@@ -1,62 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-require 'puppet/face'
-require 'puppet/indirector/facts/facter'
-require 'puppet/indirector/facts/rest'
-
-describe Puppet::Face[:facts, '0.0.1'] do
-  describe "#find" do
-    it { is_expected.to be_action :find }
-  end
-
-  describe '#upload' do
-    let(:model) { Puppet::Node::Facts }
-    let(:test_data) { model.new('puppet.node.test', {test_fact: 'test value'}) }
-    let(:facter_terminus) { model.indirection.terminus(:facter) }
-    let(:rest_terminus) { model.indirection.terminus(:rest) }
-
-    before(:each) do
-      Puppet.settings.parse_config(<<-CONF)
-[main]
-server=puppet.server.invalid
-certname=puppet.node.invalid
-[agent]
-server=puppet.server.test
-node_name_value=puppet.node.test
-CONF
-
-      # Faces start in :user run mode
-      Puppet.settings.preferred_run_mode = :user
-
-      facter_terminus.stubs(:find).with(instance_of(Puppet::Indirector::Request)).returns(test_data)
-      rest_terminus.stubs(:save).with(instance_of(Puppet::Indirector::Request)).returns(nil)
-    end
-
-    it { is_expected.to be_action :upload }
-
-    it "finds facts from terminus_class :facter" do
-      facter_terminus.expects(:find).with(instance_of(Puppet::Indirector::Request)).returns(test_data)
-
-      subject.upload
-    end
-
-    it "saves facts to terminus_class :rest" do
-      rest_terminus.expects(:save).with(instance_of(Puppet::Indirector::Request)).returns(nil)
-
-      subject.upload
-    end
-
-    it "uses settings from the agent section of puppet.conf" do
-      facter_terminus.expects(:find).with(responds_with(:key, 'puppet.node.test')).returns(test_data)
-
-      subject.upload
-    end
-
-    it "logs the name of the server that received the upload" do
-      subject.upload
-
-      expect(@logs).to be_any {|log| log.level == :notice &&
-                               log.message =~ /Uploading facts for '.*' to: 'puppet\.server\.test'/}
-    end
-  end
-end

data/spec/unit/face/generate_spec.rb

@@ -1,230 +0,0 @@
-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