puppet-retrospec 0.12.1 → 0.12.2

data/spec/fixtures/modules/stdlib/spec/lib/puppet_spec/scope.rb

@@ -1,15 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-
-module PuppetSpec::Scope
-  # Initialize a new scope suitable for testing.
-  #
-  def create_test_scope_for_node(node_name)
-    node = Puppet::Node.new(node_name)
-    compiler = Puppet::Parser::Compiler.new(node)
-    scope = Puppet::Parser::Scope.new(compiler)
-    scope.source = Puppet::Resource::Type.new(:node, node_name)
-    scope.parent = compiler.topscope
-    scope
-  end
-
-end

data/spec/fixtures/modules/stdlib/spec/lib/puppet_spec/settings.rb

@@ -1,16 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-module PuppetSpec::Settings
-
-  # It would probably be preferable to refactor defaults.rb such that the real definitions of
-  #  these settings were available as a variable, which was then accessible for use during tests.
-  #  However, I'm not doing that yet because I don't want to introduce any additional moving parts
-  #  to this already very large changeset.
-  #  Would be nice to clean this up later.  --cprice 2012-03-20
-  TEST_APP_DEFAULT_DEFINITIONS = {
-    :name         => { :default => "test", :desc => "name" },
-    :logdir       => { :type => :directory, :default => "test", :desc => "logdir" },
-    :confdir      => { :type => :directory, :default => "test", :desc => "confdir" },
-    :vardir       => { :type => :directory, :default => "test", :desc => "vardir" },
-    :rundir       => { :type => :directory, :default => "test", :desc => "rundir" },
-  }
-end

data/spec/fixtures/modules/stdlib/spec/lib/puppet_spec/verbose.rb

@@ -1,10 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-# Support code for running stuff with warnings disabled.
-module Kernel
-  def with_verbose_disabled
-    verbose, $VERBOSE = $VERBOSE, nil
-    result = yield
-    $VERBOSE = verbose
-    return result
-  end
-end

data/spec/fixtures/modules/stdlib/spec/monkey_patches/alias_should_to_must.rb

@@ -1,9 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'rspec'
-
-class Object
-  # This is necessary because the RAL has a 'should'
-  # method.
-  alias :must :should
-  alias :must_not :should_not
-end

data/spec/fixtures/modules/stdlib/spec/monkey_patches/publicize_methods.rb

@@ -1,11 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-# Some monkey-patching to allow us to test private methods.
-class Class
-    def publicize_methods(*methods)
-        saved_private_instance_methods = methods.empty? ? self.private_instance_methods : methods
-
-        self.class_eval { public(*saved_private_instance_methods) }
-        yield
-        self.class_eval { private(*saved_private_instance_methods) }
-    end
-end

data/spec/fixtures/modules/stdlib/spec/spec.opts

@@ -1,6 +0,0 @@
---format
-s
---colour
---loadby
-mtime
---backtrace

data/spec/fixtures/modules/stdlib/spec/spec_helper.rb

@@ -1,34 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-dir = File.expand_path(File.dirname(__FILE__))
-$LOAD_PATH.unshift File.join(dir, 'lib')
-
-# So everyone else doesn't have to include this base constant.
-module PuppetSpec
-  FIXTURE_DIR = File.join(dir = File.expand_path(File.dirname(__FILE__)), "fixtures") unless defined?(FIXTURE_DIR)
-end
-
-require 'puppet'
-require 'rspec-puppet'
-require 'puppetlabs_spec_helper/module_spec_helper'
-require 'puppet_spec/verbose'
-require 'puppet_spec/files'
-require 'puppet_spec/settings'
-require 'puppet_spec/fixtures'
-require 'puppet_spec/matchers'
-require 'puppet_spec/database'
-require 'monkey_patches/alias_should_to_must'
-require 'mocha/setup'
-
-
-
-RSpec.configure do |config|
-  config.before :each do
-    # Ensure that we don't accidentally cache facts and environment between
-    # test cases.  This requires each example group to explicitly load the
-    # facts being exercised with something like
-    # Facter.collection.loader.load(:ipaddress)
-    Facter::Util::Loader.any_instance.stubs(:load_all)
-    Facter.clear
-    Facter.clear_messages
-  end
-end

data/spec/fixtures/modules/stdlib/spec/spec_helper_acceptance.rb

@@ -1,50 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'beaker-rspec'
-
-UNSUPPORTED_PLATFORMS = []
-
-unless ENV['RS_PROVISION'] == 'no' or ENV['BEAKER_provision'] == 'no'
-  foss_opts = {
-    :default_action => 'gem_install',
-    :version        => (ENV['PUPPET_VERSION'] ? ENV['PUPPET_VERSION'] : '3.7.2'),
-  }
-
-  if default.is_pe?; then install_pe; else install_puppet( foss_opts ); end
-
-  hosts.each do |host|
-    if host['platform'] !~ /windows/i
-      if host.is_pe?
-        on host, 'mkdir -p /etc/puppetlabs/facter/facts.d'
-      else
-        on host, "/bin/touch #{host['puppetpath']}/hiera.yaml"
-        on host, "mkdir -p #{host['distmoduledir']}"
-        on host, 'mkdir -p /etc/facter/facts.d'
-      end
-    end
-  end
-end
-
-RSpec.configure do |c|
-  # Project root
-  proj_root = File.expand_path(File.join(File.dirname(__FILE__), '..'))
-
-  # Readable test descriptions
-  c.formatter = :documentation
-
-  # Configure all nodes in nodeset
-  c.before :suite do
-    if ENV['FUTURE_PARSER'] == 'true'
-      default[:default_apply_opts] ||= {}
-      default[:default_apply_opts].merge!({:parser => 'future'})
-    end
-
-    copy_root_module_to(default, :source => proj_root, :module_name => 'stdlib')
-  end
-end
-
-def is_future_parser_enabled?
-  if default[:default_apply_opts]
-    return default[:default_apply_opts][:parser] == 'future'
-  end
-  return false
-end

data/spec/fixtures/modules/stdlib/spec/unit/facter/facter_dot_d_spec.rb

@@ -1,32 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-require 'facter/facter_dot_d'
-
-describe Facter::Util::DotD do
-
-  context 'returns a simple fact' do
-    before :each do
-      Facter.stubs(:version).returns('1.6.1')
-      subject.stubs(:entries).returns(['/etc/facter/facts.d/fake_fact.txt'])
-      File.stubs(:readlines).with('/etc/facter/facts.d/fake_fact.txt').returns(['fake_fact=fake fact'])
-      subject.create
-    end
-
-    it 'should return successfully' do
-      expect(Facter.fact(:fake_fact).value).to eq('fake fact')
-    end
-  end
-
-  context 'returns a fact with equals signs' do
-    before :each do
-      Facter.stubs(:version).returns('1.6.1')
-      subject.stubs(:entries).returns(['/etc/facter/facts.d/foo.txt'])
-      File.stubs(:readlines).with('/etc/facter/facts.d/foo.txt').returns(['foo=1+1=2'])
-      subject.create
-    end
-
-    it 'should return successfully' do
-      expect(Facter.fact(:foo).value).to eq('1+1=2')
-    end
-  end
-end

data/spec/fixtures/modules/stdlib/spec/unit/facter/pe_version_spec.rb

@@ -1,76 +0,0 @@
-#!/usr/bin/env rspec
-
-require 'spec_helper'
-
-describe "PE Version specs" do
-  before :each do
-    # Explicitly load the pe_version.rb file which contains generated facts
-    # that cannot be automatically loaded.  Puppet 2.x implements
-    # Facter.collection.load while Facter 1.x markes Facter.collection.load as
-    # a private method.
-    if Facter.collection.respond_to? :load
-      Facter.collection.load(:pe_version)
-    else
-      Facter.collection.loader.load(:pe_version)
-    end
-  end
-
-  context "If PE is installed" do
-    %w{ 2.6.1 2.10.300 }.each do |version|
-      puppetversion = "2.7.19 (Puppet Enterprise #{version})"
-      context "puppetversion => #{puppetversion}" do
-        before :each do
-          Facter.fact(:puppetversion).stubs(:value).returns(puppetversion)
-        end
-
-        (major,minor,patch) = version.split(".")
-
-        it "Should return true" do
-          expect(Facter.fact(:is_pe).value).to eq(true)
-        end
-
-        it "Should have a version of #{version}" do
-          expect(Facter.fact(:pe_version).value).to eq(version)
-        end
-
-        it "Should have a major version of #{major}" do
-          expect(Facter.fact(:pe_major_version).value).to eq(major)
-        end
-
-        it "Should have a minor version of #{minor}" do
-          expect(Facter.fact(:pe_minor_version).value).to eq(minor)
-        end
-
-        it "Should have a patch version of #{patch}" do
-          expect(Facter.fact(:pe_patch_version).value).to eq(patch)
-        end
-      end
-    end
-  end
-
-  context "When PE is not installed" do
-    before :each do
-      Facter.fact(:puppetversion).stubs(:value).returns("2.7.19")
-    end
-
-    it "is_pe is false" do
-      expect(Facter.fact(:is_pe).value).to eq(false)
-    end
-
-    it "pe_version is nil" do
-      expect(Facter.fact(:pe_version).value).to be_nil
-    end
-
-    it "pe_major_version is nil" do
-      expect(Facter.fact(:pe_major_version).value).to be_nil
-    end
-
-    it "pe_minor_version is nil" do
-      expect(Facter.fact(:pe_minor_version).value).to be_nil
-    end
-
-    it "Should have a patch version" do
-      expect(Facter.fact(:pe_patch_version).value).to be_nil
-    end
-  end
-end

data/spec/fixtures/modules/stdlib/spec/unit/facter/root_home_spec.rb

@@ -1,52 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-require 'facter/root_home'
-
-describe Facter::Util::RootHome do
-  context "solaris" do
-    let(:root_ent) { "root:x:0:0:Super-User:/:/sbin/sh" }
-    let(:expected_root_home) { "/" }
-
-    it "should return /" do
-      Facter::Util::Resolution.expects(:exec).with("getent passwd root").returns(root_ent)
-      expect(Facter::Util::RootHome.get_root_home).to eq(expected_root_home)
-    end
-  end
-  context "linux" do
-    let(:root_ent) { "root:x:0:0:root:/root:/bin/bash" }
-    let(:expected_root_home) { "/root" }
-
-    it "should return /root" do
-      Facter::Util::Resolution.expects(:exec).with("getent passwd root").returns(root_ent)
-      expect(Facter::Util::RootHome.get_root_home).to eq(expected_root_home)
-    end
-  end
-  context "windows" do
-    before :each do
-      Facter::Util::Resolution.expects(:exec).with("getent passwd root").returns(nil)
-    end
-    it "should be nil on windows" do
-      expect(Facter::Util::RootHome.get_root_home).to be_nil
-    end
-  end
-end
-
-describe 'root_home', :type => :fact do
-  before { Facter.clear }
-  after { Facter.clear }
-
-  context "macosx" do
-    before do
-      Facter.fact(:kernel).stubs(:value).returns("Darwin")
-      Facter.fact(:osfamily).stubs(:value).returns("Darwin")
-    end
-    let(:expected_root_home) { "/var/root" }
-    sample_dscacheutil = File.read(fixtures('dscacheutil','root'))
-
-    it "should return /var/root" do
-      Facter::Util::Resolution.stubs(:exec).with("dscacheutil -q user -a name root").returns(sample_dscacheutil)
-      expect(Facter.fact(:root_home).value).to eq(expected_root_home)
-    end
-  end
-
-end

data/spec/fixtures/modules/stdlib/spec/unit/facter/util/puppet_settings_spec.rb

@@ -1,36 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-require 'facter/util/puppet_settings'
-
-describe Facter::Util::PuppetSettings do
-
-  describe "#with_puppet" do
-    context "Without Puppet loaded" do
-      before(:each) do
-        Module.expects(:const_get).with("Puppet").raises(NameError)
-      end
-
-      it 'should be nil' do
-        expect(subject.with_puppet { Puppet[:vardir] }).to be_nil
-      end
-      it 'should not yield to the block' do
-        Puppet.expects(:[]).never
-        expect(subject.with_puppet { Puppet[:vardir] }).to be_nil
-      end
-    end
-    context "With Puppet loaded" do
-      module Puppet; end
-      let(:vardir) { "/var/lib/puppet" }
-
-      before :each do
-        Puppet.expects(:[]).with(:vardir).returns vardir
-      end
-      it 'should yield to the block' do
-        subject.with_puppet { Puppet[:vardir] }
-      end
-      it 'should return the nodes vardir' do
-        expect(subject.with_puppet { Puppet[:vardir] }).to eq vardir
-      end
-    end
-  end
-end

data/spec/fixtures/modules/stdlib/spec/unit/puppet/functions/type_of_spec.rb

@@ -1,33 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-
-require 'spec_helper'
-
-if ENV["FUTURE_PARSER"] == 'yes' or Puppet.version >= "4"
-  require 'puppet/pops'
-  require 'puppet/loaders'
-
-  describe 'the type_of function' do
-    before(:all) do
-      loaders = Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, [File.join(fixtures, "modules")]))
-      Puppet.push_context({:loaders => loaders}, "test-examples")
-    end
-
-    after(:all) do
-      Puppet::Pops::Loaders.clear
-      Puppet::pop_context()
-    end
-
-    let(:func) do
-      # Load the function from the environment modulepath's modules (ie, fixtures)
-      Puppet.lookup(:loaders).private_environment_loader.load(:function, 'type_of')
-    end
-
-    it 'gives the type of a string' do
-      expect(func.call({}, 'hello world')).to be_kind_of(Puppet::Pops::Types::PStringType)
-    end
-
-    it 'gives the type of an integer' do
-      expect(func.call({}, 5)).to be_kind_of(Puppet::Pops::Types::PIntegerType)
-    end
-  end
-end

data/spec/fixtures/modules/stdlib/spec/unit/puppet/parser/functions/basename_spec.rb

@@ -1,46 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe "the basename function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    Puppet::Parser::Functions.function("basename").should == "function_basename"
-  end
-
-  it "should raise a ParseError if there is less than 1 argument" do
-    lambda { scope.function_basename([]) }.should( raise_error(Puppet::ParseError))
-  end
-
-  it "should raise a ParseError if there are more than 2 arguments" do
-    lambda { scope.function_basename(['a', 'b', 'c']) }.should( raise_error(Puppet::ParseError))
-  end
-
-  it "should return basename for an absolute path" do
-    result = scope.function_basename(['/path/to/a/file.ext'])
-    result.should(eq('file.ext'))
-  end
-
-  it "should return basename for a relative path" do
-    result = scope.function_basename(['path/to/a/file.ext'])
-    result.should(eq('file.ext'))
-  end
-
-  it "should strip extention when extension specified (absolute path)" do
-    result = scope.function_basename(['/path/to/a/file.ext', '.ext'])
-    result.should(eq('file'))
-  end
-
-  it "should strip extention when extension specified (relative path)" do
-    result = scope.function_basename(['path/to/a/file.ext', '.ext'])
-    result.should(eq('file'))
-  end
-
-  it "should complain about non-string first argument" do
-    lambda { scope.function_basename([[]]) }.should( raise_error(Puppet::ParseError))
-  end
-
-  it "should complain about non-string second argument" do
-    lambda { scope.function_basename(['/path/to/a/file.ext', []]) }.should( raise_error(Puppet::ParseError))
-  end
-end