puppet 2.7.26 → 3.0.0.rc4

data/spec/unit/network/rest_authconfig_spec.rb

@@ -1,142 +0,0 @@
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-require 'puppet/network/rest_authconfig'
-
-describe Puppet::Network::RestAuthConfig do
-
-  DEFAULT_ACL = Puppet::Network::RestAuthConfig::DEFAULT_ACL
-
-  before :each do
-    FileTest.stubs(:exists?).returns(true)
-    File.stubs(:stat).returns(stub('stat', :ctime => :now))
-    Time.stubs(:now).returns Time.now
-
-    @authconfig = Puppet::Network::RestAuthConfig.new("dummy", false)
-    @authconfig.stubs(:read)
-
-    @acl = stub_everything 'rights'
-    @authconfig.rights = @acl
-  end
-
-  it "should use the puppet default rest authorization file" do
-    Puppet.expects(:[]).with(:rest_authconfig).returns("dummy")
-
-    Puppet::Network::RestAuthConfig.new(nil, false)
-  end
-
-  it "should ask for authorization to the ACL subsystem" do
-    params = {:ip => "127.0.0.1", :node => "me", :environment => :env, :authenticated => true}
-    @acl.expects(:is_request_forbidden_and_why?).with("path", :save, "to/resource", params).returns(nil)
-
-    @authconfig.check_authorization("path", :save, "to/resource", params)
-  end
-
-  describe "when defining an acl with mk_acl" do
-    it "should create a new right for each default acl" do
-      @acl.expects(:newright).with(:path)
-      @authconfig.mk_acl(:acl => :path)
-    end
-
-    it "should allow everyone for each default right" do
-      @acl.expects(:allow).with(:path, "*")
-      @authconfig.mk_acl(:acl => :path)
-    end
-
-    it "should restrict the ACL to a method" do
-      @acl.expects(:restrict_method).with(:path, :method)
-      @authconfig.mk_acl(:acl => :path, :method => :method)
-    end
-
-    it "should restrict the ACL to a specific authentication state" do
-      @acl.expects(:restrict_authenticated).with(:path, :authentication)
-      @authconfig.mk_acl(:acl => :path, :authenticated => :authentication)
-    end
-  end
-
-  describe "when parsing the configuration file" do
-    it "should check for missing ACL after reading the authconfig file" do
-      File.stubs(:open)
-
-      @authconfig.expects(:insert_default_acl)
-
-      @authconfig.parse
-    end
-  end
-
-  DEFAULT_ACL.each do |acl|
-    it "should insert #{acl[:acl]} if not present" do
-      @authconfig.rights.stubs(:[]).returns(true)
-      @authconfig.rights.stubs(:[]).with(acl[:acl]).returns(nil)
-
-      @authconfig.expects(:mk_acl).with { |h| h[:acl] == acl[:acl] }
-
-      @authconfig.insert_default_acl
-    end
-
-    it "should not insert #{acl[:acl]} if present" do
-      @authconfig.rights.stubs(:[]).returns(true)
-      @authconfig.rights.stubs(:[]).with(acl).returns(true)
-
-      @authconfig.expects(:mk_acl).never
-
-      @authconfig.insert_default_acl
-    end
-  end
-
-  it "should create default ACL entries if no file have been read" do
-    # The singleton instance is stored as an instance variable we don't have
-    # access to, so.. instance_variable_set. Alas.
-    Puppet::Network::RestAuthConfig.instance_variable_set(:@main, nil)
-    Puppet::Network::RestAuthConfig.any_instance.stubs(:exists?).returns(false)
-
-    Puppet::Network::RestAuthConfig.any_instance.expects(:insert_default_acl)
-
-    Puppet::Network::RestAuthConfig.main
-  end
-
-  describe "when adding default ACLs" do
-
-    DEFAULT_ACL.each do |acl|
-      it "should create a default right for #{acl[:acl]}" do
-        @authconfig.stubs(:mk_acl)
-        @authconfig.expects(:mk_acl).with(acl)
-        @authconfig.insert_default_acl
-      end
-    end
-
-    it "should log at info loglevel" do
-      Puppet.expects(:info).at_least_once
-      @authconfig.insert_default_acl
-    end
-
-    it "should create a last catch-all deny all rule" do
-      @authconfig.stubs(:mk_acl)
-      @acl.expects(:newright).with("/")
-      @authconfig.insert_default_acl
-    end
-
-    it "should create a last catch-all deny all rule for any authenticated request state" do
-      @authconfig.stubs(:mk_acl)
-      @acl.stubs(:newright).with("/")
-
-      @acl.expects(:restrict_authenticated).with("/", :any)
-
-      @authconfig.insert_default_acl
-    end
-
-    it '(CVE-2013-2275) allows report submission only for the node matching the certname by default' do
-      acl = {
-        :acl => "~ ^\/report\/([^\/]+)$",
-        :method => :save,
-        :allow => '$1',
-        :authenticated => true
-      }
-      @authconfig.rights.stubs(:[]).returns(true)
-      @authconfig.rights.stubs(:[]).with(acl[:acl]).returns(nil)
-
-      @authconfig.expects(:mk_acl).with(acl)
-      @authconfig.insert_default_acl
-    end
-  end
-end

data/spec/unit/other/transbucket_spec.rb

@@ -1,184 +0,0 @@
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-describe Puppet::TransBucket do
-  before do
-    @bucket = Puppet::TransBucket.new
-  end
-
-  it "should be able to produce a RAL component" do
-    @bucket.name = "luke"
-    @bucket.type = "foo"
-
-    resource = nil
-    proc { resource = @bucket.to_ral }.should_not raise_error
-    resource.must be_instance_of(Puppet::Type::Component)
-    resource.title.should == "Foo[luke]"
-  end
-
-  it "should accept TransObjects into its children list" do
-    object = Puppet::TransObject.new("luke", "user")
-    proc { @bucket.push(object) }.should_not raise_error
-    @bucket.each do |o|
-      o.should equal(object)
-    end
-  end
-
-  it "should accept TransBuckets into its children list" do
-    object = Puppet::TransBucket.new
-    proc { @bucket.push(object) }.should_not raise_error
-    @bucket.each do |o|
-      o.should equal(object)
-    end
-  end
-
-  it "should refuse to accept any children that are not TransObjects or TransBuckets" do
-    proc { @bucket.push "a test" }.should raise_error
-  end
-
-  it "should return use 'node' as the type and the provided name as the title if only a type is provided" do
-    @bucket.type = "mystuff"
-    @bucket.to_ref.should == "Node[mystuff]"
-  end
-
-  it "should return use 'component' as the type and the provided type as the title if only a name is provided" do
-    @bucket.name = "mystuff"
-    @bucket.to_ref.should == "Class[Mystuff]"
-  end
-
-  it "should return nil as its reference when type and name are missing" do
-    @bucket.to_ref.should be_nil
-  end
-
-  it "should return the title as its reference" do
-    @bucket.name = "luke"
-    @bucket.type = "user"
-    @bucket.to_ref.should == "User[luke]"
-  end
-
-  it "should canonize resource references when the type is 'component'" do
-    @bucket.name = 'something'
-    @bucket.type = 'foo::bar'
-
-    @bucket.to_ref.should == "Foo::Bar[something]"
-  end
-end
-
-describe Puppet::TransBucket, " when generating a catalog" do
-  before do
-    @bottom = Puppet::TransBucket.new
-    @bottom.type = "fake"
-    @bottom.name = "bottom"
-    @bottomobj = Puppet::TransObject.new("bottom", "notify")
-    @bottom.push @bottomobj
-
-    @middle = Puppet::TransBucket.new
-    @middle.type = "fake"
-    @middle.name = "middle"
-    @middleobj = Puppet::TransObject.new("middle", "notify")
-    @middle.push(@middleobj)
-    @middle.push(@bottom)
-
-    @top = Puppet::TransBucket.new
-    @top.type = "fake"
-    @top.name = "top"
-    @topobj = Puppet::TransObject.new("top", "notify")
-    @top.push(@topobj)
-    @top.push(@middle)
-
-    @users = %w{top middle bottom}
-    @fakes = %w{Fake[bottom] Fake[middle] Fake[top]}
-  end
-
-  it "should convert all transportable objects to RAL resources" do
-    @catalog = @top.to_catalog
-    @users.each do |name|
-      @catalog.vertices.find { |r| r.class.name == :notify and r.title == name }.must be_instance_of(Puppet::Type.type(:notify))
-    end
-  end
-
-  it "should fail if any transportable resources fail to convert to RAL resources" do
-    @bottomobj.expects(:to_ral).raises ArgumentError
-    lambda { @bottom.to_catalog }.should raise_error(ArgumentError)
-  end
-
-  it "should convert all transportable buckets to RAL components" do
-    @catalog = @top.to_catalog
-    @fakes.each do |name|
-      @catalog.vertices.find { |r| r.class.name == :component and r.title == name }.must be_instance_of(Puppet::Type.type(:component))
-    end
-  end
-
-  it "should add all resources to the graph's resource table" do
-    @catalog = @top.to_catalog
-    @fakes.each do |name|
-      @catalog.resource(name).must be
-    end
-  end
-
-  it "should only call to_ral on each resource once" do
-    # We just raise exceptions here because we're not interested in
-    # what happens with the result, only that the method only
-    # gets called once.
-    resource = @topobj.to_ral
-    @topobj.expects(:to_ral).once.returns resource
-    @top.to_catalog
-  end
-
-  it "should set each TransObject's catalog before converting to a RAL resource" do
-    @middleobj.expects(:catalog=).with { |c| c.is_a?(Puppet::Resource::Catalog) }
-    @top.to_catalog
-  end
-
-  it "should set each TransBucket's catalog before converting to a RAL resource" do
-    # each bucket is seen twice in the loop, so we have to handle the case where the config
-    # is set twice
-    @bottom.expects(:catalog=).with { |c| c.is_a?(Puppet::Resource::Catalog) }.at_least_once
-    @top.to_catalog
-  end
-end
-
-describe Puppet::TransBucket, " when serializing" do
-  before do
-    @bucket = Puppet::TransBucket.new(%w{one two})
-    @bucket.name = "one"
-    @bucket.type = "two"
-  end
-
-  it "should be able to be dumped to yaml" do
-    proc { YAML.dump(@bucket) }.should_not raise_error
-  end
-
-  it "should dump YAML that produces an equivalent object" do
-    result = YAML.dump(@bucket)
-
-    newobj = YAML.load(result)
-    newobj.name.should == "one"
-    newobj.type.should == "two"
-    children = []
-    newobj.each do |o|
-      children << o
-    end
-    children.should == %w{one two}
-  end
-end
-
-describe Puppet::TransBucket, " when converting to a Puppet::Resource" do
-  before do
-    @trans = Puppet::TransBucket.new
-    @trans.name = "foo"
-    @trans.type = "bar"
-    @trans.param(:noop, true)
-  end
-
-  it "should create a resource with the correct type and title" do
-    result = @trans.to_resource
-    result.type.should == "Bar"
-    result.title.should == "foo"
-  end
-
-  it "should add all of its parameters to the created resource" do
-    @trans.param(:noop, true)
-    @trans.to_resource[:noop].should be_true
-  end
-end

data/spec/unit/other/transobject_spec.rb

@@ -1,111 +0,0 @@
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-require 'puppet/transportable'
-
-describe Puppet::TransObject do
-  it "should canonize resource references" do
-    resource = Puppet::TransObject.new("me", "foo::bar")
-    resource.ref.should == 'Foo::Bar[me]'
-  end
-
-  it "should lower-case resource types for backward compatibility with 0.23.2" do
-    resource = Puppet::TransObject.new("me", "Foo")
-    resource.type.should == 'foo'
-  end
-end
-
-describe Puppet::TransObject, " when serializing" do
-  before do
-    @resource = Puppet::TransObject.new("/my/file", "file")
-    @resource["one"] = "test"
-    @resource["two"] = "other"
-  end
-
-  it "should be able to be dumped to yaml" do
-    proc { YAML.dump(@resource) }.should_not raise_error
-  end
-
-  it "should produce an equivalent yaml object" do
-    text = YAML.dump(@resource)
-
-    newresource = YAML.load(text)
-    newresource.name.should == "/my/file"
-    newresource.type.should == "file"
-    %w{one two}.each do |param|
-      newresource[param].should == @resource[param]
-    end
-  end
-end
-
-describe Puppet::TransObject, " when converting to a Puppet::Resource" do
-  before do
-    @trans = Puppet::TransObject.new("/my/file", "file")
-    @trans["one"] = "test"
-    @trans["two"] = "other"
-  end
-
-  it "should create a resource with the correct type and title" do
-    result = @trans.to_resource
-    result.type.should == "File"
-    result.title.should == "/my/file"
-  end
-
-  it "should add all of its parameters to the created resource" do
-    @trans[:noop] = true
-    @trans.to_resource[:noop].should be_true
-  end
-
-  it "should copy over the tags" do
-    @trans.tags = %w{foo bar}
-    result = @trans.to_resource
-    result.should be_tagged("foo")
-    result.should be_tagged("bar")
-  end
-end
-
-describe Puppet::TransObject, " when converting to a RAL resource" do
-  before do
-    @resource = Puppet::TransObject.new("/my/file", "file")
-    @resource["one"] = "test"
-    @resource["two"] = "other"
-  end
-
-  it "should use a Puppet::Resource to create the resource" do
-    resource = mock 'resource'
-    @resource.expects(:to_resource).returns resource
-    resource.expects(:to_ral).returns "myral"
-    @resource.to_ral.should == "myral"
-  end
-end
-
-describe Puppet::TransObject, " when converting to a RAL component instance" do
-  before do
-    @resource = Puppet::TransObject.new("/my/file", "one::two")
-    @resource["one"] = "test"
-    @resource["noop"] = "other"
-  end
-
-  it "should use a new TransObject whose name is a resource reference of the type and title of the original TransObject" do
-    Puppet::Type::Component.expects(:new).with { |resource| resource.type == "component" and resource.name == "One::Two[/my/file]" }.returns(:yay)
-    @resource.to_component.should == :yay
-  end
-
-  it "should pass the resource parameters on to the newly created TransObject" do
-    Puppet::Type::Component.expects(:new).with { |resource| resource["noop"] == "other" }.returns(:yay)
-    @resource.to_component.should == :yay
-  end
-
-  it "should copy over the catalog" do
-    @resource.catalog = "mycat"
-    Puppet::Type::Component.expects(:new).with { |resource| resource.catalog == "mycat" }.returns(:yay)
-    @resource.to_component
-  end
-
-  # LAK:FIXME This really isn't the design we want going forward, but it's
-  # good enough for now.
-  it "should not pass resource parameters that are not metaparams" do
-    Puppet::Type::Component.expects(:new).with { |resource| resource["one"].nil? }.returns(:yay)
-    @resource.to_component.should == :yay
-  end
-end

data/spec/unit/provider/zfs/solaris_spec.rb

@@ -1,99 +0,0 @@
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-provider_class = Puppet::Type.type(:zfs).provider(:solaris)
-
-describe provider_class do
-  before do
-    @resource = stub("resource", :name => "myzfs")
-    @resource.stubs(:[]).with(:name).returns "myzfs"
-    @resource.stubs(:[]).returns "shouldvalue"
-    @provider = provider_class.new(@resource)
-  end
-
-  it "should have a create method" do
-    @provider.should respond_to(:create)
-  end
-
-  it "should have a destroy method" do
-    @provider.should respond_to(:destroy)
-  end
-
-  it "should have an exists? method" do
-    @provider.should respond_to(:exists?)
-  end
-
-  describe "when calling add_properties" do
-    it "should add -o and the key=value for each properties with a value" do
-      @resource.stubs(:[]).with(:quota).returns ""
-      @resource.stubs(:[]).with(:refquota).returns ""
-      @resource.stubs(:[]).with(:mountpoint).returns "/foo"
-      properties = @provider.add_properties
-      properties.include?("-o").should == true
-      properties.include?("mountpoint=/foo").should == true
-      properties.detect { |a| a.include?("quota") }.should == nil
-    end
-  end
-
-  describe "when calling create" do
-    it "should call add_properties" do
-      @provider.stubs(:zfs)
-      @provider.expects(:add_properties).returns([])
-      @provider.create
-    end
-
-    it "should call zfs with create, properties and this zfs" do
-      @provider.stubs(:add_properties).returns(%w{a b})
-      @provider.expects(:zfs).with(:create, "a", "b", @resource[:name])
-      @provider.create
-    end
-  end
-
-  describe "when calling destroy" do
-    it "should call zfs with :destroy and this zfs" do
-      @provider.expects(:zfs).with(:destroy, @resource[:name])
-      @provider.destroy
-    end
-  end
-
-  describe "when calling exist?" do
-    it "should call zfs with :list" do
-      #return stuff because we have to slice and dice it
-      @provider.expects(:zfs).with(:list).returns("NAME USED AVAIL REFER MOUNTPOINT\nmyzfs 100K 27.4M /myzfs")
-      @provider.exists?
-    end
-
-    it "should return true if returned values match the name" do
-      @provider.stubs(:zfs).with(:list).returns("NAME USED AVAIL REFER MOUNTPOINT\n#{@resource[:name]} 100K 27.4M /myzfs")
-      @provider.exists?.should == true
-    end
-
-    it "should return false if returned values don't match the name" do
-      @provider.stubs(:zfs).with(:list).returns("no soup for you")
-      @provider.exists?.should == false
-    end
-
-  end
-
-  [:mountpoint, :recordsize, :aclmode, :aclinherit, :primarycache, :secondarycache, :compression, :copies, :quota, :reservation, :sharenfs, :snapdir].each do |prop|
-    describe "when getting the #{prop} value" do
-      it "should call zfs with :get, #{prop} and this zfs" do
-        @provider.expects(:zfs).with(:get, "-H", "-o", "value", prop, @resource[:name]).returns("value\n")
-        @provider.send(prop)
-      end
-
-      it "should get the third value of the second line from the output" do
-        @provider.stubs(:zfs).with(:get, "-H", "-o", "value", prop, @resource[:name]).returns("value\n")
-        @provider.send(prop).should == "value"
-      end
-    end
-
-    describe "when setting the #{prop} value" do
-      it "should call zfs with :set, #{prop}=value and this zfs" do
-        @provider.expects(:zfs).with(:set, "#{prop}=value", @resource[:name])
-        @provider.send("#{prop}=".intern, "value")
-      end
-    end
-  end
-
-end