puppet 2.6.18 → 2.7.1

data/spec/unit/interface/documentation_spec.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+require 'puppet/interface'
+require 'puppet/interface/option'
+require 'puppet/interface/documentation'
+
+class Puppet::Interface::TinyDocs::Test
+  include Puppet::Interface::TinyDocs
+  attr_accessor :name, :options
+  def initialize
+    self.name    = "tinydoc-test"
+    self.options = []
+  end
+
+  def get_option(name)
+    Puppet::Interface::Option.new(nil, "--#{name}")
+  end
+end
+
+describe Puppet::Interface::TinyDocs do
+  subject { Puppet::Interface::TinyDocs::Test.new }
+
+  context "#build_synopsis" do
+    before :each do
+      subject.options = [:foo, :bar]
+    end
+
+    it { should respond_to :build_synopsis }
+
+    it "should put a space between options (#7828)" do
+      subject.build_synopsis('baz').should =~ /#{Regexp.quote('[--foo] [--bar]')}/
+    end
+  end
+end

data/spec/unit/interface/face_collection_spec.rb

@@ -0,0 +1,180 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+
+require 'tmpdir'
+require 'puppet/interface/face_collection'
+
+describe Puppet::Interface::FaceCollection do
+  # To avoid cross-pollution we have to save and restore both the hash
+  # containing all the interface data, and the array used by require.  Restoring
+  # both means that we don't leak side-effects across the code. --daniel 2011-04-06
+  #
+  # Worse luck, we *also* need to flush $" of anything defining a face,
+  # because otherwise we can cross-pollute from other test files and end up
+  # with no faces loaded, but the require value set true. --daniel 2011-04-10
+  before :each do
+    @original_faces    = subject.instance_variable_get("@faces").dup
+    @original_required = $".dup
+    $".delete_if do |path| path =~ %r{/face/.*\.rb$} end
+    subject.instance_variable_get(:@faces).clear
+    subject.instance_variable_set(:@loaded, false)
+  end
+
+  after :each do
+    subject.instance_variable_set(:@faces, @original_faces)
+    @original_required.each {|f| $".push f unless $".include? f }
+  end
+
+  describe "::prefix_match?" do
+    #   want     have
+    { ['1.0.0', '1.0.0'] => true,
+      ['1.0',   '1.0.0'] => true,
+      ['1',     '1.0.0'] => true,
+      ['1.0.0', '1.1.0'] => false,
+      ['1.0',   '1.1.0'] => false,
+      ['1',     '1.1.0'] => true,
+      ['1.0.1', '1.0.0'] => false,
+    }.each do |data, result|
+      it "should return #{result.inspect} for prefix_match?(#{data.join(', ')})" do
+        subject.prefix_match?(*data).should == result
+      end
+    end
+  end
+
+  describe "::validate_version" do
+    { '10.10.10'     => true,
+      '1.2.3.4'      => false,
+      '10.10.10beta' => true,
+      '10.10'        => false,
+      '123'          => false,
+      'v1.1.1'       => false,
+    }.each do |input, result|
+      it "should#{result ? '' : ' not'} permit #{input.inspect}" do
+        subject.validate_version(input).should(result ? be_true : be_false)
+      end
+    end
+  end
+
+  describe "::[]" do
+    before :each do
+      subject.instance_variable_get("@faces")[:foo]['0.0.1'] = 10
+    end
+
+    it "should return the face with the given name" do
+      subject["foo", '0.0.1'].should == 10
+    end
+
+    it "should attempt to load the face if it isn't found" do
+      subject.expects(:require).with('puppet/face/bar')
+      subject["bar", '0.0.1']
+    end
+
+    it "should attempt to load the default face for the specified version :current" do
+      subject.expects(:require).with('puppet/face/fozzie')
+      subject['fozzie', :current]
+    end
+
+    it "should return true if the face specified is registered" do
+      subject.instance_variable_get("@faces")[:foo]['0.0.1'] = 10
+      subject["foo", '0.0.1'].should == 10
+    end
+
+    it "should attempt to require the face if it is not registered" do
+      subject.expects(:require).with do |file|
+        subject.instance_variable_get("@faces")[:bar]['0.0.1'] = true
+        file == 'puppet/face/bar'
+      end
+      subject["bar", '0.0.1'].should be_true
+    end
+
+    it "should return false if the face is not registered" do
+      subject.stubs(:require).returns(true)
+      subject["bar", '0.0.1'].should be_false
+    end
+
+    it "should return false if the face file itself is missing" do
+      subject.stubs(:require).
+        raises(LoadError, 'no such file to load -- puppet/face/bar')
+      subject["bar", '0.0.1'].should be_false
+    end
+
+    it "should register the version loaded by `:current` as `:current`" do
+      subject.expects(:require).with do |file|
+        subject.instance_variable_get("@faces")[:huzzah]['2.0.1'] = :huzzah_face
+        file == 'puppet/face/huzzah'
+      end
+      subject["huzzah", :current]
+      subject.instance_variable_get("@faces")[:huzzah][:current].should == :huzzah_face
+    end
+
+    context "with something on disk" do
+      it "should register the version loaded from `puppet/face/{name}` as `:current`" do
+        subject["huzzah", '2.0.1'].should be
+        subject["huzzah", :current].should be
+        Puppet::Face[:huzzah, '2.0.1'].should == Puppet::Face[:huzzah, :current]
+      end
+
+      it "should index :current when the code was pre-required" do
+        subject.instance_variable_get("@faces")[:huzzah].should_not be_key :current
+        require 'puppet/face/huzzah'
+        subject[:huzzah, :current].should be_true
+      end
+    end
+
+    it "should not cause an invalid face to be enumerated later" do
+      subject[:there_is_no_face, :current].should be_false
+      subject.faces.should_not include :there_is_no_face
+    end
+  end
+
+  describe "::register" do
+    it "should store the face by name" do
+      face = Puppet::Face.new(:my_face, '0.0.1')
+      subject.register(face)
+      subject.instance_variable_get("@faces").should == {:my_face => {'0.0.1' => face}}
+    end
+  end
+
+  describe "::underscorize" do
+    faulty = [1, "#foo", "$bar", "sturm und drang", :"sturm und drang"]
+    valid  = {
+      "Foo"      => :foo,
+      :Foo       => :foo,
+      "foo_bar"  => :foo_bar,
+      :foo_bar   => :foo_bar,
+      "foo-bar"  => :foo_bar,
+      :"foo-bar" => :foo_bar,
+    }
+
+    valid.each do |input, expect|
+      it "should map #{input.inspect} to #{expect.inspect}" do
+        result = subject.underscorize(input)
+        result.should == expect
+      end
+    end
+
+    faulty.each do |input|
+      it "should fail when presented with #{input.inspect} (#{input.class})" do
+        expect { subject.underscorize(input) }.
+          should raise_error ArgumentError, /not a valid face name/
+      end
+    end
+  end
+
+  context "faulty faces" do
+    before :each do
+      $:.unshift "#{PuppetSpec::FIXTURE_DIR}/faulty_face"
+    end
+
+    after :each do
+      $:.delete_if {|x| x == "#{PuppetSpec::FIXTURE_DIR}/faulty_face"}
+    end
+
+    it "should not die if a face has a syntax error" do
+      subject.faces.should be_include :help
+      subject.faces.should_not be_include :syntax
+      @logs.should_not be_empty
+      @logs.first.message.should =~ /syntax error/
+    end
+  end
+end

data/spec/unit/interface/option_builder_spec.rb

@@ -0,0 +1,77 @@
+require 'puppet/interface/option_builder'
+
+describe Puppet::Interface::OptionBuilder do
+  let :face do Puppet::Interface.new(:option_builder_testing, '0.0.1') end
+
+  it "should be able to construct an option without a block" do
+    Puppet::Interface::OptionBuilder.build(face, "--foo").
+      should be_an_instance_of Puppet::Interface::Option
+  end
+
+  it "should work with an empty block" do
+    option = Puppet::Interface::OptionBuilder.build(face, "--foo") do
+      # This block deliberately left blank.
+    end
+
+    option.should be_an_instance_of Puppet::Interface::Option
+  end
+
+  [:description, :summary].each do |doc|
+    it "should support #{doc} declarations" do
+      text = "this is the #{doc}"
+      option = Puppet::Interface::OptionBuilder.build(face, "--foo") do
+        self.send doc, text
+      end
+      option.should be_an_instance_of Puppet::Interface::Option
+      option.send(doc).should == text
+    end
+  end
+
+  context "before_action hook" do
+    it "should support a before_action hook" do
+      option = Puppet::Interface::OptionBuilder.build(face, "--foo") do
+        before_action do |a,b,c| :whatever end
+      end
+      option.before_action.should be_an_instance_of UnboundMethod
+    end
+
+    it "should fail if the hook block takes too few arguments" do
+      expect do
+        Puppet::Interface::OptionBuilder.build(face, "--foo") do
+          before_action do |one, two| true end
+        end
+      end.to raise_error ArgumentError, /takes three arguments/
+    end
+
+    it "should fail if the hook block takes too many arguments" do
+      expect do
+        Puppet::Interface::OptionBuilder.build(face, "--foo") do
+          before_action do |one, two, three, four| true end
+        end
+      end.to raise_error ArgumentError, /takes three arguments/
+    end
+
+    it "should fail if the hook block takes a variable number of arguments" do
+      expect do
+        Puppet::Interface::OptionBuilder.build(face, "--foo") do
+          before_action do |*blah| true end
+        end
+      end.to raise_error ArgumentError, /takes three arguments/
+    end
+
+    it "should support simple required declarations" do
+      opt = Puppet::Interface::OptionBuilder.build(face, "--foo") do
+        required
+      end
+      opt.should be_required
+    end
+
+    it "should support arguments to the required property" do
+      opt = Puppet::Interface::OptionBuilder.build(face, "--foo") do
+        required(false)
+      end
+      opt.should_not be_required
+    end
+
+  end
+end

data/spec/unit/interface/option_spec.rb

@@ -0,0 +1,100 @@
+require 'puppet/interface'
+require 'puppet/interface/option'
+
+describe Puppet::Interface::Option do
+  let :face do Puppet::Interface.new(:option_testing, '0.0.1') end
+
+  describe "#optparse_to_name" do
+    ["", "=BAR", " BAR", "=bar", " bar"].each do |postfix|
+      { "--foo" => :foo, "-f" => :f }.each do |base, expect|
+        input = base + postfix
+        it "should map #{input.inspect} to #{expect.inspect}" do
+          option = Puppet::Interface::Option.new(face, input)
+          option.name.should == expect
+        end
+      end
+    end
+
+    [:foo, 12, nil, {}, []].each do |input|
+      it "should fail sensible when given #{input.inspect}" do
+        expect { Puppet::Interface::Option.new(face, input) }.
+          should raise_error ArgumentError, /is not valid for an option argument/
+      end
+    end
+
+    ["-foo", "-foo=BAR", "-foo BAR"].each do |input|
+      it "should fail with a single dash for long option #{input.inspect}" do
+        expect { Puppet::Interface::Option.new(face, input) }.
+          should raise_error ArgumentError, /long options need two dashes \(--\)/
+      end
+    end
+  end
+
+  it "requires a face when created" do
+    expect { Puppet::Interface::Option.new }.
+      should raise_error ArgumentError, /wrong number of arguments/
+  end
+
+  it "also requires some declaration arguments when created" do
+    expect { Puppet::Interface::Option.new(face) }.
+      should raise_error ArgumentError, /No option declarations found/
+  end
+
+  it "should infer the name from an optparse string" do
+    option = Puppet::Interface::Option.new(face, "--foo")
+    option.name.should == :foo
+  end
+
+  it "should infer the name when multiple optparse string are given" do
+    option = Puppet::Interface::Option.new(face, "--foo", "-f")
+    option.name.should == :foo
+  end
+
+  it "should prefer the first long option name over a short option name" do
+    option = Puppet::Interface::Option.new(face, "-f", "--foo")
+    option.name.should == :foo
+  end
+
+  it "should create an instance when given a face and name" do
+    Puppet::Interface::Option.new(face, "--foo").
+      should be_instance_of Puppet::Interface::Option
+  end
+
+  describe "#to_s" do
+    it "should transform a symbol into a string" do
+      option = Puppet::Interface::Option.new(face, "--foo")
+      option.name.should == :foo
+      option.to_s.should == "foo"
+    end
+
+    it "should use - rather than _ to separate words in strings but not symbols" do
+      option = Puppet::Interface::Option.new(face, "--foo-bar")
+      option.name.should == :foo_bar
+      option.to_s.should == "foo-bar"
+    end
+  end
+
+  %w{before after}.each do |side|
+    describe "#{side} hooks" do
+      subject { Puppet::Interface::Option.new(face, "--foo") }
+      let :proc do Proc.new do :from_proc end end
+
+      it { should respond_to "#{side}_action" }
+      it { should respond_to "#{side}_action=" }
+
+      it "should set the #{side}_action hook" do
+        subject.send("#{side}_action").should be_nil
+        subject.send("#{side}_action=", proc)
+        subject.send("#{side}_action").should be_an_instance_of UnboundMethod
+      end
+
+      data = [1, "foo", :foo, Object.new, method(:hash), method(:hash).unbind]
+      data.each do |input|
+        it "should fail if a #{input.class} is added to the #{side} hooks" do
+          expect { subject.send("#{side}_action=", input) }.
+            to raise_error ArgumentError, /not a proc/
+        end
+      end
+    end
+  end
+end

data/spec/unit/interface_spec.rb

@@ -0,0 +1,228 @@
+require 'spec_helper'
+require 'puppet/face'
+require 'puppet/interface'
+
+describe Puppet::Interface do
+  subject { Puppet::Interface }
+
+  before :each do
+    @faces = Puppet::Interface::FaceCollection.
+      instance_variable_get("@faces").dup
+    @dq = $".dup
+    $".delete_if do |path| path =~ %r{/face/.*\.rb$} end
+    Puppet::Interface::FaceCollection.instance_variable_get("@faces").clear
+  end
+
+  after :each do
+    Puppet::Interface::FaceCollection.instance_variable_set("@faces", @faces)
+    $".clear ; @dq.each do |item| $" << item end
+  end
+
+  describe "#[]" do
+    it "should fail when no version is requested" do
+      expect { subject[:huzzah] }.should raise_error ArgumentError
+    end
+
+    it "should raise an exception when the requested version is unavailable" do
+      expect { subject[:huzzah, '17.0.0'] }.should raise_error, Puppet::Error
+    end
+
+    it "should raise an exception when the requested face doesn't exist" do
+      expect { subject[:burrble_toot, :current] }.should raise_error, Puppet::Error
+    end
+
+    describe "version matching" do
+      { '1'     => '1.1.1',
+        '1.0'   => '1.0.1',
+        '1.0.1' => '1.0.1',
+        '1.1'   => '1.1.1',
+        '1.1.1' => '1.1.1'
+      }.each do |input, expect|
+        it "should match #{input.inspect} to #{expect.inspect}" do
+          face = subject[:version_matching, input]
+          face.should be
+          face.version.should == expect
+        end
+      end
+
+      %w{1.0.2 1.2}.each do |input|
+        it "should not match #{input.inspect} to any version" do
+          expect { subject[:version_matching, input] }.
+            to raise_error Puppet::Error, /Could not find version/
+        end
+      end
+    end
+  end
+
+  describe "#define" do
+    it "should register the face" do
+      face  = subject.define(:face_test_register, '0.0.1')
+      face.should == subject[:face_test_register, '0.0.1']
+    end
+
+    it "should load actions" do
+      subject.any_instance.expects(:load_actions)
+      subject.define(:face_test_load_actions, '0.0.1')
+    end
+
+    it "should require a version number" do
+      expect { subject.define(:no_version) }.to raise_error ArgumentError
+    end
+
+    it "should support summary builder and accessor methods" do
+      subject.new(:foo, '1.0.0').should respond_to(:summary).with(0).arguments
+      subject.new(:foo, '1.0.0').should respond_to(:summary=).with(1).arguments
+    end
+
+    # Required documentation methods...
+    { :summary     => "summary",
+      :description => "This is the description of the stuff\n\nWhee",
+      :examples    => "This is my example",
+      :short_description => "This is my custom short description",
+      :notes       => "These are my notes...",
+      :author      => "This is my authorship data",
+    }.each do |attr, value|
+      it "should support #{attr} in the builder" do
+        face = subject.new(:builder, '1.0.0') do
+          self.send(attr, value)
+        end
+        face.send(attr).should == value
+      end
+    end
+  end
+
+  describe "#initialize" do
+    it "should require a version number" do
+      expect { subject.new(:no_version) }.to raise_error ArgumentError
+    end
+
+    it "should require a valid version number" do
+      expect { subject.new(:bad_version, 'Rasins') }.
+        should raise_error ArgumentError
+    end
+
+    it "should instance-eval any provided block", :'fails_on_ruby_1.9.2' => true do
+      face = subject.new(:face_test_block, '0.0.1') do
+        action(:something) do
+          when_invoked { "foo" }
+        end
+      end
+
+      face.something.should == "foo"
+    end
+  end
+
+  it "should have a name" do
+    subject.new(:me, '0.0.1').name.should == :me
+  end
+
+  it "should stringify with its own name" do
+    subject.new(:me, '0.0.1').to_s.should =~ /\bme\b/
+  end
+
+  # Why?
+  it "should create a class-level autoloader" do
+    subject.autoloader.should be_instance_of(Puppet::Util::Autoload)
+  end
+
+  it "should try to require faces that are not known" do
+    pending "mocking require causes random stack overflow"
+    subject::FaceCollection.expects(:require).with "puppet/face/foo"
+    subject[:foo, '0.0.1']
+  end
+
+  it "should be able to load all actions in all search paths"
+
+
+  it_should_behave_like "things that declare options" do
+    def add_options_to(&block)
+      subject.new(:with_options, '0.0.1', &block)
+    end
+  end
+
+  describe "with face-level options", :'fails_on_ruby_1.9.2' => true do
+    it "should not return any action-level options" do
+      face = subject.new(:with_options, '0.0.1') do
+        option "--foo"
+        option "--bar"
+        action :baz do
+          when_invoked { true }
+          option "--quux"
+        end
+      end
+      face.options.should =~ [:foo, :bar]
+    end
+
+    it "should fail when a face option duplicates an action option" do
+      expect {
+        subject.new(:action_level_options, '0.0.1') do
+          action :bar do
+            when_invoked { true }
+            option "--foo"
+          end
+          option "--foo"
+        end
+      }.should raise_error ArgumentError, /Option foo conflicts with existing option foo on/i
+    end
+
+    it "should work when two actions have the same option" do
+      face = subject.new(:with_options, '0.0.1') do
+        action :foo do when_invoked { true } ; option "--quux" end
+        action :bar do when_invoked { true } ; option "--quux" end
+      end
+
+      face.get_action(:foo).options.should =~ [:quux]
+      face.get_action(:bar).options.should =~ [:quux]
+    end
+  end
+
+  describe "with inherited options" do
+    let :parent do
+      parent = Class.new(subject)
+      parent.option("--inherited")
+      parent.action(:parent_action) do when_invoked { true } end
+      parent
+    end
+
+    let :face do
+      face = parent.new(:example, '0.2.1')
+      face.option("--local")
+      face.action(:face_action) do when_invoked { true } end
+      face
+    end
+
+    describe "#options", :'fails_on_ruby_1.9.2' => true do
+      it "should list inherited options" do
+        face.options.should =~ [:inherited, :local]
+      end
+
+      it "should see all options on face actions" do
+        face.get_action(:face_action).options.should =~ [:inherited, :local]
+      end
+
+      it "should see all options on inherited actions accessed on the subclass" do
+        face.get_action(:parent_action).options.should =~ [:inherited, :local]
+      end
+
+      it "should not see subclass actions on the parent class" do
+        parent.options.should =~ [:inherited]
+      end
+
+      it "should not see subclass actions on actions accessed on the parent class" do
+        parent.get_action(:parent_action).options.should =~ [:inherited]
+      end
+    end
+
+    describe "#get_option", :'fails_on_ruby_1.9.2' => true do
+      it "should return an inherited option object" do
+        face.get_option(:inherited).should be_an_instance_of subject::Option
+      end
+    end
+  end
+
+  it_should_behave_like "documentation on faces" do
+    subject do
+      Puppet::Interface.new(:face_documentation, '0.0.1')
+    end
+  end
+end