Add provider spec tests for common package types, and tidy up test locations

This commit is contained in:
2016-10-12 23:13:05 +01:00
parent 61b3262b7a
commit 9b9e1281f3
5 changed files with 304 additions and 222 deletions

View File

@@ -1,222 +0,0 @@
require 'spec_helper'
require 'puppet/type/entropy_mask'
require 'puppet/type/entropy_unmask'
require 'puppet/type/entropy_splitdebug'
require 'puppet/type/entropy_splitdebug_mask'
types = {
:entropy_mask => Puppet::Type::Entropy_mask,
:entropy_unmask => Puppet::Type::Entropy_unmask,
:entropy_splitdebug => Puppet::Type::Entropy_splitdebug,
:entropy_splitdebug_mask => Puppet::Type::Entropy_splitdebug_mask,
}
default_targets = {
:entropy_mask => '/etc/entropy/packages/package.mask',
:entropy_unmask => '/etc/entropy/packages/package.unmask',
:entropy_splitdebug => '/etc/entropy/packages/package.splitdebug',
:entropy_splitdebug_mask => '/etc/entropy/packages/package.splitdebug.mask',
}
types.each do |type_name, type|
describe Puppet::Type.type(type_name).provider(:parsed) do
before do
described_class.stubs(:filetype).returns(Puppet::Util::FileType::FileTypeRam)
described_class.stubs(:filetype=)
@default_target = described_class.default_target
end
describe "should have a default target of #{default_targets[type_name]}" do
it do
expect(described_class.default_target).to eq(default_targets[type_name])
end
end
describe "when parsing" do
it "should parse out the name" do
line = 'app-admin/foobar ## Puppet Name: foobar'
expect(described_class.parse_line(line)[:name]).to eq('foobar')
end
context "with just a package name" do
line = 'app-admin/foobar ## Puppet Name: foobar'
parsed = described_class.parse_line(line)
it "should parse out the package name" do
expect(parsed[:package]).to eq('app-admin/foobar')
end
it "should have all other parameters undefined" do
[:operator, :version, :slot, :use, :tag, :repo].each do |param|
expect(parsed[param]).to be_nil
end
end
end
context "with a versioned package" do
line = 'app-admin/foobar-1.2.3_alpha1-r1 ## Puppet Name: foobar'
parsed = described_class.parse_line(line)
it "should parse out the package name" do
expect(parsed[:package]).to eq('app-admin/foobar')
end
it "should parse out the version" do
expect(parsed[:version]).to eq('1.2.3_alpha1-r1')
end
it "should have all other parameters undefined" do
[:operator, :slot, :use, :tag, :repo].each do |param|
expect(parsed[param]).to be_nil
end
end
end
context "with a package range" do
line = '>=app-admin/foobar-1.2.3_alpha1-r1 ## Puppet Name: foobar'
parsed = described_class.parse_line(line)
it "should parse out the package name" do
expect(parsed[:package]).to eq('app-admin/foobar')
end
it "should parse out the version" do
expect(parsed[:version]).to eq('1.2.3_alpha1-r1')
end
it "should parse out the operator" do
expect(parsed[:operator]).to eq('>=')
end
it "should have all other parameters undefined" do
[:slot, :use, :tag, :repo].each do |param|
expect(parsed[param]).to be_nil
end
end
end
context "with a slotted package" do
line = 'app-admin/foobar:1.1 ## Puppet Name: foobar'
parsed = described_class.parse_line(line)
it "should parse out the package name" do
expect(parsed[:package]).to eq('app-admin/foobar')
end
it "should parse out the slot" do
expect(parsed[:slot]).to eq('1.1')
end
it "should have all other parameters undefined" do
[:operator, :version, :use, :tag, :repo].each do |param|
expect(parsed[param]).to be_nil
end
end
end
context "with a package with use restrictions" do
line = 'app-admin/foobar[-foo,bar] ## Puppet Name: foobar'
parsed = described_class.parse_line(line)
it "should parse out the package name" do
expect(parsed[:package]).to eq('app-admin/foobar')
end
it "should parse out the use" do
expect(parsed[:use]).to eq('-foo,bar')
end
it "should have all other parameters undefined" do
[:operator, :version, :slot, :tag, :repo].each do |param|
expect(parsed[param]).to be_nil
end
end
end
context "with a tagged package" do
line = 'app-admin/foobar#server ## Puppet Name: foobar'
parsed = described_class.parse_line(line)
it "should parse out the package name" do
expect(parsed[:package]).to eq('app-admin/foobar')
end
it "should parse out the tag" do
expect(parsed[:tag]).to eq('server')
end
it "should have all other parameters undefined" do
[:operator, :version, :slot, :use, :repo].each do |param|
expect(parsed[param]).to be_nil
end
end
end
context "with a package from a specific repo" do
line = 'app-admin/foobar::community ## Puppet Name: foobar'
parsed = described_class.parse_line(line)
it "should parse out the package name" do
expect(parsed[:package]).to eq('app-admin/foobar')
end
it "should parse out the repo" do
expect(parsed[:repo]).to eq('community')
end
it "should have all other parameters undefined" do
[:operator, :version, :slot, :use, :tag].each do |param|
expect(parsed[param]).to be_nil
end
end
end
context "with everything" do
line = '>=app-admin/foobar-1.2.3a_alpha1-r1:1[-foo]#server::community ## Puppet Name: foobar'
parsed = described_class.parse_line(line)
expected = {
:name => 'foobar',
:operator => '>=',
:package => 'app-admin/foobar',
:version => '1.2.3a_alpha1-r1',
:slot => '1',
:use => '-foo',
:tag => 'server',
:repo => 'community',
}
it "should parse out all parameters" do
expected.each do |param, value|
expect(parsed[param]).to eq(value)
end
end
end
end
describe "when flushing" do
before :each do
@ramfile = Puppet::Util::FileType::FileTypeRam.new(@default_target)
File.stubs(:exist?).with(default_targets[type_name]).returns(true)
described_class.any_instance.stubs(:target_object).returns(@ramfile)
resource = type.new(:name => 'test', :package => 'app-admin/foobar')
resource.stubs(:should).with(:target).returns(@default_target)
@providerinstance = described_class.new(resource)
@providerinstance.ensure = :present
#@providerinstance.package = 'app-admin/foobar'
end
after :each do
described_class.clear
end
it "should write an atom name to disk" do
@providerinstance.flush
expect(@ramfile.read.chomp).to eq ('app-admin/foobar ## Puppet Name: test')
end
end
end
end

View File

@@ -0,0 +1,304 @@
require 'spec_helper'
require 'puppet/type/entropy_mask'
require 'puppet/type/entropy_unmask'
require 'puppet/type/entropy_splitdebug'
require 'puppet/type/entropy_splitdebug_mask'
types = {
:entropy_mask => Puppet::Type::Entropy_mask,
:entropy_unmask => Puppet::Type::Entropy_unmask,
:entropy_splitdebug => Puppet::Type::Entropy_splitdebug,
:entropy_splitdebug_mask => Puppet::Type::Entropy_splitdebug_mask,
}
default_targets = {
:entropy_mask => '/etc/entropy/packages/package.mask',
:entropy_unmask => '/etc/entropy/packages/package.unmask',
:entropy_splitdebug => '/etc/entropy/packages/package.splitdebug',
:entropy_splitdebug_mask => '/etc/entropy/packages/package.splitdebug.mask',
}
types.each do |type_name, type|
describe Puppet::Type.type(type_name).provider(:parsed) do
before do
described_class.stubs(:filetype).returns(Puppet::Util::FileType::FileTypeRam)
described_class.stubs(:filetype=)
@default_target = described_class.default_target
end
describe "should have a default target of #{default_targets[type_name]}" do
it do
expect(described_class.default_target).to eq(default_targets[type_name])
end
end
describe 'when parsing' do
it 'should parse out the name' do
line = 'app-admin/foobar ## Puppet Name: foobar'
expect(described_class.parse_line(line)[:name]).to eq('foobar')
end
context 'with just a package name' do
line = 'app-admin/foobar ## Puppet Name: foobar'
parsed = described_class.parse_line(line)
it 'should parse out the package name' do
expect(parsed[:package]).to eq('app-admin/foobar')
end
it 'should have all other parameters undefined' do
[:operator, :version, :slot, :use, :tag, :repo].each do |param|
expect(parsed[param]).to be_nil
end
end
end
context 'with a versioned package' do
line = 'app-admin/foobar-1.2.3_alpha1-r1 ## Puppet Name: foobar'
parsed = described_class.parse_line(line)
it 'should parse out the package name' do
expect(parsed[:package]).to eq('app-admin/foobar')
end
it 'should parse out the version' do
expect(parsed[:version]).to eq('1.2.3_alpha1-r1')
end
it 'should have all other parameters undefined' do
[:operator, :slot, :use, :tag, :repo].each do |param|
expect(parsed[param]).to be_nil
end
end
end
context 'with a package range' do
line = '>=app-admin/foobar-1.2.3_alpha1-r1 ## Puppet Name: foobar'
parsed = described_class.parse_line(line)
it 'should parse out the package name' do
expect(parsed[:package]).to eq('app-admin/foobar')
end
it 'should parse out the version' do
expect(parsed[:version]).to eq('1.2.3_alpha1-r1')
end
it 'should parse out the operator' do
expect(parsed[:operator]).to eq('>=')
end
it 'should have all other parameters undefined' do
[:slot, :use, :tag, :repo].each do |param|
expect(parsed[param]).to be_nil
end
end
end
context 'with a slotted package' do
line = 'app-admin/foobar:1.1 ## Puppet Name: foobar'
parsed = described_class.parse_line(line)
it 'should parse out the package name' do
expect(parsed[:package]).to eq('app-admin/foobar')
end
it 'should parse out the slot' do
expect(parsed[:slot]).to eq('1.1')
end
it 'should have all other parameters undefined' do
[:operator, :version, :use, :tag, :repo].each do |param|
expect(parsed[param]).to be_nil
end
end
end
context 'with a package with use restrictions' do
line = 'app-admin/foobar[-foo,bar] ## Puppet Name: foobar'
parsed = described_class.parse_line(line)
it 'should parse out the package name' do
expect(parsed[:package]).to eq('app-admin/foobar')
end
it 'should parse out the use' do
expect(parsed[:use]).to eq('-foo,bar')
end
it 'should have all other parameters undefined' do
[:operator, :version, :slot, :tag, :repo].each do |param|
expect(parsed[param]).to be_nil
end
end
end
context 'with a tagged package' do
line = 'app-admin/foobar#server ## Puppet Name: foobar'
parsed = described_class.parse_line(line)
it 'should parse out the package name' do
expect(parsed[:package]).to eq('app-admin/foobar')
end
it 'should parse out the tag' do
expect(parsed[:tag]).to eq('server')
end
it 'should have all other parameters undefined' do
[:operator, :version, :slot, :use, :repo].each do |param|
expect(parsed[param]).to be_nil
end
end
end
context 'with a package from a specific repo' do
line = 'app-admin/foobar::community ## Puppet Name: foobar'
parsed = described_class.parse_line(line)
it 'should parse out the package name' do
expect(parsed[:package]).to eq('app-admin/foobar')
end
it 'should parse out the repo' do
expect(parsed[:repo]).to eq('community')
end
it 'should have all other parameters undefined' do
[:operator, :version, :slot, :use, :tag].each do |param|
expect(parsed[param]).to be_nil
end
end
end
context 'with everything' do
line = '>=app-admin/foobar-1.2.3a_alpha1-r1:1[-foo]#server::community ## Puppet Name: foobar'
parsed = described_class.parse_line(line)
expected = {
:name => 'foobar',
:operator => '>=',
:package => 'app-admin/foobar',
:version => '1.2.3a_alpha1-r1',
:slot => '1',
:use => '-foo',
:tag => 'server',
:repo => 'community',
}
it 'should parse out all parameters' do
expected.each do |param, value|
expect(parsed[param]).to eq(value)
end
end
end
end
describe 'when flushing' do
before :each do
@ramfile = Puppet::Util::FileType::FileTypeRam.new(@default_target)
File.stubs(:exist?).with(default_targets[type_name]).returns(true)
described_class.any_instance.stubs(:target_object).returns(@ramfile)
end
after :each do
described_class.clear
end
it 'should output a single package entry' do
resource = {
:record_type => :parsed,
:name => 'test',
:package => 'app-admin/foobar',
}
expect(described_class.to_line(resource)).to eq ('app-admin/foobar ## Puppet Name: test')
end
it 'should output a versioned package entry' do
resource = {
:record_type => :parsed,
:name => 'test',
:package => 'app-admin/foobar',
:version => '1.2.3',
}
expect(described_class.to_line(resource)).to eq ('app-admin/foobar-1.2.3 ## Puppet Name: test')
end
it 'should output a ranged versioned package entry' do
resource = {
:record_type => :parsed,
:name => 'test',
:package => 'app-admin/foobar',
:version => '1.2.3',
:operator => '>=',
}
expect(described_class.to_line(resource)).to eq ('>=app-admin/foobar-1.2.3 ## Puppet Name: test')
end
it 'should output a use-restricted package entry' do
resource = {
:record_type => :parsed,
:name => 'test',
:package => 'app-admin/foobar',
:use => '-foo,bar',
}
expect(described_class.to_line(resource)).to eq ('app-admin/foobar[-foo,bar] ## Puppet Name: test')
end
it 'should output a slotted package entry' do
resource = {
:record_type => :parsed,
:name => 'test',
:package => 'app-admin/foobar',
:slot => '1.1',
}
expect(described_class.to_line(resource)).to eq ('app-admin/foobar:1.1 ## Puppet Name: test')
end
it 'should output a tagged package entry' do
resource = {
:record_type => :parsed,
:name => 'test',
:package => 'app-admin/foobar',
:tag => 'server',
}
expect(described_class.to_line(resource)).to eq ('app-admin/foobar#server ## Puppet Name: test')
end
it 'should output a repo-specific package entry' do
resource = {
:record_type => :parsed,
:name => 'test',
:package => 'app-admin/foobar',
:repo => 'community',
}
expect(described_class.to_line(resource)).to eq ('app-admin/foobar::community ## Puppet Name: test')
end
it 'should output a whole-repo entry' do
resource = {
:record_type => :parsed,
:name => 'test',
:repo => 'community',
}
expect(described_class.to_line(resource)).to eq ('::community ## Puppet Name: test')
end
it 'should output all fields for a package entry' do
resource = {
:record_type => :parsed,
:name => 'test',
:package => 'app-admin/foobar',
:operator => '>=',
:version => '1.2.3',
:slot => '1.1',
:use => '-foo,bar',
:tag => 'server',
:repo => 'community',
}
expect(described_class.to_line(resource)).to eq ('>=app-admin/foobar-1.2.3:1.1[-foo,bar]#server::community ## Puppet Name: test')
end
end
end
end

View File

@@ -0,0 +1,25 @@
describe Puppet::Type.type(:enman_repo) do
before do
@provider = stub 'provider'
@provider.stubs(:name).returns(:enman)
described_class.stubs(:defaultprovider).returns(@provider)
end
it "should be an instance of Puppet::Type::Enman_repo" do
expect(described_class.new(:name => "test")).to be_an_instance_of Puppet::Type::Enman_repo
end
describe "when validating attributes" do
params = [:name]
params.each do |param|
it "should have the #{param} param" do
expect(described_class.attrtype(param)).to eq :param
end
end
end
it "should have name as the namevar" do
expect(described_class.key_attributes).to eq [:name]
end
end

View File

@@ -0,0 +1,77 @@
describe Puppet::Type.type(:entropy_keywords) do
before do
@provider = stub 'provider'
@provider.stubs(:name).returns(:parsed)
@provider.stubs(:ancestors).returns([Puppet::Provider::ParsedFile])
@provider.stubs(:default_target).returns("defaulttarget")
described_class.stubs(:defaultprovider).returns(@provider)
end
it "should be an instance of Puppet::Type::Entropy_keywords" do
expect(described_class.new(:name => "test", :package => "app-admin/dummy")).to be_an_instance_of Puppet::Type::Entropy_keywords
end
describe "when validating attributes" do
params = [:name]
properties = [:package, :operator, :version, :repo, :target]
params.each do |param|
it "should have the #{param} param" do
expect(described_class.attrtype(param)).to eq :param
end
end
properties.each do |property|
it "should have the #{property} property" do
expect(described_class.attrtype(property)).to eq :property
end
end
end
it "should have name as the namevar" do
expect(described_class.key_attributes).to eq [:name]
end
describe "when validating the target property" do
it "should default to the provider's default target" do
expect(described_class.new(:name => "test", :package => "app-admin/dummy").should(:target)).to eq "defaulttarget"
end
end
describe "when validating required properties" do
it "should raise an error when no required attributes are passed" do
expect {
described_class.new(:name => "test")
}.to raise_error(Puppet::Error, /At least one of (.*) is required/)
end
it "should raise an error when a version is passed with no package" do
expect {
described_class.new(:name => "test", :repo => "test", :version => "1.2.3")
}.to raise_error(Puppet::Error, /Package is required/)
end
it "should raise an error when an operator is passed with no version" do
expect {
described_class.new(:name => "test", :package => "app-admin/dummy", :operator => "<=")
}.to raise_error(Puppet::Error, /Version is required/)
end
end
describe "when the catalog includes a matching package" do
it "should have an autobefore relationship" do
resource = described_class.new(:name => "test", :package => "app-admin/dummy")
package = Puppet::Type.type(:package).new(:title => 'app-admin/dummy')
catalog = Puppet::Resource::Catalog.new
catalog.add_resource package
catalog.add_resource resource
befores = resource.autobefore
expect(befores.size).to eq 1
expect(befores[0].source).to eq resource
expect(befores[0].target).to eq package
end
end
end

View File

@@ -0,0 +1,94 @@
require 'spec_helper'
require 'puppet/type/entropy_mask'
require 'puppet/type/entropy_unmask'
require 'puppet/type/entropy_splitdebug'
require 'puppet/type/entropy_splitdebug_mask'
types = {
:entropy_mask => Puppet::Type::Entropy_mask,
:entropy_unmask => Puppet::Type::Entropy_unmask,
:entropy_splitdebug => Puppet::Type::Entropy_splitdebug,
:entropy_splitdebug_mask => Puppet::Type::Entropy_splitdebug_mask,
}
types.each do |type_name, type|
describe Puppet::Type.type(type_name) do
before do
@provider = stub 'provider'
@provider.stubs(:name).returns(:parsed)
@provider.stubs(:ancestors).returns([Puppet::Provider::ParsedFile])
@provider.stubs(:default_target).returns("defaulttarget")
described_class.stubs(:defaultprovider).returns(@provider)
end
it "should be an instance of #{type.class.name}" do
expect(described_class.new(:name => "test", :package => "app-admin/dummy")).to be_an_instance_of type
end
describe "when validating attributes" do
params = [:name]
properties = [:package, :operator, :version, :slot, :use, :tag, :repo, :target]
params.each do |param|
it "should have the #{param} param" do
expect(described_class.attrtype(param)).to eq :param
end
end
properties.each do |property|
it "should have the #{property} property" do
expect(described_class.attrtype(property)).to eq :property
end
end
end
it "should have name as the namevar" do
expect(described_class.key_attributes).to eq [:name]
end
describe "when validating the target property" do
it "should default to the provider's default target" do
expect(described_class.new(:name => "test", :package => "app-admin/dummy").should(:target)).to eq "defaulttarget"
end
end
describe "when validating required properties" do
it "should raise an error when no required attributes are passed" do
expect {
described_class.new(:name => "test")
}.to raise_error(Puppet::Error, /At least one of (.*) is required/)
end
it "should raise an error when a version is passed with no package" do
expect {
described_class.new(:name => "test", :repo => "test", :version => "1.2.3")
}.to raise_error(Puppet::Error, /Package is required/)
end
it "should raise an error when an operator is passed with no version" do
expect {
described_class.new(:name => "test", :package => "app-admin/dummy", :operator => "<=")
}.to raise_error(Puppet::Error, /Version is required/)
end
end
describe "when the catalog includes a matching package" do
it "should have an autobefore relationship" do
resource = described_class.new(:name => "test", :package => "app-admin/dummy")
package = Puppet::Type.type(:package).new(:title => 'app-admin/dummy')
catalog = Puppet::Resource::Catalog.new
catalog.add_resource package
catalog.add_resource resource
befores = resource.autobefore
expect(befores.size).to eq 1
expect(befores[0].source).to eq resource
expect(befores[0].target).to eq package
end
end
end
end
# vim: set ts=2 sw=2 expandtab: