ben/puppet-sabayon
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Autocorrect PDK validation warnings

Browse Source
This commit is contained in:
Ben Roberts
2019-05-09 23:41:09 +01:00
parent 998f1716f3
commit 939f795d37
26 changed files with 537 additions and 584 deletions
Download Patch File Download Diff File Expand all files Collapse all files

145
spec/unit/provider/entropy_keywords/parsed_spec.rb
View File

@@ -1,7 +1,7 @@
require 'spec_helper'
describe Puppet::Type.type(:entropy_keywords).provider(:parsed) do
before do
before(:each) do
described_class.stubs(:filetype).returns(Puppet::Util::FileType::FileTypeRam)
described_class.stubs(:filetype=)
@default_target = described_class.default_target
@@ -14,7 +14,7 @@ describe Puppet::Type.type(:entropy_keywords).provider(:parsed) do
end
describe 'when parsing' do
it 'should parse out the name' do
it 'parses out the name' do
line = '** app-admin/foobar ## Puppet Name: foobar'
expect(described_class.parse_line(line)[:name]).to eq('foobar')
end
@@ -23,15 +23,15 @@ describe Puppet::Type.type(:entropy_keywords).provider(:parsed) do
line = '** app-admin/foobar ## Puppet Name: foobar'
parsed = described_class.parse_line(line)
it 'should parse out the keyword' do
it 'parses out the keyword' do
expect(parsed[:keyword]).to eq('**')
end
it 'should parse out the package name' do
it 'parses out the package name' do
expect(parsed[:package]).to eq('app-admin/foobar')
end
it 'should have all other parameters undefined' do
it 'has all other parameters undefined' do
[:operator, :version, :repo].each do |param|
expect(parsed[param]).to be_nil
end
@@ -42,19 +42,19 @@ describe Puppet::Type.type(:entropy_keywords).provider(:parsed) do
line = '** app-admin/foobar-1.2.3_alpha1-r1 ## Puppet Name: foobar'
parsed = described_class.parse_line(line)
it 'should parse out the keyword' do
it 'parses out the keyword' do
expect(parsed[:keyword]).to eq('**')
end
it 'should parse out the package name' do
it 'parses out the package name' do
expect(parsed[:package]).to eq('app-admin/foobar')
end
it 'should parse out the version' do
it 'parses out the version' do
expect(parsed[:version]).to eq('1.2.3_alpha1-r1')
end
it 'should have all other parameters undefined' do
it 'has all other parameters undefined' do
[:operator, :repo].each do |param|
expect(parsed[param]).to be_nil
end
@@ -65,23 +65,23 @@ describe Puppet::Type.type(:entropy_keywords).provider(:parsed) do
line = '** >=app-admin/foobar-1.2.3_alpha1-r1 ## Puppet Name: foobar'
parsed = described_class.parse_line(line)
it 'should parse out the keyword' do
it 'parses out the keyword' do
expect(parsed[:keyword]).to eq('**')
end
it 'should parse out the package name' do
it 'parses out the package name' do
expect(parsed[:package]).to eq('app-admin/foobar')
end
it 'should parse out the version' do
it 'parses out the version' do
expect(parsed[:version]).to eq('1.2.3_alpha1-r1')
end
it 'should parse out the operator' do
it 'parses out the operator' do
expect(parsed[:operator]).to eq('>=')
end
it 'should have all other parameters undefined' do
it 'has all other parameters undefined' do
[:repo].each do |param|
expect(parsed[param]).to be_nil
end
@@ -92,19 +92,19 @@ describe Puppet::Type.type(:entropy_keywords).provider(:parsed) do
line = '** app-admin/foobar repo=community ## Puppet Name: foobar'
parsed = described_class.parse_line(line)
it 'should parse out the keyword' do
it 'parses out the keyword' do
expect(parsed[:keyword]).to eq('**')
end
it 'should parse out the package name' do
it 'parses out the package name' do
expect(parsed[:package]).to eq('app-admin/foobar')
end
it 'should parse out the repo' do
it 'parses out the repo' do
expect(parsed[:repo]).to eq('community')
end
it 'should have all other parameters undefined' do
it 'has all other parameters undefined' do
[:operator, :version].each do |param|
expect(parsed[param]).to be_nil
end
@@ -115,15 +115,15 @@ describe Puppet::Type.type(:entropy_keywords).provider(:parsed) do
line = 'amd64 repo=community ## Puppet Name: foobar'
parsed = described_class.parse_line(line)
it 'should parse out the keyword' do
it 'parses out the keyword' do
expect(parsed[:keyword]).to eq('amd64')
end
it 'should parse out the repo' do
it 'parses out the repo' do
expect(parsed[:repo]).to eq('community')
end
it 'should have all other parameters undefined' do
it 'has all other parameters undefined' do
[:package, :operator, :version].each do |param|
expect(parsed[param]).to be_nil
end
@@ -135,24 +135,23 @@ describe Puppet::Type.type(:entropy_keywords).provider(:parsed) do
parsed = described_class.parse_line(line)
expected = {
:name => 'foobar',
:keyword => '**',
:package => 'app-admin/foobar',
:operator => '>=',
:version => '1.2.3a_alpha1-r1',
:repo => 'community',
name: 'foobar',
keyword: '**',
package: 'app-admin/foobar',
operator: '>=',
version: '1.2.3a_alpha1-r1',
repo: 'community',
}
it 'should parse out all parameters' do
it 'parses out all parameters' do
expected.each do |param, value|
expect(parsed[param]).to eq(value)
end
end
end
end
describe 'when flushing' do
describe 'when flushing' do
before :each do
@ramfile = Puppet::Util::FileType::FileTypeRam.new(@default_target)
File.stubs(:exist?).with(@default_target).returns(true)
@@ -163,71 +162,71 @@ describe Puppet::Type.type(:entropy_keywords).provider(:parsed) do
described_class.clear
end
it 'should output a single package entry' do
it 'outputs a single package entry' do
resource = {
:record_type => :parsed,
:name => 'test',
:keyword => '**',
:package => 'app-admin/foobar',
record_type: :parsed,
name: 'test',
keyword: '**',
package: 'app-admin/foobar',
}
expect(described_class.to_line(resource)).to eq ('** app-admin/foobar ## Puppet Name: test')
expect(described_class.to_line(resource)).to eq '** app-admin/foobar ## Puppet Name: test'
end
it 'should output a versioned package entry' do
it 'outputs a versioned package entry' do
resource = {
:record_type => :parsed,
:name => 'test',
:keyword => '**',
:package => 'app-admin/foobar',
:version => '1.2.3',
record_type: :parsed,
name: 'test',
keyword: '**',
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')
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
it 'outputs a ranged versioned package entry' do
resource = {
:record_type => :parsed,
:name => 'test',
:keyword => '**',
:package => 'app-admin/foobar',
:version => '1.2.3',
:operator => '>=',
record_type: :parsed,
name: 'test',
keyword: '**',
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')
expect(described_class.to_line(resource)).to eq '** >=app-admin/foobar-1.2.3 ## Puppet Name: test'
end
it 'should output a repo-specific package entry' do
it 'outputs a repo-specific package entry' do
resource = {
:record_type => :parsed,
:name => 'test',
:keyword => '**',
:package => 'app-admin/foobar',
:repo => 'community',
record_type: :parsed,
name: 'test',
keyword: '**',
package: 'app-admin/foobar',
repo: 'community',
}
expect(described_class.to_line(resource)).to eq ('** app-admin/foobar repo=community ## Puppet Name: test')
expect(described_class.to_line(resource)).to eq '** app-admin/foobar repo=community ## Puppet Name: test'
end
it 'should output a whole-repo entry' do
it 'outputs a whole-repo entry' do
resource = {
:record_type => :parsed,
:name => 'test',
:keyword => '**',
:repo => 'community',
record_type: :parsed,
name: 'test',
keyword: '**',
repo: 'community',
}
expect(described_class.to_line(resource)).to eq ('** repo=community ## Puppet Name: test')
expect(described_class.to_line(resource)).to eq '** repo=community ## Puppet Name: test'
end
it 'should output all fields for a package entry' do
it 'outputs all fields for a package entry' do
resource = {
:record_type => :parsed,
:name => 'test',
:keyword => '**',
:package => 'app-admin/foobar',
:operator => '>=',
:version => '1.2.3',
:repo => 'community',
record_type: :parsed,
name: 'test',
keyword: '**',
package: 'app-admin/foobar',
operator: '>=',
version: '1.2.3',
repo: 'community',
}
expect(described_class.to_line(resource)).to eq ('** >=app-admin/foobar-1.2.3 repo=community ## Puppet Name: test')
expect(described_class.to_line(resource)).to eq '** >=app-admin/foobar-1.2.3 repo=community ## Puppet Name: test'
end
end
end

38
spec/unit/provider/entropy_repo/file_spec.rb
View File

@@ -8,53 +8,53 @@ describe Puppet::Type.type(:entropy_repo).provider(:file) do
let(:repos) do
[
{:name => 'sabayonlinux.org', :type => 'entropy', :enabled => 'true'},
{:name => 'sabayon-limbo', :type => 'entropy', :enabled => 'false'},
{:name => 'community', :type => 'enman', :enabled => 'true'},
{ name: 'sabayonlinux.org', type: 'entropy', enabled: 'true' },
{ name: 'sabayon-limbo', type: 'entropy', enabled: 'false' },
{ name: 'community', type: 'enman', enabled: 'true' },
]
end
before do
before(:each) do
Dir.stubs(:entries).with('/etc/entropy/repositories.conf.d/').returns([
'.', '..', 'README',
'entropy_sabayonlinux.org',
'_entropy_sabayon-limbo',
'entropy_enman_community',
'entropy_foobar.example',
])
'.', '..', 'README',
'entropy_sabayonlinux.org',
'_entropy_sabayon-limbo',
'entropy_enman_community',
'entropy_foobar.example'
])
end
it 'should identify the correct number of repos' do
it 'identifies the correct number of repos' do
expect(instances.size).to eq(repos.size)
end
it 'should identify the correct repo name' do
it 'identifies the correct repo name' do
repos.each_with_index do |repo, index|
expect(instances[index].name).to eq(repo[:name])
end
end
it 'should identify the correct enabled state' do
it 'identifies the correct enabled state' do
repos.each_with_index do |repo, index|
expect(instances[index].enabled).to eq(repo[:enabled])
end
end
end
describe 'when enabling a repository' do
it 'should enable a disabled repository' do
describe 'when enabling a repository' do
it 'enables a disabled repository' do
File.stubs(:exists?).with('/etc/entropy/repositories.conf.d/entropy_sabayonlinux.org').returns(true).once
File.stubs(:rename).with('/etc/entropy/repositories.conf.d/entropy_sabayonlinux.org', '/etc/entropy/repositories.conf.d/_entropy_sabayonlinux.org').once
instance = described_class.new(:name => 'sabayonlinux.org', :enabled => 'true', :type => 'entropy')
instance = described_class.new(name: 'sabayonlinux.org', enabled: 'true', type: 'entropy')
instance.enabled = 'false'
end
end
describe 'when disabling a repository' do
it 'should disable an enabled repository' do
describe 'when disabling a repository' do
it 'disables an enabled repository' do
File.stubs(:exists?).with('/etc/entropy/repositories.conf.d/_entropy_sabayon-limbo').returns(true).once
File.stubs(:rename).with('/etc/entropy/repositories.conf.d/_entropy_sabayon-limbo', '/etc/entropy/repositories.conf.d/entropy_sabayon-limbo').once
instance = described_class.new(:name => 'sabayon-limbo', :enabled => 'false', :type => 'entropy')
instance = described_class.new(name: 'sabayon-limbo', enabled: 'false', type: 'entropy')
instance.enabled = 'true'
end
end

201
spec/unit/provider/package_types/parsed_spec.rb
View File

@@ -5,22 +5,22 @@ 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,
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',
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|
types.each do |type_name, _type|
describe Puppet::Type.type(type_name).provider(:parsed) do
before do
before(:each) do
described_class.stubs(:filetype).returns(Puppet::Util::FileType::FileTypeRam)
described_class.stubs(:filetype=)
@default_target = described_class.default_target
@@ -33,7 +33,7 @@ types.each do |type_name, type|
end
describe 'when parsing' do
it 'should parse out the name' do
it 'parses out the name' do
line = 'app-admin/foobar ## Puppet Name: foobar'
expect(described_class.parse_line(line)[:name]).to eq('foobar')
end
@@ -42,11 +42,11 @@ types.each do |type_name, type|
line = 'app-admin/foobar ## Puppet Name: foobar'
parsed = described_class.parse_line(line)
it 'should parse out the package name' do
it 'parses out the package name' do
expect(parsed[:package]).to eq('app-admin/foobar')
end
it 'should have all other parameters undefined' do
it 'has all other parameters undefined' do
[:operator, :version, :slot, :use, :tag, :repo].each do |param|
expect(parsed[param]).to be_nil
end
@@ -57,15 +57,15 @@ types.each do |type_name, type|
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
it 'parses out the package name' do
expect(parsed[:package]).to eq('app-admin/foobar')
end
it 'should parse out the version' do
it 'parses out the version' do
expect(parsed[:version]).to eq('1.2.3_alpha1-r1')
end
it 'should have all other parameters undefined' do
it 'has all other parameters undefined' do
[:operator, :slot, :use, :tag, :repo].each do |param|
expect(parsed[param]).to be_nil
end
@@ -76,19 +76,19 @@ types.each do |type_name, type|
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
it 'parses out the package name' do
expect(parsed[:package]).to eq('app-admin/foobar')
end
it 'should parse out the version' do
it 'parses out the version' do
expect(parsed[:version]).to eq('1.2.3_alpha1-r1')
end
it 'should parse out the operator' do
it 'parses out the operator' do
expect(parsed[:operator]).to eq('>=')
end
it 'should have all other parameters undefined' do
it 'has all other parameters undefined' do
[:slot, :use, :tag, :repo].each do |param|
expect(parsed[param]).to be_nil
end
@@ -99,15 +99,15 @@ types.each do |type_name, type|
line = 'app-admin/foobar:1.1 ## Puppet Name: foobar'
parsed = described_class.parse_line(line)
it 'should parse out the package name' do
it 'parses out the package name' do
expect(parsed[:package]).to eq('app-admin/foobar')
end
it 'should parse out the slot' do
it 'parses out the slot' do
expect(parsed[:slot]).to eq('1.1')
end
it 'should have all other parameters undefined' do
it 'has all other parameters undefined' do
[:operator, :version, :use, :tag, :repo].each do |param|
expect(parsed[param]).to be_nil
end
@@ -118,15 +118,15 @@ types.each do |type_name, type|
line = 'app-admin/foobar[-foo,bar] ## Puppet Name: foobar'
parsed = described_class.parse_line(line)
it 'should parse out the package name' do
it 'parses out the package name' do
expect(parsed[:package]).to eq('app-admin/foobar')
end
it 'should parse out the use' do
it 'parses out the use' do
expect(parsed[:use]).to eq('-foo,bar')
end
it 'should have all other parameters undefined' do
it 'has all other parameters undefined' do
[:operator, :version, :slot, :tag, :repo].each do |param|
expect(parsed[param]).to be_nil
end
@@ -137,15 +137,15 @@ types.each do |type_name, type|
line = 'app-admin/foobar#server ## Puppet Name: foobar'
parsed = described_class.parse_line(line)
it 'should parse out the package name' do
it 'parses out the package name' do
expect(parsed[:package]).to eq('app-admin/foobar')
end
it 'should parse out the tag' do
it 'parses out the tag' do
expect(parsed[:tag]).to eq('server')
end
it 'should have all other parameters undefined' do
it 'has all other parameters undefined' do
[:operator, :version, :slot, :use, :repo].each do |param|
expect(parsed[param]).to be_nil
end
@@ -156,15 +156,15 @@ types.each do |type_name, type|
line = 'app-admin/foobar::community ## Puppet Name: foobar'
parsed = described_class.parse_line(line)
it 'should parse out the package name' do
it 'parses out the package name' do
expect(parsed[:package]).to eq('app-admin/foobar')
end
it 'should parse out the repo' do
it 'parses out the repo' do
expect(parsed[:repo]).to eq('community')
end
it 'should have all other parameters undefined' do
it 'has all other parameters undefined' do
[:operator, :version, :slot, :use, :tag].each do |param|
expect(parsed[param]).to be_nil
end
@@ -176,26 +176,25 @@ types.each do |type_name, type|
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',
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
it 'parses out all parameters' do
expected.each do |param, value|
expect(parsed[param]).to eq(value)
end
end
end
end
describe 'when flushing' do
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)
@@ -206,98 +205,98 @@ types.each do |type_name, type|
described_class.clear
end
it 'should output a single package entry' do
it 'outputs a single package entry' do
resource = {
:record_type => :parsed,
:name => 'test',
:package => 'app-admin/foobar',
record_type: :parsed,
name: 'test',
package: 'app-admin/foobar',
}
expect(described_class.to_line(resource)).to eq ('app-admin/foobar ## Puppet Name: test')
expect(described_class.to_line(resource)).to eq 'app-admin/foobar ## Puppet Name: test'
end
it 'should output a versioned package entry' do
it 'outputs a versioned package entry' do
resource = {
:record_type => :parsed,
:name => 'test',
:package => 'app-admin/foobar',
:version => '1.2.3',
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')
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
it 'outputs a ranged versioned package entry' do
resource = {
:record_type => :parsed,
:name => 'test',
:package => 'app-admin/foobar',
:version => '1.2.3',
:operator => '>=',
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')
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
it 'outputs a use-restricted package entry' do
resource = {
:record_type => :parsed,
:name => 'test',
:package => 'app-admin/foobar',
:use => '-foo,bar',
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')
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
it 'outputs a slotted package entry' do
resource = {
:record_type => :parsed,
:name => 'test',
:package => 'app-admin/foobar',
:slot => '1.1',
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')
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
it 'outputs a tagged package entry' do
resource = {
:record_type => :parsed,
:name => 'test',
:package => 'app-admin/foobar',
:tag => 'server',
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')
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
it 'outputs a repo-specific package entry' do
resource = {
:record_type => :parsed,
:name => 'test',
:package => 'app-admin/foobar',
:repo => 'community',
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')
expect(described_class.to_line(resource)).to eq 'app-admin/foobar::community ## Puppet Name: test'
end
it 'should output a whole-repo entry' do
it 'outputs a whole-repo entry' do
resource = {
:record_type => :parsed,
:name => 'test',
:repo => 'community',
record_type: :parsed,
name: 'test',
repo: 'community',
}
expect(described_class.to_line(resource)).to eq ('::community ## Puppet Name: test')
expect(described_class.to_line(resource)).to eq '::community ## Puppet Name: test'
end
it 'should output all fields for a package entry' do
it 'outputs 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',
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')
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

12
spec/unit/type/enman_repo_spec.rb
View File

@@ -1,16 +1,16 @@
describe Puppet::Type.type(:enman_repo) do
before do
before(:each) 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
it 'is 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]
describe 'when validating attributes' do
params = [:name]
params.each do |param|
it "should have the #{param} param" do
@@ -19,7 +19,7 @@ describe Puppet::Type.type(:enman_repo) do
end
end
it "should have name as the namevar" do
it 'has name as the namevar' do
expect(described_class.key_attributes).to eq [:name]
end
end

41
spec/unit/type/entropy_keywords_spec.rb
View File

@@ -1,17 +1,17 @@
describe Puppet::Type.type(:entropy_keywords) do
before do
before(:each) do
@provider = stub 'provider'
@provider.stubs(:name).returns(:parsed)
@provider.stubs(:ancestors).returns([Puppet::Provider::ParsedFile])
@provider.stubs(:default_target).returns("defaulttarget")
@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
it 'is 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
describe 'when validating attributes' do
params = [:name]
properties = [:package, :operator, :version, :repo, :target]
@@ -26,37 +26,36 @@ describe Puppet::Type.type(:entropy_keywords) do
expect(described_class.attrtype(property)).to eq :property
end
end
end
it "should have name as the namevar" do
it 'has 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"
describe 'when validating the target property' do
it "defaults 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 a version is passed with no package" do
describe 'when validating required properties' do
it 'raises 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/)
described_class.new(name: 'test', repo: 'test', version: '1.2.3')
}.to raise_error(Puppet::Error, %r{Package is required})
end
it "should raise an error when an operator is passed with no version" do
it 'raises 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/)
described_class.new(name: 'test', package: 'app-admin/dummy', operator: '<=')
}.to raise_error(Puppet::Error, %r{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')
describe 'when the catalog includes a matching package' do
it 'has 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

10
spec/unit/type/entropy_repo_spec.rb
View File

@@ -1,15 +1,15 @@
describe Puppet::Type.type(:entropy_repo) do
before do
before(:each) do
@provider = stub 'provider'
@provider.stubs(:name).returns(:file)
described_class.stubs(:defaultprovider).returns(@provider)
end
it "should be an instance of Puppet::Type::Entropy_repo" do
expect(described_class.new(:name => "test")).to be_an_instance_of Puppet::Type::Entropy_repo
it 'is an instance of Puppet::Type::Entropy_repo' do
expect(described_class.new(name: 'test')).to be_an_instance_of Puppet::Type::Entropy_repo
end
describe "when validating attributes" do
describe 'when validating attributes' do
params = [:name]
properties = [:repo_type, :enabled]
@@ -26,7 +26,7 @@ describe Puppet::Type.type(:entropy_repo) do
end
end
it "should have name as the namevar" do
it 'has name as the namevar' do
expect(described_class.key_attributes).to eq [:name]
end
end

53
spec/unit/type/package_types_spec.rb
View File

@@ -5,27 +5,27 @@ 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,
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
before(:each) do
@provider = stub 'provider'
@provider.stubs(:name).returns(:parsed)
@provider.stubs(:ancestors).returns([Puppet::Provider::ParsedFile])
@provider.stubs(:default_target).returns("defaulttarget")
@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
expect(described_class.new(name: 'test', package: 'app-admin/dummy')).to be_an_instance_of type
end
describe "when validating attributes" do
describe 'when validating attributes' do
params = [:name]
properties = [:package, :operator, :version, :slot, :use, :tag, :repo, :target]
@@ -40,32 +40,31 @@ types.each do |type_name, type|
expect(described_class.attrtype(property)).to eq :property
end
end
end
it "should have name as the namevar" do
it 'has 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"
describe 'when validating the target property' do
it "defaults 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
describe 'when validating required properties' do
packages = [
'virtual/package',
'package',
'package-with-dash',
'package_with_underscores',
'category-123/package2',
'category.with.dots/package'
'category.with.dots/package',
]
packages.each do |package|
it "should accept valid package name #{package}" do
expect {
described_class.new(:name => 'test', :package => package)
described_class.new(name: 'test', package: package)
}.not_to raise_error
end
end
@@ -79,28 +78,28 @@ types.each do |type_name, type|
packages.each do |package|
it "should reject invalid package name #{package}" do
expect {
described_class.new(:name => 'test', :package => package)
described_class.new(name: 'test', package: package)
}.to raise_error(Puppet::Error)
end
end
it "should raise an error when a version is passed with no package" do
it 'raises 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/)
described_class.new(name: 'test', repo: 'test', version: '1.2.3')
}.to raise_error(Puppet::Error, %r{Package is required})
end
it "should raise an error when an operator is passed with no version" do
it 'raises 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/)
described_class.new(name: 'test', package: 'app-admin/dummy', operator: '<=')
}.to raise_error(Puppet::Error, %r{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')
describe 'when the catalog includes a matching package' do
it 'has 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