supply_drop 0.11.0 → 0.11.1

data/examples/vendored-puppet/vendor/puppet-2.7.8/spec/shared_behaviours/an_indirector_face.rb

@@ -1,6 +0,0 @@
-shared_examples_for "an indirector face" do
-  [:find, :search, :save, :destroy, :info].each do |action|
-    it { should be_action action }
-    it { should respond_to action }
-  end
-end

data/examples/vendored-puppet/vendor/puppet-2.7.8/spec/shared_behaviours/documentation_on_faces.rb

@@ -1,263 +0,0 @@
-# encoding: UTF-8
-shared_examples_for "documentation on faces" do
-  defined?(Attrs) or
-    Attrs = [:summary, :description, :examples, :short_description, :notes, :author]
-
-  defined?(SingleLineAttrs) or
-    SingleLineAttrs = [:summary, :author]
-
-  # Simple, procedural tests that apply to a bunch of methods.
-  Attrs.each do |attr|
-    it "should accept a #{attr}" do
-      expect { subject.send("#{attr}=", "hello") }.not_to raise_error
-      subject.send(attr).should == "hello"
-    end
-
-    it "should accept a long (single line) value for #{attr}" do
-      text = "I never know when to stop with the word banana" + ("na" * 1000)
-      expect { subject.send("#{attr}=", text) }.to_not raise_error
-      subject.send(attr).should == text
-    end
-  end
-
-  Attrs.each do |getter|
-    setter = "#{getter}=".to_sym
-    context "#{getter}" do
-      it "should strip leading whitespace on a single line" do
-        subject.send(setter, "  death to whitespace")
-        subject.send(getter).should == "death to whitespace"
-      end
-
-      it "should strip trailing whitespace on a single line" do
-        subject.send(setter, "death to whitespace  ")
-        subject.send(getter).should == "death to whitespace"
-      end
-
-      it "should strip whitespace at both ends at once" do
-        subject.send(setter, "  death to whitespace  ")
-        subject.send(getter).should == "death to whitespace"
-      end
-
-      multiline_text = "with\nnewlines"
-      if SingleLineAttrs.include? getter then
-        it "should not accept multiline values" do
-          expect { subject.send(setter, multiline_text) }.
-            to raise_error ArgumentError, /#{getter} should be a single line/
-          subject.send(getter).should be_nil
-        end
-      else
-        it "should accept multiline values" do
-          expect { subject.send(setter, multiline_text) }.not_to raise_error
-          subject.send(getter).should == multiline_text
-        end
-
-        [1, 2, 4, 7, 25].each do |length|
-          context "#{length} chars indent" do
-            indent = ' ' * length
-
-            it "should strip leading whitespace on multiple lines" do
-              text = "this\nis\the\final\outcome"
-              subject.send(setter, text.gsub(/^/, indent))
-              subject.send(getter).should == text
-            end
-
-            it "should not remove formatting whitespace, only global indent" do
-              text = "this\n  is\n    the\n  ultimate\ntest\n"
-              subject.send(setter, text.gsub(/^/, indent))
-              subject.send(getter).should == text
-            end
-          end
-        end
-
-        it "should strip whitespace with a blank line" do
-          subject.send(setter, "  this\n\n  should outdent\n")
-          subject.send(getter).should == "this\n\nshould outdent\n"
-        end
-      end
-    end
-  end
-
-  describe "#short_description" do
-    it "should return the set value if set after description" do
-      subject.description = "hello\ngoodbye"
-      subject.short_description = "whatever"
-      subject.short_description.should == "whatever"
-    end
-
-    it "should return the set value if set before description" do
-      subject.short_description = "whatever"
-      subject.description = "hello\ngoodbye"
-      subject.short_description.should == "whatever"
-    end
-
-    it "should return nothing if not set and no description" do
-      subject.short_description.should be_nil
-    end
-
-    it "should return the first paragraph of description if not set (where it is one line long)" do
-      subject.description = "hello"
-      subject.short_description.should == subject.description
-    end
-
-    it "should return the first paragraph of description if not set (where there is no paragraph break)" do
-      subject.description = "hello\ngoodbye"
-      subject.short_description.should == subject.description
-    end
-
-    it "should return the first paragraph of description if not set (where there is a paragraph break)" do
-      subject.description = "hello\ngoodbye\n\nmore\ntext\nhere\n\nfinal\nparagraph"
-      subject.short_description.should == "hello\ngoodbye"
-    end
-
-    it "should trim a very, very long first paragraph and add ellipsis" do
-      line = "this is a very, very, very long long line full of text\n"
-      subject.description = line * 20 + "\n\nwhatever, dude."
-
-      subject.short_description.should == (line * 5).chomp + ' [...]'
-    end
-
-    it "should trim a very very long only paragraph even if it is followed by a new paragraph" do
-      line = "this is a very, very, very long long line full of text\n"
-      subject.description = line * 20
-
-      subject.short_description.should == (line * 5).chomp + ' [...]'
-    end
-  end
-
-  describe "multiple authors" do
-    authors = %w{John Paul George Ringo}
-
-    context "in the DSL" do
-      it "should support multiple authors" do
-
-        authors.each {|name| subject.author name }
-        subject.authors.should =~ authors
-
-        subject.author.should == authors.join("\n")
-      end
-
-      it "should reject author as an array" do
-        expect { subject.author ["Foo", "Bar"] }.
-          to raise_error ArgumentError, /author must be a string/
-      end
-    end
-
-    context "#author=" do
-      it "should accept a single name" do
-        subject.author = "Fred"
-        subject.author.should == "Fred"
-      end
-
-      it "should accept an array of names" do
-        subject.author = authors
-        subject.authors.should =~ authors
-        subject.author.should == authors.join("\n")
-      end
-
-      it "should not append when set multiple times" do
-        subject.author = "Fred"
-        subject.author = "John"
-        subject.author.should == "John"
-      end
-
-      it "should reject arrays with embedded newlines" do
-        expect { subject.author = ["Fred\nJohn"] }.
-          to raise_error ArgumentError, /author should be a single line/
-      end
-    end
-  end
-
-  describe "#license" do
-    it "should default to reserving rights" do
-      subject.license.should =~ /All Rights Reserved/
-    end
-
-    it "should accept an arbitrary license string on the object" do
-      subject.license = "foo"
-      subject.license.should == "foo"
-    end
-
-    it "should accept symbols to specify existing licenses..."
-  end
-
-  describe "#copyright" do
-    it "should fail with just a name" do
-      expect { subject.copyright("invalid") }.
-        to raise_error ArgumentError, /copyright takes the owners names, then the years covered/
-    end
-
-    [1997, "1997"].each do |year|
-      it "should accept an entity name and a #{year.class.name} year" do
-        subject.copyright("me", year)
-        subject.copyright.should =~ /\bme\b/
-        subject.copyright.should =~ /#{year}/
-      end
-
-      it "should accept multiple entity names and a #{year.class.name} year" do
-        subject.copyright ["me", "you"], year
-        subject.copyright.should =~ /\bme\b/
-        subject.copyright.should =~ /\byou\b/
-        subject.copyright.should =~ /#{year}/
-      end
-    end
-
-    ["1997-2003", "1997 - 2003", 1997..2003].each do |range|
-      it "should accept a #{range.class.name} range of years" do
-        subject.copyright("me", range)
-        subject.copyright.should =~ /\bme\b/
-        subject.copyright.should =~ /1997-2003/
-      end
-
-      it "should accept a #{range.class.name} range of years" do
-        subject.copyright ["me", "you"], range
-        subject.copyright.should =~ /\bme\b/
-        subject.copyright.should =~ /\byou\b/
-        subject.copyright.should =~ /1997-2003/
-      end
-    end
-
-    [[1997, 2003], ["1997", 2003], ["1997", "2003"]].each do |input|
-      it "should accept the set of years #{input.inspect} in an array" do
-        subject.copyright "me", input
-        subject.copyright.should =~ /\bme\b/
-        subject.copyright.should =~ /1997, 2003/
-      end
-
-      it "should accept the set of years #{input.inspect} in an array" do
-        subject.copyright ["me", "you"], input
-        subject.copyright.should =~ /\bme\b/
-        subject.copyright.should =~ /\byou\b/
-        subject.copyright.should =~ /1997, 2003/
-      end
-    end
-
-    it "should warn if someone does math accidentally on the range of years" do
-      expect { subject.copyright "me", 1997-2003 }.
-        to raise_error ArgumentError, /copyright with a year before 1970 is very strange; did you accidentally add or subtract two years\?/
-    end
-
-    it "should accept complex copyright years" do
-      years = [1997, 1999, 2000..2002, 2005].reverse
-      subject.copyright "me", years
-      subject.copyright.should =~ /\bme\b/
-      subject.copyright.should =~ /1997, 1999, 2000-2002, 2005/
-    end
-  end
-
-  # Things that are automatically generated.
-  [:name, :options, :synopsis].each do |attr|
-    describe "##{attr}" do
-      it "should not allow you to set #{attr}" do
-        subject.should_not respond_to :"#{attr}="
-      end
-
-      it "should have a #{attr}" do
-        subject.send(attr).should_not be_nil
-      end
-
-      it "'s #{attr} should not be empty..." do
-        subject.send(attr).should_not == ''
-      end
-    end
-  end
-end

data/examples/vendored-puppet/vendor/puppet-2.7.8/spec/shared_behaviours/file_server_terminus.rb

@@ -1,41 +0,0 @@
-#!/usr/bin/env rspec
-shared_examples_for "Puppet::Indirector::FileServerTerminus" do
-  # This only works if the shared behaviour is included before
-  # the 'before' block in the including context.
-  before do
-    Puppet::FileServing::Configuration.instance_variable_set(:@configuration, nil)
-    FileTest.stubs(:exists?).returns true
-    FileTest.stubs(:exists?).with(Puppet[:fileserverconfig]).returns(true)
-
-    @path = Tempfile.new("file_server_testing")
-    path = @path.path
-    @path.close!
-    @path = path
-
-    Dir.mkdir(@path)
-    File.open(File.join(@path, "myfile"), "w") { |f| f.print "my content" }
-
-    # Use a real mount, so the integration is a bit deeper.
-    @mount1 = Puppet::FileServing::Configuration::Mount::File.new("one")
-    @mount1.path = @path
-
-    @parser = stub 'parser', :changed? => false
-    @parser.stubs(:parse).returns("one" => @mount1)
-
-    Puppet::FileServing::Configuration::Parser.stubs(:new).returns(@parser)
-
-    # Stub out the modules terminus
-    @modules = mock 'modules terminus'
-
-    @request = Puppet::Indirector::Request.new(:indirection, :method, "puppet://myhost/one/myfile")
-  end
-
-  it "should use the file server configuration to find files" do
-    @modules.stubs(:find).returns(nil)
-    @terminus.indirection.stubs(:terminus).with(:modules).returns(@modules)
-
-    path = File.join(@path, "myfile")
-
-    @terminus.find(@request).should be_instance_of(@test_class)
-  end
-end

data/examples/vendored-puppet/vendor/puppet-2.7.8/spec/shared_behaviours/file_serving.rb

@@ -1,68 +0,0 @@
-#!/usr/bin/env rspec
-shared_examples_for "Puppet::FileServing::Files" do
-  it "should use the rest terminus when the 'puppet' URI scheme is used and a host name is present" do
-    uri = "puppet://myhost/fakemod/my/file"
-
-    # It appears that the mocking somehow interferes with the caching subsystem.
-    # This mock somehow causes another terminus to get generated.
-    term = @indirection.terminus(:rest)
-    @indirection.stubs(:terminus).with(:rest).returns term
-    term.expects(:find)
-    @indirection.find(uri)
-  end
-
-  it "should use the rest terminus when the 'puppet' URI scheme is used, no host name is present, and the process name is not 'puppet' or 'apply'" do
-    uri = "puppet:///fakemod/my/file"
-    Puppet.settings.stubs(:value).returns "foo"
-    Puppet.settings.stubs(:value).with(:name).returns("puppetd")
-    Puppet.settings.stubs(:value).with(:modulepath).returns("")
-    @indirection.terminus(:rest).expects(:find)
-    @indirection.find(uri)
-  end
-
-  it "should use the file_server terminus when the 'puppet' URI scheme is used, no host name is present, and the process name is 'puppet'" do
-    uri = "puppet:///fakemod/my/file"
-    Puppet::Node::Environment.stubs(:new).returns(stub("env", :name => "testing", :module => nil, :modulepath => []))
-    Puppet.settings.stubs(:value).returns ""
-    Puppet.settings.stubs(:value).with(:name).returns("puppet")
-    Puppet.settings.stubs(:value).with(:fileserverconfig).returns("/whatever")
-    @indirection.terminus(:file_server).expects(:find)
-    @indirection.terminus(:file_server).stubs(:authorized?).returns(true)
-    @indirection.find(uri)
-  end
-
-  it "should use the file_server terminus when the 'puppet' URI scheme is used, no host name is present, and the process name is 'apply'" do
-    uri = "puppet:///fakemod/my/file"
-    Puppet::Node::Environment.stubs(:new).returns(stub("env", :name => "testing", :module => nil, :modulepath => []))
-    Puppet.settings.stubs(:value).returns ""
-    Puppet.settings.stubs(:value).with(:name).returns("apply")
-    Puppet.settings.stubs(:value).with(:fileserverconfig).returns("/whatever")
-    @indirection.terminus(:file_server).expects(:find)
-    @indirection.terminus(:file_server).stubs(:authorized?).returns(true)
-    @indirection.find(uri)
-  end
-
-  it "should use the file terminus when the 'file' URI scheme is used" do
-    uri = Puppet::Util.path_to_uri(File.expand_path('/fakemod/my/other file'))
-    uri.scheme.should == 'file'
-    @indirection.terminus(:file).expects(:find)
-    @indirection.find(uri.to_s)
-  end
-
-  it "should use the file terminus when a fully qualified path is provided" do
-    uri = File.expand_path("/fakemod/my/file")
-    @indirection.terminus(:file).expects(:find)
-    @indirection.find(uri)
-  end
-
-  it "should use the configuration to test whether the request is allowed" do
-    uri = "fakemod/my/file"
-    mount = mock 'mount'
-    config = stub 'configuration', :split_path => [mount, "eh"]
-    @indirection.terminus(:file_server).stubs(:configuration).returns config
-
-    @indirection.terminus(:file_server).expects(:find)
-    mount.expects(:allowed?).returns(true)
-    @indirection.find(uri, :node => "foo", :ip => "bar")
-  end
-end

data/examples/vendored-puppet/vendor/puppet-2.7.8/spec/shared_behaviours/memory_terminus.rb

@@ -1,28 +0,0 @@
-shared_examples_for "A Memory Terminus" do
-  it "should find no instances by default" do
-    @searcher.find(@request).should be_nil
-  end
-
-  it "should be able to find instances that were previously saved" do
-    @searcher.save(@request)
-    @searcher.find(@request).should equal(@instance)
-  end
-
-  it "should replace existing saved instances when a new instance with the same name is saved" do
-    @searcher.save(@request)
-    two = stub 'second', :name => @name
-    trequest = stub 'request', :key => @name, :instance => two
-    @searcher.save(trequest)
-    @searcher.find(@request).should equal(two)
-  end
-
-  it "should be able to remove previously saved instances" do
-    @searcher.save(@request)
-    @searcher.destroy(@request)
-    @searcher.find(@request).should be_nil
-  end
-
-  it "should fail when asked to destroy an instance that does not exist" do
-    proc { @searcher.destroy(@request) }.should raise_error(ArgumentError)
-  end
-end

data/examples/vendored-puppet/vendor/puppet-2.7.8/spec/shared_behaviours/path_parameters.rb

@@ -1,187 +0,0 @@
-# In order to use this correctly you must define a method to get an instance
-# of the type being tested, so that this code can remain generic:
-#
-#    it_should_behave_like "all path parameters", :path do
-#      def instance(path)
-#        Puppet::Type.type(:example).new(
-#          :name => 'foo', :require => 'bar', :path_param => path
-#        )
-#      end
-#
-# That method will be invoked for each test to create the instance that we
-# subsequently test through the system; you should ensure that the minimum of
-# possible attributes are set to keep the tests clean.
-#
-# You must also pass the symbolic name of the parameter being tested to the
-# block, and optionally can pass a hash of additional options to the block.
-#
-# The known options are:
-#  :array :: boolean, does this support arrays of paths, default true.
-
-shared_examples_for "all pathname parameters with arrays" do |win32|
-  path_types = {
-    "unix absolute"            => %q{/foo/bar},
-    "unix relative"            => %q{foo/bar},
-    "win32 non-drive absolute" => %q{\foo\bar},
-    "win32 non-drive relative" => %q{foo\bar},
-    "win32 drive absolute"     => %q{c:\foo\bar},
-    "win32 drive relative"     => %q{c:foo\bar}
-  }
-
-  describe "when given an array of paths" do
-    (1..path_types.length).each do |n|
-      path_types.keys.combination(n) do |set|
-        data = path_types.collect { |k, v| set.member?(k) ? v : nil } .compact
-
-        has_relative = set.find { |k| k =~ /relative/ or k =~ /non-drive/ }
-        has_windows = set.find { |k| k =~ /win32/ }
-        has_unix = set.find { |k| k =~ /unix/ }
-
-        if has_relative or (has_windows and !win32) or (has_unix and win32)
-          reject = true
-        else
-          reject = false
-        end
-
-        it "should #{reject ? 'reject' : 'accept'} #{set.join(", ")}" do
-          if reject then
-            expect { instance(data) }.
-              should raise_error Puppet::Error, /fully qualified/
-          else
-            instance = instance(data)
-            instance[@param].should == data
-          end
-        end
-
-        it "should #{reject ? 'reject' : 'accept'} #{set.join(", ")} doubled" do
-          if reject then
-            expect { instance(data + data) }.
-              should raise_error Puppet::Error, /fully qualified/
-          else
-            instance = instance(data + data)
-            instance[@param].should == (data + data)
-          end
-        end
-      end
-    end
-  end
-end
-
-
-shared_examples_for "all path parameters" do |param, options|
-  # Extract and process options to the block.
-  options ||= {}
-  array = options[:array].nil? ? true : options.delete(:array)
-  if options.keys.length > 0 then
-    fail "unknown options for 'all path parameters': " +
-      options.keys.sort.join(', ')
-  end
-
-  def instance(path)
-    fail "we didn't implement the 'instance(path)' method in the it_should_behave_like block"
-  end
-
-  ########################################################################
-  # The actual testing code...
-  before :all do
-    @param = param
-  end
-
-  before :each do
-    @file_separator = File::SEPARATOR
-  end
-  after :each do
-    with_verbose_disabled do
-      verbose, $VERBOSE = $VERBOSE, nil
-      File::SEPARATOR = @file_separator
-      $VERBOSE = verbose
-    end
-  end
-
-  describe "on a Unix-like platform it" do
-    before :each do
-      with_verbose_disabled do
-        File::SEPARATOR = '/'
-      end
-      Puppet.features.stubs(:microsoft_windows?).returns(false)
-      Puppet.features.stubs(:posix?).returns(true)
-    end
-
-    if array then
-      it_should_behave_like "all pathname parameters with arrays", false
-    end
-
-    it "should accept a fully qualified path" do
-      path = File.join('', 'foo')
-      instance = instance(path)
-      instance[@param].should == path
-    end
-
-    it "should give a useful error when the path is not absolute" do
-      path = 'foo'
-      expect { instance(path) }.
-        should raise_error Puppet::Error, /fully qualified/
-    end
-
-    { "Unix" => '/', "Win32" => '\\' }.each do |style, slash|
-      %w{q Q a A z Z c C}.sort.each do |drive|
-        it "should reject drive letter '#{drive}' with #{style} path separators" do
-          path = "#{drive}:#{slash}Program Files"
-          expect { instance(path) }.
-            should raise_error Puppet::Error, /fully qualified/
-        end
-      end
-    end
-  end
-
-  describe "on a Windows-like platform it" do
-    before :each do
-      with_verbose_disabled do
-        File::SEPARATOR = '\\'
-      end
-      Puppet.features.stubs(:microsoft_windows?).returns(true)
-      Puppet.features.stubs(:posix?).returns(false)
-    end
-
-    if array then
-      it_should_behave_like "all pathname parameters with arrays", true
-    end
-
-    it "should reject a fully qualified unix path" do
-      path = '/foo'
-      expect { instance(path) }.to raise_error(Puppet::Error, /fully qualified/)
-    end
-
-    it "should give a useful error when the path is not absolute" do
-      path = 'foo'
-      expect { instance(path) }.
-        should raise_error Puppet::Error, /fully qualified/
-    end
-
-    it "also accepts Unix style path separators" do
-      path = 'C:/Program Files'
-      instance = instance(path)
-      instance[@param].should == path
-    end
-
-    { "Unix" => '/', "Win32" => '\\' }.each do |style, slash|
-      %w{q Q a A z Z c C}.sort.each do |drive|
-        it "should accept drive letter '#{drive}' with #{style} path separators " do
-          path = "#{drive}:#{slash}Program Files"
-          instance = instance(path)
-          instance[@param].should == path
-        end
-      end
-    end
-
-    { "UNC paths"            => %q{\\\\foo\bar},
-      "unparsed local paths" => %q{\\\\?\c:\foo},
-      "unparsed UNC paths"   => %q{\\\\?\foo\bar}
-    }.each do |name, path|
-      it "should accept #{name} as absolute" do
-        instance = instance(path)
-        instance[@param].should == path
-      end
-    end
-  end
-end