puppet 0.25.5 → 2.6.0

data/spec/unit/network/client.rb

@@ -1,45 +0,0 @@
-#!/usr/bin/env ruby
-#
-#  Created by Luke Kanies on 2008-3-24.
-#  Copyright (c) 2008. All rights reserved.
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-require 'puppet/network/client'
-
-describe Puppet::Network::Client do
-    before do
-        Puppet.settings.stubs(:use).returns(true)
-        Puppet::Network::HttpPool.stubs(:cert_setup)
-    end
-
-    describe "when keep-alive is enabled" do
-        before do
-            Puppet::Network::HttpPool.stubs(:keep_alive?).returns true
-        end
-        it "should start the http client up on creation" do
-            http = mock 'http'
-            http.stub_everything
-            http.expects(:start)
-            Net::HTTP.stubs(:new).returns http
-
-            # Pick a random subclass...
-            Puppet::Network::Client.runner.new :Server => Puppet[:server]
-        end
-    end
-
-    describe "when keep-alive is disabled" do
-        before do
-            Puppet::Network::HttpPool.stubs(:keep_alive?).returns false
-        end
-        it "should not start the http client up on creation" do
-            http = mock 'http'
-            http.stub_everything
-            http.expects(:start).never
-            Net::HTTP.stubs(:new).returns http
-
-            # Pick a random subclass...
-            Puppet::Network::Client.runner.new :Server => Puppet[:server]
-        end
-    end
-end

data/spec/unit/network/client/dipper.rb

@@ -1,16 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../../spec_helper'
-
-describe Puppet::Network::Client.dipper do
-    it "should fail in an informative way when there are failures backing up to the server" do
-        FileTest.stubs(:exists?).returns true
-        File.stubs(:read).returns "content"
-
-        @dipper = Puppet::Network::Client::Dipper.new(:Path => "/my/bucket")
-
-        @dipper.driver.expects(:addfile).raises ArgumentError
-
-        lambda { @dipper.backup("/my/file") }.should raise_error(Puppet::Error)
-    end
-end

data/spec/unit/network/format.rb

@@ -1,191 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-require 'puppet/network/format'
-
-# A class with all of the necessary
-# hooks.
-class FormatRenderer
-    def self.to_multiple_my_format(list)
-    end
-
-    def self.from_multiple_my_format(text)
-    end
-
-    def self.from_my_format(text)
-    end
-
-    def to_my_format
-    end
-end
-
-describe Puppet::Network::Format do
-    describe "when initializing" do
-        it "should require a name" do
-            lambda { Puppet::Network::Format.new }.should raise_error(ArgumentError)
-        end
-
-        it "should be able to provide its name" do
-            Puppet::Network::Format.new(:my_format).name.should == :my_format
-        end
-
-        it "should always convert its name to a downcased symbol" do
-            Puppet::Network::Format.new(:My_Format).name.should == :my_format
-        end
-
-        it "should be able to set its downcased mime type at initialization" do
-            format = Puppet::Network::Format.new(:my_format, :mime => "Foo/Bar")
-            format.mime.should == "foo/bar"
-        end
-
-        it "should default to text plus the name of the format as the mime type" do
-            Puppet::Network::Format.new(:my_format).mime.should == "text/my_format"
-        end
-
-        it "should fail if unsupported options are provided" do
-            lambda { Puppet::Network::Format.new(:my_format, :foo => "bar") }.should raise_error(ArgumentError)
-        end
-    end
-
-    describe "instances" do
-        before do
-            @format = Puppet::Network::Format.new(:my_format)
-        end
-
-        it "should support being confined" do
-            @format.should respond_to(:confine)
-        end
-
-        it "should not be considered suitable if confinement conditions are not met" do
-            @format.confine :true => false
-            @format.should_not be_suitable
-        end
-
-        it "should be able to determine if a class is supported" do
-            @format.should respond_to(:supported?)
-        end
-
-        it "should consider a class to be supported if it has the individual and multiple methods for rendering and interning" do
-            @format.should be_supported(FormatRenderer)
-        end
-
-        it "should default to its required methods being the individual and multiple methods for rendering and interning" do
-            Puppet::Network::Format.new(:foo).required_methods.sort { |a,b| a.to_s <=> b.to_s }.should ==  [:intern_method, :intern_multiple_method, :render_multiple_method, :render_method].sort { |a,b| a.to_s <=> b.to_s }
-        end
-
-        it "should consider a class supported if the provided class has all required methods present" do
-            format = Puppet::Network::Format.new(:foo)
-            [:intern_method, :intern_multiple_method, :render_multiple_method, :render_method].each do |method|
-                format.expects(:required_method_present?).with { |name, klass, type| name == method and klass == String }.returns true
-            end
-
-            format.should be_required_methods_present(String)
-        end
-
-        it "should consider a class not supported if any required methods are missing from the provided class" do
-            format = Puppet::Network::Format.new(:foo)
-            format.stubs(:required_method_present?).returns true
-            format.expects(:required_method_present?).with { |name, *args| name == :intern_method }.returns false
-            format.should_not be_required_methods_present(String)
-        end
-
-        it "should be able to specify the methods required for support" do
-            Puppet::Network::Format.new(:foo, :required_methods => [:render_method, :intern_method]).required_methods.should == [:render_method, :intern_method]
-        end
-
-        it "should only test for required methods if specific methods are specified as required" do
-            format = Puppet::Network::Format.new(:foo, :required_methods => [:intern_method])
-            format.expects(:required_method_present?).with { |name, klass, type| name == :intern_method }
-
-            format.required_methods_present?(String)
-        end
-
-        it "should not consider a class supported unless the format is suitable" do
-            @format.expects(:suitable?).returns false
-            @format.should_not be_supported(FormatRenderer)
-        end
-
-        it "should always downcase mimetypes" do
-            @format.mime = "Foo/Bar"
-            @format.mime.should == "foo/bar"
-        end
-
-        it "should support having a weight" do
-            @format.should respond_to(:weight)
-        end
-
-        it "should default to a weight of of 5" do
-            @format.weight.should == 5
-        end
-
-        it "should be able to override its weight at initialization" do
-            Puppet::Network::Format.new(:foo, :weight => 1).weight.should == 1
-        end
-
-        [:intern_method, :intern_multiple_method, :render_multiple_method, :render_method].each do |method|
-            it "should allow assignment of the #{method}" do
-                Puppet::Network::Format.new(:foo, method => :foo).send(method).should == :foo
-            end
-        end
-    end
-
-    describe "when converting between instances and formatted text" do
-        before do
-            @format = Puppet::Network::Format.new(:my_format)
-            @instance = FormatRenderer.new
-        end
-
-        it "should have a method for rendering a single instance" do
-            @format.should respond_to(:render)
-        end
-
-        it "should have a method for rendering multiple instances" do
-            @format.should respond_to(:render_multiple)
-        end
-
-        it "should have a method for interning text" do
-            @format.should respond_to(:intern)
-        end
-
-        it "should have a method for interning text into multiple instances" do
-            @format.should respond_to(:intern_multiple)
-        end
-
-        it "should return the results of calling the instance-specific render method if the method is present" do
-            @instance.expects(:to_my_format).returns "foo"
-            @format.render(@instance).should == "foo"
-        end
-
-        it "should return the results of calling the class-specific render_multiple method if the method is present" do
-            @instance.class.expects(:to_multiple_my_format).returns ["foo"]
-            @format.render_multiple([@instance]).should == ["foo"]
-        end
-
-        it "should return the results of calling the class-specific intern method if the method is present" do
-            FormatRenderer.expects(:from_my_format).with("foo").returns @instance
-            @format.intern(FormatRenderer, "foo").should equal(@instance)
-        end
-
-        it "should return the results of calling the class-specific intern_multiple method if the method is present" do
-            FormatRenderer.expects(:from_multiple_my_format).with("foo").returns [@instance]
-            @format.intern_multiple(FormatRenderer, "foo").should == [@instance]
-        end
-
-        it "should fail if asked to render and the instance does not respond to 'to_<format>'" do
-            lambda { @format.render("foo") }.should raise_error(NotImplementedError)
-        end
-
-        it "should fail if asked to intern and the class does not respond to 'from_<format>'" do
-            lambda { @format.intern(String, "foo") }.should raise_error(NotImplementedError)
-        end
-
-        it "should fail if asked to intern multiple and the class does not respond to 'from_multiple_<format>'" do
-            lambda { @format.intern_multiple(String, "foo") }.should raise_error(NotImplementedError)
-        end
-
-        it "should fail if asked to render multiple and the instance does not respond to 'to_multiple_<format>'" do
-            lambda { @format.render_multiple(["foo", "bar"]) }.should raise_error(NotImplementedError)
-        end
-    end
-end

data/spec/unit/network/format_handler.rb

@@ -1,327 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-require 'puppet/network/format_handler'
-
-class FormatTester
-    extend Puppet::Network::FormatHandler
-end
-
-describe Puppet::Network::FormatHandler do
-    after do
-        formats = Puppet::Network::FormatHandler.instance_variable_get("@formats")
-        formats.each do |name, format|
-            formats.delete(name) unless format.is_a?(Puppet::Network::Format)
-        end
-    end
-
-    it "should be able to list supported formats" do
-        FormatTester.should respond_to(:supported_formats)
-    end
-
-    it "should include all supported formats" do
-        one = stub 'supported', :supported? => true, :name => :one, :weight => 1
-        two = stub 'supported', :supported? => false, :name => :two, :weight => 1
-        three = stub 'supported', :supported? => true, :name => :three, :weight => 1
-        four = stub 'supported', :supported? => false, :name => :four, :weight => 1
-        Puppet::Network::FormatHandler.stubs(:formats).returns [:one, :two, :three, :four]
-        Puppet::Network::FormatHandler.stubs(:format).with(:one).returns one
-        Puppet::Network::FormatHandler.stubs(:format).with(:two).returns two
-        Puppet::Network::FormatHandler.stubs(:format).with(:three).returns three
-        Puppet::Network::FormatHandler.stubs(:format).with(:four).returns four
-        result = FormatTester.supported_formats
-        result.length.should == 2
-        result.should be_include(:one)
-        result.should be_include(:three)
-    end
-
-    it "should return the supported formats in decreasing order of weight" do
-        one = stub 'supported', :supported? => true, :name => :one, :weight => 1
-        two = stub 'supported', :supported? => true, :name => :two, :weight => 6
-        three = stub 'supported', :supported? => true, :name => :three, :weight => 2
-        four = stub 'supported', :supported? => true, :name => :four, :weight => 8
-        Puppet::Network::FormatHandler.stubs(:formats).returns [:one, :two, :three, :four]
-        Puppet::Network::FormatHandler.stubs(:format).with(:one).returns one
-        Puppet::Network::FormatHandler.stubs(:format).with(:two).returns two
-        Puppet::Network::FormatHandler.stubs(:format).with(:three).returns three
-        Puppet::Network::FormatHandler.stubs(:format).with(:four).returns four
-        FormatTester.supported_formats.should == [:four, :two, :three, :one]
-    end
-
-
-    describe "with a preferred serialization format setting" do
-        before do
-            one = stub 'supported', :supported? => true, :name => :one, :weight => 1
-            two = stub 'supported', :supported? => true, :name => :two, :weight => 6
-            Puppet::Network::FormatHandler.stubs(:formats).returns [:one, :two]
-            Puppet::Network::FormatHandler.stubs(:format).with(:one).returns one
-            Puppet::Network::FormatHandler.stubs(:format).with(:two).returns two
-        end
-        describe "that is supported" do
-            before do
-                Puppet.settings.expects(:value).with(:preferred_serialization_format).returns :one
-            end    
-            it "should return the preferred serialization format first" do
-                FormatTester.supported_formats.should == [:one, :two]
-            end
-        end
-        describe "that is not supported" do
-            before do
-                Puppet.settings.expects(:value).with(:preferred_serialization_format).returns :unsupported
-            end
-            it "should still return the default format first" do
-                FormatTester.supported_formats.should == [:two, :one]
-            end
-            it "should log a debug message" do
-                Puppet.expects(:debug).with("Value of 'preferred_serialization_format' (unsupported) is invalid for FormatTester, using default (two)")
-                Puppet.expects(:debug).with("FormatTester supports formats: one two; using two")
-                FormatTester.supported_formats
-            end
-        end
-    end
-
-    it "should return the first format as the default format" do
-        FormatTester.expects(:supported_formats).returns [:one, :two]
-        FormatTester.default_format.should == :one
-    end
-
-    it "should be able to use a protected format for better logging on errors" do
-        Puppet::Network::FormatHandler.should respond_to(:protected_format)
-    end
-
-    it "should delegate all methods from the informative format to the specified format" do
-        format = mock 'format'
-        format.stubs(:name).returns(:myformat)
-        Puppet::Network::FormatHandler.expects(:format).twice.with(:myformat).returns format
-
-        format.expects(:render).with("foo").returns "yay"
-        Puppet::Network::FormatHandler.protected_format(:myformat).render("foo").should == "yay"
-    end
-
-    it "should provide better logging if a failure is encountered when delegating from the informative format to the real format" do
-        format = mock 'format'
-        format.stubs(:name).returns(:myformat)
-        Puppet::Network::FormatHandler.expects(:format).twice.with(:myformat).returns format
-
-        format.expects(:render).with("foo").raises "foo"
-        lambda { Puppet::Network::FormatHandler.protected_format(:myformat).render("foo") }.should raise_error(Puppet::Network::FormatHandler::FormatError)
-    end
-
-    it "should raise an error if we couldn't find a format by name or mime-type" do
-        Puppet::Network::FormatHandler.stubs(:format).with(:myformat).returns nil
-        lambda { Puppet::Network::FormatHandler.protected_format(:myformat) }.should raise_error
-    end
-
-    describe "when using formats" do
-        before do
-            @format = mock 'format'
-            @format.stubs(:supported?).returns true
-            @format.stubs(:name).returns :my_format
-            Puppet::Network::FormatHandler.stubs(:format).with(:my_format).returns @format
-            Puppet::Network::FormatHandler.stubs(:mime).with("text/myformat").returns @format
-            Puppet::Network::Format.stubs(:===).returns false
-            Puppet::Network::Format.stubs(:===).with(@format).returns true
-        end
-
-        it "should be able to test whether a format is supported" do
-            FormatTester.should respond_to(:support_format?)
-        end
-
-        it "should use the Format to determine whether a given format is supported" do
-            @format.expects(:supported?).with(FormatTester)
-            FormatTester.support_format?(:my_format)
-        end
-
-        it "should be able to convert from a given format" do
-            FormatTester.should respond_to(:convert_from)
-        end
-
-        it "should call the format-specific converter when asked to convert from a given format" do
-            @format.expects(:intern).with(FormatTester, "mydata")
-            FormatTester.convert_from(:my_format, "mydata")
-        end
-
-        it "should call the format-specific converter when asked to convert from a given format by mime-type" do
-            @format.expects(:intern).with(FormatTester, "mydata")
-            FormatTester.convert_from("text/myformat", "mydata")
-        end
-
-        it "should call the format-specific converter when asked to convert from a given format by format instance" do
-            @format.expects(:intern).with(FormatTester, "mydata")
-            FormatTester.convert_from(@format, "mydata")
-        end
-
-        it "should raise a FormatError when an exception is encountered when converting from a format" do
-            @format.expects(:intern).with(FormatTester, "mydata").raises "foo"
-            lambda { FormatTester.convert_from(:my_format, "mydata") }.should raise_error(Puppet::Network::FormatHandler::FormatError)
-        end
-
-        it "should be able to use a specific hook for converting into multiple instances" do
-            @format.expects(:intern_multiple).with(FormatTester, "mydata")
-
-            FormatTester.convert_from_multiple(:my_format, "mydata")
-        end
-
-        it "should raise a FormatError when an exception is encountered when converting multiple items from a format" do
-            @format.expects(:intern_multiple).with(FormatTester, "mydata").raises "foo"
-            lambda { FormatTester.convert_from_multiple(:my_format, "mydata") }.should raise_error(Puppet::Network::FormatHandler::FormatError)
-        end
-
-        it "should be able to use a specific hook for rendering multiple instances" do
-            @format.expects(:render_multiple).with("mydata")
-
-            FormatTester.render_multiple(:my_format, "mydata")
-        end
-
-        it "should raise a FormatError when an exception is encountered when rendering multiple items into a format" do
-            @format.expects(:render_multiple).with("mydata").raises "foo"
-            lambda { FormatTester.render_multiple(:my_format, "mydata") }.should raise_error(Puppet::Network::FormatHandler::FormatError)
-        end
-    end
-
-    describe "when managing formats" do
-        it "should have a method for defining a new format" do
-            Puppet::Network::FormatHandler.should respond_to(:create)
-        end
-
-        it "should create a format instance when asked" do
-            format = stub 'format', :name => :foo
-            Puppet::Network::Format.expects(:new).with(:foo).returns format
-            Puppet::Network::FormatHandler.create(:foo)
-        end
-
-        it "should instance_eval any block provided when creating a format" do
-            format = stub 'format', :name => :instance_eval
-            format.expects(:yayness)
-            Puppet::Network::Format.expects(:new).returns format
-            Puppet::Network::FormatHandler.create(:instance_eval) do
-                yayness
-            end
-        end
-
-        it "should be able to retrieve a format by name" do
-            format = Puppet::Network::FormatHandler.create(:by_name)
-            Puppet::Network::FormatHandler.format(:by_name).should equal(format)
-        end
-
-        it "should be able to retrieve formats by name irrespective of case and class" do
-            format = Puppet::Network::FormatHandler.create(:by_name)
-            Puppet::Network::FormatHandler.format(:By_Name).should equal(format)
-        end
-
-        it "should be able to retrieve a format by mime type" do
-            format = Puppet::Network::FormatHandler.create(:by_name, :mime => "foo/bar")
-            Puppet::Network::FormatHandler.mime("foo/bar").should equal(format)
-        end
-
-        it "should be able to retrieve a format by mime type irrespective of case" do
-            format = Puppet::Network::FormatHandler.create(:by_name, :mime => "foo/bar")
-            Puppet::Network::FormatHandler.mime("Foo/Bar").should equal(format)
-        end
-
-        it "should be able to return all formats" do
-            one = stub 'one', :name => :one
-            two = stub 'two', :name => :two
-            Puppet::Network::Format.expects(:new).with(:one).returns(one)
-            Puppet::Network::Format.expects(:new).with(:two).returns(two)
-
-            Puppet::Network::FormatHandler.create(:one)
-            Puppet::Network::FormatHandler.create(:two)
-
-            list = Puppet::Network::FormatHandler.formats
-            list.should be_include(:one)
-            list.should be_include(:two)
-        end
-    end
-
-    describe "when an instance" do
-        it "should be able to test whether a format is supported" do
-            FormatTester.new.should respond_to(:support_format?)
-        end
-
-        it "should be able to convert to a given format" do
-            FormatTester.new.should respond_to(:render)
-        end
-
-        it "should be able to get a format mime-type" do
-            FormatTester.new.should respond_to(:mime)
-        end
-
-        it "should raise a FormatError when a rendering error is encountered" do
-            format = stub 'rendering format', :supported? => true, :name => :foo
-            Puppet::Network::FormatHandler.stubs(:format).with(:foo).returns format
-
-            tester = FormatTester.new
-            format.expects(:render).with(tester).raises "eh"
-
-            lambda { tester.render(:foo) }.should raise_error(Puppet::Network::FormatHandler::FormatError)
-        end
-
-        it "should call the format-specific converter when asked to convert to a given format" do
-            format = stub 'rendering format', :supported? => true, :name => :foo
-
-            Puppet::Network::FormatHandler.stubs(:format).with(:foo).returns format
-
-            tester = FormatTester.new
-            format.expects(:render).with(tester).returns "foo"
-
-            tester.render(:foo).should == "foo"
-        end
-
-        it "should call the format-specific converter when asked to convert to a given format by mime-type" do
-            format = stub 'rendering format', :supported? => true, :name => :foo
-            Puppet::Network::FormatHandler.stubs(:mime).with("text/foo").returns format
-            Puppet::Network::FormatHandler.stubs(:format).with(:foo).returns format
-
-            tester = FormatTester.new
-            format.expects(:render).with(tester).returns "foo"
-
-            tester.render("text/foo").should == "foo"
-        end
-
-        it "should call the format converter when asked to convert to a given format instance" do
-            format = stub 'rendering format', :supported? => true, :name => :foo
-            Puppet::Network::Format.stubs(:===).with(format).returns(true)
-            Puppet::Network::FormatHandler.stubs(:format).with(:foo).returns format
-
-            tester = FormatTester.new
-            format.expects(:render).with(tester).returns "foo"
-
-            tester.render(format).should == "foo"
-        end
-
-        it "should render to the default format if no format is provided when rendering" do
-            format = stub 'rendering format', :supported? => true, :name => :foo
-            Puppet::Network::FormatHandler.stubs(:format).with(:foo).returns format
-
-            FormatTester.expects(:default_format).returns :foo
-            tester = FormatTester.new
-
-            format.expects(:render).with(tester)
-            tester.render
-        end
-
-        it "should call the format-specific converter when asked for the mime-type of a given format" do
-            format = stub 'rendering format', :supported? => true, :name => :foo
-
-            Puppet::Network::FormatHandler.stubs(:format).with(:foo).returns format
-
-            tester = FormatTester.new
-            format.expects(:mime).returns "text/foo"
-
-            tester.mime(:foo).should == "text/foo"
-        end
-
-        it "should return the default format mime-type if no format is provided" do
-            format = stub 'rendering format', :supported? => true, :name => :foo
-            Puppet::Network::FormatHandler.stubs(:format).with(:foo).returns format
-
-            FormatTester.expects(:default_format).returns :foo
-            tester = FormatTester.new
-
-            format.expects(:mime).returns "text/foo"
-            tester.mime.should == "text/foo"
-        end
-    end
-end