rtyler
/
puppet-bsd
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Autofix specs for rubocop

This commit is contained in:
Zach Leslie 2017-02-26 18:59:08 -08:00
parent d7bf068648
commit 961c7c0e94
27 changed files with 1014 additions and 1016 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
spec/classes/network_carp_spec.rb
View File

@ -4,23 +4,21 @@ describe 'bsd::network::carp' do
on_supported_os.each do |os, facts|
let(:facts) { facts }
context "on #{os}" do
context 'with allowed' do
let(:params) { {:allowed => true} }
let(:params) { { allowed: true } }
it do
should contain_class('bsd::network::carp')
should contain_sysctl('net.inet.carp.allow').with_value('1')
is_expected.to contain_class('bsd::network::carp')
is_expected.to contain_sysctl('net.inet.carp.allow').with_value('1')
end
end
context 'with preempt' do
let(:params) { {:preempt => true} }
let(:params) { { preempt: true } }
it do
should contain_class('bsd::network::carp')
should contain_sysctl('net.inet.carp.preempt').with_value('1')
is_expected.to contain_class('bsd::network::carp')
is_expected.to contain_sysctl('net.inet.carp.preempt').with_value('1')
end
end
end
end
end

62
spec/classes/network_gre_spec.rb
View File

@ -4,49 +4,53 @@ describe 'bsd::network::gre' do
on_supported_os.each do |os, facts|
let(:facts) { facts }
context "on #{os}" do
context 'with allowed' do
let(:params) {{
:allowed => true,
:wccp => false,
:mobileip => false,
}}
let(:params) do
{
allowed: true,
wccp: false,
mobileip: false
}
end
it do
should contain_class('bsd::network::gre')
should contain_sysctl('net.inet.gre.allow').with_value('1')
should contain_sysctl('net.inet.gre.wccp').with_value('0')
should contain_sysctl('net.inet.mobileip.allow').with_value('0')
is_expected.to contain_class('bsd::network::gre')
is_expected.to contain_sysctl('net.inet.gre.allow').with_value('1')
is_expected.to contain_sysctl('net.inet.gre.wccp').with_value('0')
is_expected.to contain_sysctl('net.inet.mobileip.allow').with_value('0')
end
end
context 'with wccp' do
let(:params) {{
:allowed => false,
:wccp => true,
:mobileip => false,
}}
let(:params) do
{
allowed: false,
wccp: true,
mobileip: false
}
end
it do
should contain_class('bsd::network::gre')
should contain_sysctl('net.inet.gre.allow').with_value('0')
should contain_sysctl('net.inet.gre.wccp').with_value('1')
should contain_sysctl('net.inet.mobileip.allow').with_value('0')
is_expected.to contain_class('bsd::network::gre')
is_expected.to contain_sysctl('net.inet.gre.allow').with_value('0')
is_expected.to contain_sysctl('net.inet.gre.wccp').with_value('1')
is_expected.to contain_sysctl('net.inet.mobileip.allow').with_value('0')
end
end
context 'with mobileip' do
let(:params) {{
:allowed => false,
:wccp => false,
:mobileip => true,
}}
let(:params) do
{
allowed: false,
wccp: false,
mobileip: true
}
end
it do
should contain_class('bsd::network::gre')
should contain_sysctl('net.inet.gre.allow').with_value('0')
should contain_sysctl('net.inet.gre.wccp').with_value('0')
should contain_sysctl('net.inet.mobileip.allow').with_value('1')
is_expected.to contain_class('bsd::network::gre')
is_expected.to contain_sysctl('net.inet.gre.allow').with_value('0')
is_expected.to contain_sysctl('net.inet.gre.wccp').with_value('0')
is_expected.to contain_sysctl('net.inet.mobileip.allow').with_value('1')
end
end
end
end
end

56
spec/classes/network_spec.rb
View File

@ -5,52 +5,48 @@ describe 'bsd::network' do
context "on #{os}" do
let(:facts) { facts }
context 'with default params' do
it {
should contain_class('bsd::network')
should contain_sysctl('net.inet6.ip6.forwarding').with_value('0')
should contain_sysctl('net.inet.ip.forwarding').with_value('0')
}
it do
is_expected.to contain_class('bsd::network')
is_expected.to contain_sysctl('net.inet6.ip6.forwarding').with_value('0')
is_expected.to contain_sysctl('net.inet.ip.forwarding').with_value('0')
end
end
context 'with forwarding enabled' do
let(:params) { {:v4forwarding => true, :v6forwarding => true} }
it {
should contain_class('bsd::network')
should contain_sysctl('net.inet6.ip6.forwarding').with_value('1')
should contain_sysctl('net.inet.ip.forwarding').with_value('1')
}
let(:params) { { v4forwarding: true, v6forwarding: true } }
it do
is_expected.to contain_class('bsd::network')
is_expected.to contain_sysctl('net.inet6.ip6.forwarding').with_value('1')
is_expected.to contain_sysctl('net.inet.ip.forwarding').with_value('1')
end
case facts[:osfamily]
when 'FreeBSD'
it {
should contain_shellvar('gateway_enable').with_value('YES')
should contain_shellvar('ipv6_gateway_enable').with_value('YES')
}
it do
is_expected.to contain_shellvar('gateway_enable').with_value('YES')
is_expected.to contain_shellvar('ipv6_gateway_enable').with_value('YES')
end
end
end
context 'with gateways set' do
let(:params) { {:v4gateway => '123.123.123.123', :v6gateway => '123::'} }
it {
should contain_class('bsd::network')
}
let(:params) { { v4gateway: '123.123.123.123', v6gateway: '123::' } }
it do
is_expected.to contain_class('bsd::network')
end
case facts[:osfamily]
when 'FreeBSD'
it {
should contain_shellvar('defaultrouter').with_value('123.123.123.123')
should contain_shellvar('ipv6_defaultrouter').with_value('123::')
}
it do
is_expected.to contain_shellvar('defaultrouter').with_value('123.123.123.123')
is_expected.to contain_shellvar('ipv6_defaultrouter').with_value('123::')
end
when 'OpenBSD'
it {
should contain_file('/etc/mygate')
}
it do
is_expected.to contain_file('/etc/mygate')
end
end
end
end
end
end

68
spec/defines/bsd_network_interface_bridge_spec.rb
View File

@ -1,64 +1,64 @@
require 'spec_helper'
describe "bsd::network::interface::bridge" do
context "on OpenBSD" do
let(:facts) { {:kernel => 'OpenBSD'} }
describe 'bsd::network::interface::bridge' do
context 'on OpenBSD' do
let(:facts) { { kernel: 'OpenBSD' } }
let(:title) { 'bridge0' }
context " a minimal example" do
let(:params) {
context ' a minimal example' do
let(:params) do
{
:interface => ['em0', 'em1']
interface: %w(em0 em1)
}
}
it do
should contain_bsd__network__interface__bridge('bridge0')
should contain_bsd__network__interface('bridge0').with_parents(['em0', 'em1'])
should contain_bsd_interface('bridge0')
end
it do
should contain_file('/etc/hostname.bridge0').with_content(/add em0\nadd em1\nup\n/)
is_expected.to contain_bsd__network__interface__bridge('bridge0')
is_expected.to contain_bsd__network__interface('bridge0').with_parents(%w(em0 em1))
is_expected.to contain_bsd_interface('bridge0')
end
it do
is_expected.to contain_file('/etc/hostname.bridge0').with_content(%r{add em0\nadd em1\nup\n})
end
end
context "a medium example" do
let(:params) {
context 'a medium example' do
let(:params) do
{
:interface => ['em0', 'em1'],
:description => "TestNet"
interface: %w(em0 em1),
description: 'TestNet'
}
}
it do
should contain_bsd__network__interface('bridge0').with_parents(['em0', 'em1'])
end
it do
should contain_file('/etc/hostname.bridge0').with_content(/description "TestNet"\nadd em0\nadd em1\nup\n/)
is_expected.to contain_bsd__network__interface('bridge0').with_parents(%w(em0 em1))
end
it do
is_expected.to contain_file('/etc/hostname.bridge0').with_content(%r{description "TestNet"\nadd em0\nadd em1\nup\n})
end
end
context " a bit more extensive example with values set" do
let(:params) {
context ' a bit more extensive example with values set' do
let(:params) do
{
:interface => ['em0', 'em1'],
:raw_values => '!route add -net 10.10.10.0/24 10.0.0.254',
interface: %w(em0 em1),
raw_values: '!route add -net 10.10.10.0/24 10.0.0.254'
}
}
it do
should contain_bsd__network__interface('bridge0').with_parents(['em0', 'em1'])
end
it do
should contain_file('/etc/hostname.bridge0').with_content(/add em0\nadd em1\n!route add -net 10.10.10.0\/24 10.0.0.254\nup\n/)
is_expected.to contain_bsd__network__interface('bridge0').with_parents(%w(em0 em1))
end
it do
is_expected.to contain_file('/etc/hostname.bridge0').with_content(/add em0\nadd em1\n!route add -net 10.10.10.0\/24 10.0.0.254\nup\n/)
end
end
end
context "when a bad name is used" do
let(:facts) { {:kernel => 'OpenBSD'} }
context 'when a bad name is used' do
let(:facts) { { kernel: 'OpenBSD' } }
let(:title) { 'notcorrect0' }
let(:params) { {:interface => ['em0', 'em1'], :description => "TestNet"} }
let(:params) { { interface: %w(em0 em1), description: 'TestNet' } }
it do
expect {
should contain_bsd__network__interface__bridge('notcorrect0')
}.to raise_error(Puppet::Error, /does not match/)
expect do
is_expected.to contain_bsd__network__interface__bridge('notcorrect0')
end.to raise_error(Puppet::Error, %r{does not match})
end
end
end

136
spec/defines/bsd_network_interface_carp_spec.rb
View File

@ -1,107 +1,107 @@
require 'spec_helper'
describe "bsd::network::interface::carp" do
context "on OpenBSD" do
let(:facts) { {:kernel => 'OpenBSD'} }
describe 'bsd::network::interface::carp' do
context 'on OpenBSD' do
let(:facts) { { kernel: 'OpenBSD' } }
let(:title) { 'carp0' }
context " a minimal example" do
let(:params) {
context ' a minimal example' do
let(:params) do
{
:id => '1',
:device => 'em0',
:address => ['10.0.0.1/24'],
:advbase => '1',
:advskew => '0',
:pass => 'TopSecret',
id: '1',
device: 'em0',
address: ['10.0.0.1/24'],
advbase: '1',
advskew: '0',
pass: 'TopSecret'
}
}
it do
should contain_bsd__network__interface__carp('carp0')
should contain_bsd__network__interface('carp0').with_parents(['em0'])
should contain_bsd_interface('carp0')
end
it do
should contain_file('/etc/hostname.carp0').with_content(/vhid 1 pass TopSecret carpdev em0 advbase 1 advskew 0\ninet 10.0.0.1 255.255.255.0 NONE\nup\n/)
is_expected.to contain_bsd__network__interface__carp('carp0')
is_expected.to contain_bsd__network__interface('carp0').with_parents(['em0'])
is_expected.to contain_bsd_interface('carp0')
end
it do
is_expected.to contain_file('/etc/hostname.carp0').with_content(%r{vhid 1 pass TopSecret carpdev em0 advbase 1 advskew 0\ninet 10.0.0.1 255.255.255.0 NONE\nup\n})
end
end
context " a bit more extensive example with values set" do
let(:params) {
context ' a bit more extensive example with values set' do
let(:params) do
{
:id => '1',
:device => 'em0',
:address => ['10.0.0.1/24'],
:advbase => '1',
:advskew => '0',
:pass => 'TopSecret',
:raw_values => '!route add -net 10.10.10.0/24 10.0.0.254',
id: '1',
device: 'em0',
address: ['10.0.0.1/24'],
advbase: '1',
advskew: '0',
pass: 'TopSecret',
raw_values: '!route add -net 10.10.10.0/24 10.0.0.254'
}
}
it do
should contain_bsd__network__interface('carp0').with_parents(['em0'])
end
it do
should contain_file('/etc/hostname.carp0').with_content(/vhid 1 pass TopSecret carpdev em0 advbase 1 advskew 0\ninet 10.0.0.1 255.255.255.0 NONE\n!route add -net 10.10.10.0\/24 10.0.0.254\nup\n/)
is_expected.to contain_bsd__network__interface('carp0').with_parents(['em0'])
end
it do
is_expected.to contain_file('/etc/hostname.carp0').with_content(/vhid 1 pass TopSecret carpdev em0 advbase 1 advskew 0\ninet 10.0.0.1 255.255.255.0 NONE\n!route add -net 10.10.10.0\/24 10.0.0.254\nup\n/)
end
end
context " a bit more extensive example with multiple values set" do
let(:params) {
context ' a bit more extensive example with multiple values set' do
let(:params) do
{
:id => '1',
:device => 'em0',
:address => ['10.0.0.1/24'],
:advbase => '1',
:advskew => '0',
:pass => 'TopSecret',
:raw_values => [ '!route add -net 10.10.10.0/24 10.0.0.254', '!route add -net 10.20.10.0/24 10.0.0.254', ],
id: '1',
device: 'em0',
address: ['10.0.0.1/24'],
advbase: '1',
advskew: '0',
pass: 'TopSecret',
raw_values: ['!route add -net 10.10.10.0/24 10.0.0.254', '!route add -net 10.20.10.0/24 10.0.0.254']
}
}
it do
should contain_bsd__network__interface('carp0').with_parents(['em0'])
end
it do
should contain_file('/etc/hostname.carp0').with_content(/vhid 1 pass TopSecret carpdev em0 advbase 1 advskew 0\ninet 10.0.0.1 255.255.255.0 NONE\n!route add -net 10.10.10.0\/24 10.0.0.254\n!route add -net 10.20.10.0\/24 10.0.0.254\nup\n/)
is_expected.to contain_bsd__network__interface('carp0').with_parents(['em0'])
end
it do
is_expected.to contain_file('/etc/hostname.carp0').with_content(/vhid 1 pass TopSecret carpdev em0 advbase 1 advskew 0\ninet 10.0.0.1 255.255.255.0 NONE\n!route add -net 10.10.10.0\/24 10.0.0.254\n!route add -net 10.20.10.0\/24 10.0.0.254\nup\n/)
end
end
context " a bit more extensive example with multiple addresses" do
let(:params) {
context ' a bit more extensive example with multiple addresses' do
let(:params) do
{
:id => '1',
:device => 'em0',
:address => [ '10.0.0.1/24', '10.0.0.2/32', '10.0.0.3/32' ],
:advbase => '1',
:advskew => '0',
:pass => 'TopSecret',
id: '1',
device: 'em0',
address: ['10.0.0.1/24', '10.0.0.2/32', '10.0.0.3/32'],
advbase: '1',
advskew: '0',
pass: 'TopSecret'
}
}
it do
should contain_bsd__network__interface('carp0').with_parents(['em0'])
end
it do
should contain_file('/etc/hostname.carp0').with_content(/vhid 1 pass TopSecret carpdev em0 advbase 1 advskew 0\ninet 10.0.0.1 255.255.255.0 NONE\ninet alias 10.0.0.2 255.255.255.255 NONE\ninet alias 10.0.0.3 255.255.255.255 NONE\nup\n/)
is_expected.to contain_bsd__network__interface('carp0').with_parents(['em0'])
end
it do
is_expected.to contain_file('/etc/hostname.carp0').with_content(%r{vhid 1 pass TopSecret carpdev em0 advbase 1 advskew 0\ninet 10.0.0.1 255.255.255.0 NONE\ninet alias 10.0.0.2 255.255.255.255 NONE\ninet alias 10.0.0.3 255.255.255.255 NONE\nup\n})
end
end
end
context "when a bad name is used" do
let(:facts) { {:kernel => 'OpenBSD'} }
context 'when a bad name is used' do
let(:facts) { { kernel: 'OpenBSD' } }
let(:title) { 'notcorrect0' }
let(:params) {
let(:params) do
{
:id => '1',
:device => 'em0',
:address => ['10.0.0.1/24'],
:advbase => '1',
:advskew => '0',
:pass => 'TopSecret',
id: '1',
device: 'em0',
address: ['10.0.0.1/24'],
advbase: '1',
advskew: '0',
pass: 'TopSecret'
}
}
end
it do
expect {
should contain_bsd__network__interface__carp('notcorrect0')
}.to raise_error(Puppet::Error, /does not match/)
expect do
is_expected.to contain_bsd__network__interface__carp('notcorrect0')
end.to raise_error(Puppet::Error, %r{does not match})
end
end
end

98
spec/defines/bsd_network_interface_pfsync_spec.rb
View File

@ -1,82 +1,90 @@
require 'spec_helper'
describe "bsd::network::interface::pfsync" do
context "on OpenBSD" do
let(:facts) { {:kernel => 'OpenBSD'} }
describe 'bsd::network::interface::pfsync' do
context 'on OpenBSD' do
let(:facts) { { kernel: 'OpenBSD' } }
let(:title) { 'pfsync0' }
context "an example with all default values" do
context 'an example with all default values' do
it do
should contain_bsd__network__interface__pfsync('pfsync0')
should contain_bsd__network__interface('pfsync0')
should contain_bsd_interface('pfsync0')
is_expected.to contain_bsd__network__interface__pfsync('pfsync0')
is_expected.to contain_bsd__network__interface('pfsync0')
is_expected.to contain_bsd_interface('pfsync0')
end
it do
should contain_file('/etc/hostname.pfsync0').with_content(/-syncdev -syncpeer maxupd 128 -defer\nup\n/)
is_expected.to contain_file('/etc/hostname.pfsync0').with_content(%r{-syncdev -syncpeer maxupd 128 -defer\nup\n})
end
end
context "a minimal example" do
let(:params) { {:syncdev => 'em0'} }
context 'a minimal example' do
let(:params) { { syncdev: 'em0' } }
it do
should contain_bsd__network__interface('pfsync0').with_parents(['em0'])
is_expected.to contain_bsd__network__interface('pfsync0').with_parents(['em0'])
end
it do
should contain_file('/etc/hostname.pfsync0').with_content(/syncdev em0 -syncpeer maxupd 128 -defer\nup\n/)
is_expected.to contain_file('/etc/hostname.pfsync0').with_content(%r{syncdev em0 -syncpeer maxupd 128 -defer\nup\n})
end
end
context "a medium example" do
let(:params) { {:syncdev => 'em0', :description => "TestNet"} }
context 'a medium example' do
let(:params) { { syncdev: 'em0', description: 'TestNet' } }
it do
should contain_bsd__network__interface('pfsync0').with_parents(['em0'])
is_expected.to contain_bsd__network__interface('pfsync0').with_parents(['em0'])
end
it do
should contain_file('/etc/hostname.pfsync0').with_content(/description \"TestNet\"\nsyncdev em0 -syncpeer maxupd 128 -defer\nup\n/)
is_expected.to contain_file('/etc/hostname.pfsync0').with_content(%r{description \"TestNet\"\nsyncdev em0 -syncpeer maxupd 128 -defer\nup\n})
end
end
context "an example with syncpeer" do
let(:params) { {
:syncdev => 'em0',
:syncpeer => '10.0.0.222',
} }
it do
should contain_bsd__network__interface('pfsync0').with_parents(['em0'])
context 'an example with syncpeer' do
let(:params) do
{
syncdev: 'em0',
syncpeer: '10.0.0.222'
}
end
it do
should contain_file('/etc/hostname.pfsync0').with_content(
/syncdev em0 syncpeer 10.0.0.222 maxupd 128 -defer\nup\n/)
is_expected.to contain_bsd__network__interface('pfsync0').with_parents(['em0'])
end
it do
is_expected.to contain_file('/etc/hostname.pfsync0').with_content(
%r{syncdev em0 syncpeer 10.0.0.222 maxupd 128 -defer\nup\n}
)
end
end
context "an example with non-default maxupd and defer" do
let(:params) { {
:syncdev => 'em0',
:syncpeer => '10.0.0.222',
:maxupd => '156',
:defer => true,
} }
it do
should contain_bsd__network__interface('pfsync0').with_parents(['em0'])
context 'an example with non-default maxupd and defer' do
let(:params) do
{
syncdev: 'em0',
syncpeer: '10.0.0.222',
maxupd: '156',
defer: true
}
end
it do
should contain_file('/etc/hostname.pfsync0').with_content(
/syncdev em0 syncpeer 10.0.0.222 maxupd 156 defer\nup\n/)
is_expected.to contain_bsd__network__interface('pfsync0').with_parents(['em0'])
end
it do
is_expected.to contain_file('/etc/hostname.pfsync0').with_content(
%r{syncdev em0 syncpeer 10.0.0.222 maxupd 156 defer\nup\n}
)
end
end
end
context "when a bad name is used" do
let(:facts) { {:kernel => 'OpenBSD'} }
context 'when a bad name is used' do
let(:facts) { { kernel: 'OpenBSD' } }
let(:title) { 'notcorrect0' }
let(:params) { {
:syncdev => 'em0',
:description => "TestNet"
} }
let(:params) do
{
syncdev: 'em0',
description: 'TestNet'
}
end
it do
expect {
should contain_bsd__network__interface__pfsync('notcorrect0')
}.to raise_error(Puppet::Error, /does not match/)
expect do
is_expected.to contain_bsd__network__interface__pfsync('notcorrect0')
end.to raise_error(Puppet::Error, %r{does not match})
end
end
end

195
spec/defines/bsd_network_interface_spec.rb
View File

@ -1,152 +1,153 @@
require 'spec_helper'
describe "bsd::network::interface" do
describe 'bsd::network::interface' do
on_supported_os.each do |os, facts|
context "on #{os}" do
let(:facts) { facts }
context "a basic configuration" do
context 'a basic configuration' do
let(:title) { 'igb0' }
let(:params) { {:ensure => 'up'} }
case facts[:osfamily]
when 'FreeBSD'
it {
should contain_bsd__network__interface('igb0').with_ensure('up')
should contain_bsd__network__interface('igb0').with_mtu(nil)
should contain_bsd__network__interface('igb0').with_parents(nil)
should contain_bsd_interface('igb0').with_ensure('up')
should contain_bsd_interface('igb0').with_mtu(nil)
should contain_bsd_interface('igb0').with_parents(nil)
}
end
end
context "a basic configuration with an address" do
let(:title) { 'igb0' }
let(:params) { {:addresses => ['10.0.0.1/24'], :description => 'simple' } }
case facts[:osfamily]
when 'FreeBSD'
it {
should contain_shellvar('ifconfig_igb0').with_value(/inet 10.0.0.1\/24/)
should contain_shellvar('ifconfig_igb0').with_target('/etc/rc.conf')
should contain_shellvar('ifconfig_igb0').that_notifies('Bsd_interface[igb0]')
should contain_bsd_interface('igb0').with_ensure('up')
should contain_bsd_interface('igb0').with_mtu(nil)
should contain_bsd_interface('igb0').with_parents(nil)
}
end
end
context "a basic configuration with mtu" do
let(:title) { 'igb0' }
let(:params) { {:mtu => 9000, :description => 'simple mtu' } }
case facts[:osfamily]
when 'FreeBSD'
it {
should contain_shellvar('ifconfig_igb0').with_value(/mtu 9000/)
should contain_shellvar('ifconfig_igb0').with_target('/etc/rc.conf')
should contain_bsd_interface('igb0').with_ensure('up')
should contain_bsd_interface('igb0').with_mtu(9000)
should contain_bsd_interface('igb0').with_parents(nil)
}
end
end
context "a basic vlan interface with an address" do
let(:title) { 'vlan1' }
let(:params) { {:addresses => ['10.0.0.1/24'], :options => ['vlan 1', 'vlandev em0'] } }
let(:params) { { ensure: 'up' } }
case facts[:osfamily]
when 'FreeBSD'
it do
should contain_shellvar('ifconfig_vlan1').with_value(/inet 10.0.0.1\/24 vlan 1 vlandev em0/)
should contain_shellvar('ifconfig_vlan1').with_ensure('present')
should contain_shellvar('ifconfig_vlan1').that_notifies('Bsd_interface[vlan1]')
should contain_bsd_interface('vlan1').that_requires('Shellvar[ifconfig_vlan1]')
should contain_bsd__network__interface('vlan1')
is_expected.to contain_bsd__network__interface('igb0').with_ensure('up')
is_expected.to contain_bsd__network__interface('igb0').with_mtu(nil)
is_expected.to contain_bsd__network__interface('igb0').with_parents(nil)
is_expected.to contain_bsd_interface('igb0').with_ensure('up')
is_expected.to contain_bsd_interface('igb0').with_mtu(nil)
is_expected.to contain_bsd_interface('igb0').with_parents(nil)
end
end
end
should contain_bsd_interface('vlan1').with_ensure('up')
should contain_bsd_interface('vlan1').with_mtu(nil)
should contain_bsd_interface('vlan1').with_parents(nil)
context 'a basic configuration with an address' do
let(:title) { 'igb0' }
let(:params) { { addresses: ['10.0.0.1/24'], description: 'simple' } }
case facts[:osfamily]
when 'FreeBSD'
it do
is_expected.to contain_shellvar('ifconfig_igb0').with_value(/inet 10.0.0.1\/24/)
is_expected.to contain_shellvar('ifconfig_igb0').with_target('/etc/rc.conf')
is_expected.to contain_shellvar('ifconfig_igb0').that_notifies('Bsd_interface[igb0]')
is_expected.to contain_bsd_interface('igb0').with_ensure('up')
is_expected.to contain_bsd_interface('igb0').with_mtu(nil)
is_expected.to contain_bsd_interface('igb0').with_parents(nil)
end
end
end
context 'a basic configuration with mtu' do
let(:title) { 'igb0' }
let(:params) { { mtu: 9000, description: 'simple mtu' } }
case facts[:osfamily]
when 'FreeBSD'
it do
is_expected.to contain_shellvar('ifconfig_igb0').with_value(%r{mtu 9000})
is_expected.to contain_shellvar('ifconfig_igb0').with_target('/etc/rc.conf')
is_expected.to contain_bsd_interface('igb0').with_ensure('up')
is_expected.to contain_bsd_interface('igb0').with_mtu(9000)
is_expected.to contain_bsd_interface('igb0').with_parents(nil)
end
end
end
context 'a basic vlan interface with an address' do
let(:title) { 'vlan1' }
let(:params) { { addresses: ['10.0.0.1/24'], options: ['vlan 1', 'vlandev em0'] } }
case facts[:osfamily]
when 'FreeBSD'
it do
is_expected.to contain_shellvar('ifconfig_vlan1').with_value(/inet 10.0.0.1\/24 vlan 1 vlandev em0/)
is_expected.to contain_shellvar('ifconfig_vlan1').with_ensure('present')
is_expected.to contain_shellvar('ifconfig_vlan1').that_notifies('Bsd_interface[vlan1]')
is_expected.to contain_bsd_interface('vlan1').that_requires('Shellvar[ifconfig_vlan1]')
is_expected.to contain_bsd__network__interface('vlan1')
is_expected.to contain_bsd_interface('vlan1').with_ensure('up')
is_expected.to contain_bsd_interface('vlan1').with_mtu(nil)
is_expected.to contain_bsd_interface('vlan1').with_parents(nil)
end
end
end
end
end
context "on OpenBSD" do
let(:facts) { {:kernel => 'OpenBSD'} }
context "a basic configuration" do
context 'on OpenBSD' do
let(:facts) { { kernel: 'OpenBSD' } }
context 'a basic configuration' do
let(:title) { 'tun0' }
let(:params) { {:raw_values => ['just a test', 'up'], :description => 'simple' } }
let(:params) { { raw_values: ['just a test', 'up'], description: 'simple' } }
it do
should contain_file('/etc/hostname.tun0').with_content(/description "simple"\njust a test\nup\n/)
should contain_bsd_interface('tun0').that_requires('File[/etc/hostname.tun0]')
should contain_bsd__network__interface('tun0')
is_expected.to contain_file('/etc/hostname.tun0').with_content(%r{description "simple"\njust a test\nup\n})
is_expected.to contain_bsd_interface('tun0').that_requires('File[/etc/hostname.tun0]')
is_expected.to contain_bsd__network__interface('tun0')
end
end
context "a tun device" do
context 'a tun device' do
let(:title) { 'tun0' }
let(:params) { {:raw_values => ['up','!/usr/local/bin/openvpn'] } }
let(:params) { { raw_values: ['up', '!/usr/local/bin/openvpn'] } }
it do
should contain_file('/etc/hostname.tun0').with_content(/up\n!\/usr\/local\/bin\/openvpn/)
is_expected.to contain_file('/etc/hostname.tun0').with_content(/up\n!\/usr\/local\/bin\/openvpn/)
end
it do
should contain_file('/etc/hostname.tun0').that_notifies('Bsd_interface[tun0]')
is_expected.to contain_file('/etc/hostname.tun0').that_notifies('Bsd_interface[tun0]')
end
it do
should contain_bsd_interface('tun0').that_requires('File[/etc/hostname.tun0]')
is_expected.to contain_bsd_interface('tun0').that_requires('File[/etc/hostname.tun0]')
end
end
context "a vether device using addresses and values parameter" do
context 'a vether device using addresses and values parameter' do
let(:title) { 'vether0' }
let(:params) { {
:addresses => [ '123.123.123.123/29',
'172.16.0.1/27',
'fc01::/7',
'2001:100:fed:beef::/64', ],
:raw_values => [ 'up', ]
let(:params) do
{
addresses: ['123.123.123.123/29',
'172.16.0.1/27',
'fc01::/7',
'2001:100:fed:beef::/64'],
raw_values: ['up']
}
}
end
it do
should contain_file('/etc/hostname.vether0').with_content(/inet 123.123.123.123 255.255.255.248 NONE\ninet alias 172.16.0.1 255.255.255.224 NONE\ninet6 fc01:: 7\ninet6 alias 2001:100:fed:beef:: 64\nup\n/)
is_expected.to contain_file('/etc/hostname.vether0').with_content(%r{inet 123.123.123.123 255.255.255.248 NONE\ninet alias 172.16.0.1 255.255.255.224 NONE\ninet6 fc01:: 7\ninet6 alias 2001:100:fed:beef:: 64\nup\n})
end
it do
should contain_file('/etc/hostname.vether0').that_notifies('Bsd_interface[vether0]')
should contain_bsd_interface('vether0').that_requires('File[/etc/hostname.vether0]')
should contain_bsd__network__interface('vether0')
is_expected.to contain_file('/etc/hostname.vether0').that_notifies('Bsd_interface[vether0]')
is_expected.to contain_bsd_interface('vether0').that_requires('File[/etc/hostname.vether0]')
is_expected.to contain_bsd__network__interface('vether0')
end
end
context "a vether device using values parameter only" do
context 'a vether device using values parameter only' do
let(:title) { 'vether0' }
let(:params) { {
:raw_values => [ '123.123.123.123/29',
'172.16.0.1/27',
'fc01::/7',
'2001:100:fed:beef::/64',
'up', ]
let(:params) do
{
raw_values: ['123.123.123.123/29',
'172.16.0.1/27',
'fc01::/7',
'2001:100:fed:beef::/64',
'up']
}
}
end
it do
should contain_file('/etc/hostname.vether0').with_content(/inet 123.123.123.123 255.255.255.248 NONE\ninet alias 172.16.0.1 255.255.255.224 NONE\ninet6 fc01:: 7\ninet6 alias 2001:100:fed:beef:: 64\nup\n/)
is_expected.to contain_file('/etc/hostname.vether0').with_content(%r{inet 123.123.123.123 255.255.255.248 NONE\ninet alias 172.16.0.1 255.255.255.224 NONE\ninet6 fc01:: 7\ninet6 alias 2001:100:fed:beef:: 64\nup\n})
end
it do
should contain_file('/etc/hostname.vether0').that_notifies('Bsd_interface[vether0]')
is_expected.to contain_file('/etc/hostname.vether0').that_notifies('Bsd_interface[vether0]')
end
it do
should contain_bsd_interface('vether0').that_requires('File[/etc/hostname.vether0]')
is_expected.to contain_bsd_interface('vether0').that_requires('File[/etc/hostname.vether0]')
end
end
end
end

84
spec/defines/bsd_network_interface_trunk_spec.rb
View File

@ -1,70 +1,76 @@
require 'spec_helper'
describe "bsd::network::interface::trunk" do
context "on OpenBSD" do
let(:facts) { {:kernel => 'OpenBSD'} }
describe 'bsd::network::interface::trunk' do
context 'on OpenBSD' do
let(:facts) { { kernel: 'OpenBSD' } }
let(:title) { 'trunk0' }
context " a minimal example" do
let(:params) { {:interface => ['em0', 'em1']} }
context ' a minimal example' do
let(:params) { { interface: %w(em0 em1) } }
it do
should contain_bsd__network__interface__trunk('trunk0')
should contain_bsd__network__interface('trunk0').with_parents(['em0', 'em1'])
should contain_bsd_interface('trunk0')
is_expected.to contain_bsd__network__interface__trunk('trunk0')
is_expected.to contain_bsd__network__interface('trunk0').with_parents(%w(em0 em1))
is_expected.to contain_bsd_interface('trunk0')
end
it do
should contain_file('/etc/hostname.trunk0').with_content(/trunkproto lacp trunkport em0 trunkport em1\nup\n/)
is_expected.to contain_file('/etc/hostname.trunk0').with_content(%r{trunkproto lacp trunkport em0 trunkport em1\nup\n})
end
end
context "a medium example" do
let(:params) { {:interface => ['em0', 'em1'], :description => "TestNet"} }
context 'a medium example' do
let(:params) { { interface: %w(em0 em1), description: 'TestNet' } }
it do
should contain_bsd__network__interface('trunk0').with_parents(['em0', 'em1'])
is_expected.to contain_bsd__network__interface('trunk0').with_parents(%w(em0 em1))
end
it do
should contain_file('/etc/hostname.trunk0').with_content(/description \"TestNet\"\ntrunkproto lacp trunkport em0 trunkport em1\nup\n/)
is_expected.to contain_file('/etc/hostname.trunk0').with_content(%r{description \"TestNet\"\ntrunkproto lacp trunkport em0 trunkport em1\nup\n})
end
end
context "an example with an address" do
let(:params) { {
:interface => ['em0', 'em1'],
:description => "TestNet",
:address => ['fc01::/64']
} }
it do
should contain_bsd__network__interface('trunk0').with_parents(['em0', 'em1'])
context 'an example with an address' do
let(:params) do
{
interface: %w(em0 em1),
description: 'TestNet',
address: ['fc01::/64']
}
end
it do
should contain_file('/etc/hostname.trunk0').with_content(
/description \"TestNet\"\ntrunkproto lacp trunkport em0 trunkport em1\ninet6 fc01:: 64\nup\n/)
is_expected.to contain_bsd__network__interface('trunk0').with_parents(%w(em0 em1))
end
it do
is_expected.to contain_file('/etc/hostname.trunk0').with_content(
%r{description \"TestNet\"\ntrunkproto lacp trunkport em0 trunkport em1\ninet6 fc01:: 64\nup\n}
)
end
end
context "an example with multiple addresses" do
let(:params) { {
:interface => ['em0', 'em1'],
:description => "TestNet",
:address => ['fc01::/64', '10.0.0.1/24'],
} }
it do
should contain_bsd__network__interface('trunk0').with_parents(['em0', 'em1'])
context 'an example with multiple addresses' do
let(:params) do
{
interface: %w(em0 em1),
description: 'TestNet',
address: ['fc01::/64', '10.0.0.1/24']
}
end
it do
should contain_file('/etc/hostname.trunk0').with_content(
/description \"TestNet\"\ntrunkproto lacp trunkport em0 trunkport em1\ninet6 fc01:: 64\ninet 10.0.0.1 255.255.255.0 NONE\nup\n/)
is_expected.to contain_bsd__network__interface('trunk0').with_parents(%w(em0 em1))
end
it do
is_expected.to contain_file('/etc/hostname.trunk0').with_content(
%r{description \"TestNet\"\ntrunkproto lacp trunkport em0 trunkport em1\ninet6 fc01:: 64\ninet 10.0.0.1 255.255.255.0 NONE\nup\n}
)
end
end
end
context "when a bad name is used" do
let(:facts) { {:kernel => 'OpenBSD'} }
context 'when a bad name is used' do
let(:facts) { { kernel: 'OpenBSD' } }
let(:title) { 'notcorrect0' }
let(:params) { {:interface => ['em0', 'em1'], :description => "TestNet"} }
let(:params) { { interface: %w(em0 em1), description: 'TestNet' } }
it do
expect {
should contain_bsd__network__interface__trunk('notcorrect0')
}.to raise_error(Puppet::Error, /does not match/)
expect do
is_expected.to contain_bsd__network__interface__trunk('notcorrect0')
end.to raise_error(Puppet::Error, %r{does not match})
end
end
end

110
spec/defines/bsd_network_interface_vlan_spec.rb
View File

@ -1,95 +1,95 @@
require 'spec_helper'
describe "bsd::network::interface::vlan" do
context "on OpenBSD" do
let(:facts) { {:kernel => 'OpenBSD'} }
describe 'bsd::network::interface::vlan' do
context 'on OpenBSD' do
let(:facts) { { kernel: 'OpenBSD' } }
let(:title) { 'vlan0' }
context " a minimal example" do
let(:params) {
context ' a minimal example' do
let(:params) do
{
:id => 1,
:device => 'em0',
:address => ['10.0.0.1/24'],
id: 1,
device: 'em0',
address: ['10.0.0.1/24']
}
}
it do
should contain_bsd__network__interface__vlan('vlan0')
should contain_bsd__network__interface('vlan0').with_parents(['em0'])
should contain_bsd_interface('vlan0')
end
it do
should contain_file('/etc/hostname.vlan0').with_content(/vlan 1 vlandev em0\ninet 10.0.0.1 255.255.255.0 NONE\nup\n/)
is_expected.to contain_bsd__network__interface__vlan('vlan0')
is_expected.to contain_bsd__network__interface('vlan0').with_parents(['em0'])
is_expected.to contain_bsd_interface('vlan0')
end
it do
is_expected.to contain_file('/etc/hostname.vlan0').with_content(%r{vlan 1 vlandev em0\ninet 10.0.0.1 255.255.255.0 NONE\nup\n})
end
end
context " a minimal example with multiple addresses" do
let(:params) {
context ' a minimal example with multiple addresses' do
let(:params) do
{
:id => 1,
:device => 'em0',
:address => [ '10.0.0.1/24', '10.0.0.2/32', ],
id: 1,
device: 'em0',
address: ['10.0.0.1/24', '10.0.0.2/32']
}
}
it do
should contain_bsd__network__interface('vlan0').with_parents(['em0'])
end
it do
should contain_file('/etc/hostname.vlan0').with_content(/vlan 1 vlandev em0\ninet 10.0.0.1 255.255.255.0 NONE\ninet alias 10.0.0.2 255.255.255.255 NONE\nup\n/)
is_expected.to contain_bsd__network__interface('vlan0').with_parents(['em0'])
end
it do
is_expected.to contain_file('/etc/hostname.vlan0').with_content(%r{vlan 1 vlandev em0\ninet 10.0.0.1 255.255.255.0 NONE\ninet alias 10.0.0.2 255.255.255.255 NONE\nup\n})
end
end
context " a bit more extensive example with values set" do
let(:params) {
context ' a bit more extensive example with values set' do
let(:params) do
{
:id => 1,
:device => 'em0',
:address => ['10.0.0.1/24'],
:raw_values => ['!route add -net 10.10.10.0/24 10.0.0.254'],
id: 1,
device: 'em0',
address: ['10.0.0.1/24'],
raw_values: ['!route add -net 10.10.10.0/24 10.0.0.254']
}
}
it do
should contain_bsd__network__interface('vlan0').with_parents(['em0'])
end
it do
should contain_file('/etc/hostname.vlan0').with_content(/vlan 1 vlandev em0\ninet 10.0.0.1 255.255.255.0 NONE\n!route add -net 10.10.10.0\/24 10.0.0.254\nup\n/)
is_expected.to contain_bsd__network__interface('vlan0').with_parents(['em0'])
end
it do
is_expected.to contain_file('/etc/hostname.vlan0').with_content(/vlan 1 vlandev em0\ninet 10.0.0.1 255.255.255.0 NONE\n!route add -net 10.10.10.0\/24 10.0.0.254\nup\n/)
end
end
end
context "when a bad name is used" do
let(:facts) { {:kernel => 'OpenBSD'} }
context 'when a bad name is used' do
let(:facts) { { kernel: 'OpenBSD' } }
let(:title) { 'notcorrect0' }
let(:params) {
let(:params) do
{
:id => 1,
:device => 'em0',
:address => ['10.0.0.1/24'],
id: 1,
device: 'em0',
address: ['10.0.0.1/24']
}
}
end
it do
expect {
should contain_bsd__network__interface__vlan('notcorrect0')
}.to raise_error(Puppet::Error, /does not match/)
expect do
is_expected.to contain_bsd__network__interface__vlan('notcorrect0')
end.to raise_error(Puppet::Error, %r{does not match})
end
end
context "on FreeBSD" do
let(:facts) { {:kernel => 'FreeBSD'} }
context 'on FreeBSD' do
let(:facts) { { kernel: 'FreeBSD' } }
let(:title) { 'vlan0' }
context " a minimal example" do
let(:params) {
context ' a minimal example' do
let(:params) do
{
:id => 1,
:device => 'em0',
:address => ['10.0.0.1/24'],
id: 1,
device: 'em0',
address: ['10.0.0.1/24']
}
}
it do
should contain_bsd__network__interface('vlan0').with_parents(['em0'])
end
it do
should contain_bsd__network__interface('vlan0').with_options(['vlan 1', 'vlandev em0'])
is_expected.to contain_bsd__network__interface('vlan0').with_parents(['em0'])
end
it do
should contain_bsd__network__interface('vlan0').with_raw_values(['10.0.0.1/24'])
is_expected.to contain_bsd__network__interface('vlan0').with_options(['vlan 1', 'vlandev em0'])
end
it do
is_expected.to contain_bsd__network__interface('vlan0').with_raw_values(['10.0.0.1/24'])
end
end
end

91
spec/defines/bsd_network_interface_wifi_spec.rb
View File

@ -1,63 +1,62 @@
require 'spec_helper'
describe "bsd::network::interface::wifi" do
let(:facts) { {:kernel => 'OpenBSD'} }
describe 'bsd::network::interface::wifi' do
let(:facts) { { kernel: 'OpenBSD' } }
let(:title) { 'athn0' }
context "with minimal parameters" do
let(:params) { {:network_name => 'myssid', :wpa_key => 'mysecretkey'} }
context 'with minimal parameters' do
let(:params) { { network_name: 'myssid', wpa_key: 'mysecretkey' } }
it do
should contain_file('/etc/hostname.athn0').with_content(/nwid myssid wpakey mysecretkey\nup/)
should contain_bsd__network__interface__wifi('athn0')
should contain_bsd__network__interface('athn0')
should contain_bsd_interface('athn0')
is_expected.to contain_file('/etc/hostname.athn0').with_content(%r{nwid myssid wpakey mysecretkey\nup})
is_expected.to contain_bsd__network__interface__wifi('athn0')
is_expected.to contain_bsd__network__interface('athn0')
is_expected.to contain_bsd_interface('athn0')
end
end
context "with more parameters" do
let(:params) { {:network_name => 'myssid',
:wpa_key => 'mysecretkey',
:description => 'something good',
:address => [
'10.23.4.56/16',
'2001:471:4336:ff::1/64',
],
:options => [
'chan 1',
'media OFDM54',
'mode 11g',
'mediaopt hostap',
]
}
}
context 'with more parameters' do
let(:params) do
{ network_name: 'myssid',
wpa_key: 'mysecretkey',
description: 'something good',
address: [
'10.23.4.56/16',
'2001:471:4336:ff::1/64'
],
options: [
'chan 1',
'media OFDM54',
'mode 11g',
'mediaopt hostap'
] }
end
it do
should_content = "inet 10.23.4.56 255.255.0.0 NONE\ninet6 2001:471:4336:ff::1 64\nnwid myssid wpakey mysecretkey chan 1 media OFDM54 mode 11g mediaopt hostap description \"something good\"\nup"
should contain_file('/etc/hostname.athn0').with_content(/#{should_content}/)
should_content = "inet 10.23.4.56 255.255.0.0 NONE\ninet6 2001:471:4336:ff::1 64\nnwid myssid wpakey mysecretkey chan 1 media OFDM54 mode 11g mediaopt hostap description \"something good\"\nup"
is_expected.to contain_file('/etc/hostname.athn0').with_content(%r{#{should_content}})
end
end
context " a bit more extensive example with values set" do
let(:params) { {:network_name => 'myssid',
:wpa_key => 'mysecretkey',
:description => 'something good',
:address => [
'10.23.4.56/16',
'2001:471:4336:ff::1/64',
],
:options => [
'chan 1',
'media OFDM54',
'mode 11g',
'mediaopt hostap',
],
:raw_values => '!route add -net 10.10.10.0/24 10.0.0.254',
}
}
context ' a bit more extensive example with values set' do
let(:params) do
{ network_name: 'myssid',
wpa_key: 'mysecretkey',
description: 'something good',
address: [
'10.23.4.56/16',
'2001:471:4336:ff::1/64'
],
options: [
'chan 1',
'media OFDM54',
'mode 11g',
'mediaopt hostap'
],
raw_values: '!route add -net 10.10.10.0/24 10.0.0.254' }
end
it do
should_content = "inet 10.23.4.56 255.255.0.0 NONE\ninet6 2001:471:4336:ff::1 64\nnwid myssid wpakey mysecretkey chan 1 media OFDM54 mode 11g mediaopt hostap description \"something good\"\n!route add -net 10.10.10.0\/24 10.0.0.254\nup"
should contain_file('/etc/hostname.athn0').with_content(/#{should_content}/)
should_content = "inet 10.23.4.56 255.255.0.0 NONE\ninet6 2001:471:4336:ff::1 64\nnwid myssid wpakey mysecretkey chan 1 media OFDM54 mode 11g mediaopt hostap description \"something good\"\n!route add -net 10.10.10.0\/24 10.0.0.254\nup"
is_expected.to contain_file('/etc/hostname.athn0').with_content(%r{#{should_content}})
end
end
end

33
spec/functions/get_freebsd_rc_conf_shellvar_spec.rb
View File

@ -1,45 +1,44 @@
describe 'get_freebsd_rc_conf_shellvar' do
context 'setting only the mtu' do
hash = {
'ifconfig_re0' => {
'value' => 'mtu 9000',
},
'value' => 'mtu 9000'
}
}
c = {
"name" => 're0',
"mtu" => 9000,
'name' => 're0',
'mtu' => 9000
}
it { should run.with_params(c).and_return(hash) }
it { is_expected.to run.with_params(c).and_return(hash) }
end
context 'a full example' do
hash = {
'ifconfig_re0' => {
'value' => 'inet 10.0.1.12/24 mtu 9000',
'value' => 'inet 10.0.1.12/24 mtu 9000'
},
'ifconfig_re0_alias0' => {
'value' => 'inet 10.0.1.13/24',
'value' => 'inet 10.0.1.13/24'
},
'ifconfig_re0_alias1' => {
'value' => 'inet 10.0.1.14/24',
},
'value' => 'inet 10.0.1.14/24'
}
}
full = {
"name" => 're0',
"description" => "Uplink",
"addresses" => [
'name' => 're0',
'description' => 'Uplink',
'addresses' => [
'10.0.1.12/24',
'10.0.1.13/24',
'10.0.1.14/24',
'10.0.1.14/24'
],
"options" => [
'mtu 9000',
'options' => [
'mtu 9000'
]
}
it { should run.with_params(full).and_return(hash) }
it { is_expected.to run.with_params(full).and_return(hash) }
end
end

29
spec/functions/get_openbsd_hostname_if_content_spec.rb
View File

@ -1,32 +1,31 @@
require 'spec_helper'
describe "get_openbsd_hostname_if_content" do
context "with mtu set" do
describe 'get_openbsd_hostname_if_content' do
context 'with mtu set' do
config = {
"name" => 'em0',
"mtu" => 9000,
'name' => 'em0',
'mtu' => 9000
}
it { should run.with_params(config).and_return("mtu 9000") }
it { is_expected.to run.with_params(config).and_return('mtu 9000') }
end
context "with an address set" do
context 'with an address set' do
config = {
"name" => 'em0',
"addresses" => ['fc01::/64'],
'name' => 'em0',
'addresses' => ['fc01::/64']
}
it { should run.with_params(config).and_return("inet6 fc01:: 64") }
it { is_expected.to run.with_params(config).and_return('inet6 fc01:: 64') }
end
context "tun interface" do
context 'tun interface' do
config = {
"name" => 'tun0',
"type" => 'tun',
"raw_values" => ['up','!/usr/local/bin/openvpn'],
'name' => 'tun0',
'type' => 'tun',
'raw_values' => ['up', '!/usr/local/bin/openvpn']
}
it { should run.with_params(config).and_return("up\n!/usr/local/bin/openvpn") }
it { is_expected.to run.with_params(config).and_return("up\n!/usr/local/bin/openvpn") }
end
end

18
spec/functions/get_rc_conf_vlan_spec.rb
View File

@ -2,17 +2,17 @@ require 'spec_helper'
describe 'get_rc_conf_vlan' do
context 'with a simple config' do
desired = ["vlan 1", "vlandev em0"]
desired = ['vlan 1', 'vlandev em0']
config = {
"name" => 'vlan1',
"description" => "Trees",
"device" => 'em0',
"id" => 1,
"address" => [
'10.0.1.12/24',
],
'name' => 'vlan1',
'description' => 'Trees',
'device' => 'em0',
'id' => 1,
'address' => [
'10.0.1.12/24'
]
}
it { should run.with_params(config).and_return(desired) }
it { is_expected.to run.with_params(config).and_return(desired) }
end
end

44
spec/unit/bsd/hostname_if/carp_spec.rb
View File

@ -5,40 +5,38 @@ describe 'Carp' do
describe 'initialize' do
context 'when minimal configuration is passed' do
it 'should not error' do
expect {
subject.new({
:id => '1',
:device => 'em0',
:address => ['10.0.0.1/24'],
})
}.to_not raise_error
it 'does not error' do
expect do
subject.new(id: '1',
device: 'em0',
address: ['10.0.0.1/24'])
end.not_to raise_error
end
end
end
describe 'content' do
it 'should support a full example' do
it 'supports a full example' do
c = {
:id => '1',
:device => 'em0',
:address => ['10.0.0.1/24'],
:advbase => '1',
:advskew => '0',
:pass => 'TopSecret',
id: '1',
device: 'em0',
address: ['10.0.0.1/24'],
advbase: '1',
advskew: '0',
pass: 'TopSecret'
}
expect(subject.new(c).content).to match(/vhid 1 pass TopSecret carpdev em0 advbase 1 advskew 0\ninet 10.0.0.1 255.255.255.0 NONE/)
expect(subject.new(c).content).to match(%r{vhid 1 pass TopSecret carpdev em0 advbase 1 advskew 0\ninet 10.0.0.1 255.255.255.0 NONE})
end
it 'should support a partial example' do
it 'supports a partial example' do
c = {
:id => '1',
:device => 'em0',
:address => ['10.0.0.1/24'],
:advbase => '1',
:advskew => '0',
id: '1',
device: 'em0',
address: ['10.0.0.1/24'],
advbase: '1',
advskew: '0'
}
expect(subject.new(c).content).to match(/vhid 1 carpdev em0 advbase 1 advskew 0\ninet 10.0.0.1 255.255.255.0 NONE/)
expect(subject.new(c).content).to match(%r{vhid 1 carpdev em0 advbase 1 advskew 0\ninet 10.0.0.1 255.255.255.0 NONE})
end
end
end

62
spec/unit/bsd/hostname_if/inet_spec.rb
View File

@ -2,76 +2,76 @@ require 'puppet_x/bsd/hostname_if/inet'
describe 'PuppetX::BSD::Hostname_if::Inet' do
describe 'initialize' do
it "should raise an error if argument is not of correct type" do
a = {:one => '1'}
it 'raises an error if argument is not of correct type' do
a = { one: '1' }
expect { PuppetX::BSD::Hostname_if::Inet.new(a) }.to raise_error
end
it "should not raise an error if argument is of correct type" do
it 'does not raise an error if argument is of correct type' do
a = ['10.0.0.0/24']
expect { PuppetX::BSD::Hostname_if::Inet.new(a) }.to_not raise_error
expect { PuppetX::BSD::Hostname_if::Inet.new(a) }.not_to raise_error
b = '10.0.0.0/24'
expect { PuppetX::BSD::Hostname_if::Inet.new(b) }.to_not raise_error
expect { PuppetX::BSD::Hostname_if::Inet.new(b) }.not_to raise_error
end
end
describe 'process' do
context 'On OpenBSD 5.6' do
it "should yield the the dynamic addressing is specified for all AF with rtsol" do
a = [
'dhcp',
'rtsol',
]
it 'yields the the dynamic addressing is specified for all AF with rtsol' do
a = %w(
dhcp
rtsol
)
expect(Facter).to receive(:value).with('kernelversion').at_least(:once).and_return('5.6')
expect {|b|
expect do |b|
PuppetX::BSD::Hostname_if::Inet.new(a).process(&b)
}.to yield_successive_args('dhcp','rtsol')
end.to yield_successive_args('dhcp', 'rtsol')
end
it "should yield the the dynamic addressing is specified for all AF with inet6 autoconf" do
it 'yields the the dynamic addressing is specified for all AF with inet6 autoconf' do
a = [
'dhcp',
'inet6 autoconf',
'inet6 autoconf'
]
expect(Facter).to receive(:value).with('kernelversion').at_least(:once).and_return('5.6')
expect {|b|
expect do |b|
PuppetX::BSD::Hostname_if::Inet.new(a).process(&b)
}.to yield_successive_args('dhcp','rtsol')
end.to yield_successive_args('dhcp', 'rtsol')
end
end
context 'On OpenBSD 5.7' do
it "should yield the the dynamic addressing is specified for all AF with rtsol" do
a = [
'dhcp',
'rtsol',
]
it 'yields the the dynamic addressing is specified for all AF with rtsol' do
a = %w(
dhcp
rtsol
)
expect(Facter).to receive(:value).with('kernelversion').at_least(:once).and_return('5.7')
expect {|b|
expect do |b|
PuppetX::BSD::Hostname_if::Inet.new(a).process(&b)
}.to yield_successive_args('dhcp','inet6 autoconf')
end.to yield_successive_args('dhcp', 'inet6 autoconf')
end
it "should yield the the dynamic addressing is specified for all AF with inet6 autoconf" do
it 'yields the the dynamic addressing is specified for all AF with inet6 autoconf' do
a = [
'dhcp',
'inet6 autoconf',
'inet6 autoconf'
]
expect(Facter).to receive(:value).with('kernelversion').at_least(:once).and_return('5.7')
expect {|b|
expect do |b|
PuppetX::BSD::Hostname_if::Inet.new(a).process(&b)
}.to yield_successive_args('dhcp','inet6 autoconf')
end.to yield_successive_args('dhcp', 'inet6 autoconf')
end
end
it "should yield multiple addresses when specified" do
it 'yields multiple addresses when specified' do
a = [
'123.123.123.123/29',
'172.16.0.1/27',
'fc01::/7',
'2001:100:fed:beef::/64',
'2001:100:fed:beef::/64'
]
expect {|b|
expect do |b|
PuppetX::BSD::Hostname_if::Inet.new(a).process(&b)
}.to yield_successive_args(
end.to yield_successive_args(
'inet 123.123.123.123 255.255.255.248 NONE',
'inet alias 172.16.0.1 255.255.255.224 NONE',
'inet6 fc01:: 7',

14
spec/unit/bsd/hostname_if/pfsync_spec.rb
View File

@ -4,17 +4,17 @@ describe 'Pfsync' do
subject(:pfif) { Hostname_if::Pfsync }
describe 'content' do
it 'should support a minimal example' do
c = { }
expect(pfif.new(c).content).to match(/-syncdev -syncpeer maxupd 128 -defer/)
it 'supports a minimal example' do
c = {}
expect(pfif.new(c).content).to match(%r{-syncdev -syncpeer maxupd 128 -defer})
end
it 'should support a partial example' do
it 'supports a partial example' do
c = {
:syncdev => 'em0',
:syncpeer => '10.0.0.222',
syncdev: 'em0',
syncpeer: '10.0.0.222'
}
expect(pfif.new(c).content).to match(/syncdev em0 syncpeer 10.0.0.222 maxupd 128 -defer/)
expect(pfif.new(c).content).to match(%r{syncdev em0 syncpeer 10.0.0.222 maxupd 128 -defer})
end
end
end

26
spec/unit/bsd/hostname_if/trunk_spec.rb
View File

@ -4,25 +4,25 @@ describe 'Trunk' do
subject(:trunkif) { Hostname_if::Trunk }
describe 'content' do
it 'should support a full example' do
it 'supports a full example' do
c = {
:proto => 'lacp',
:interface => ['em0'],
proto: 'lacp',
interface: ['em0']
}
expect(trunkif.new(c).content).to match(/trunkproto lacp trunkport em0/)
expect(trunkif.new(c).content).to match(%r{trunkproto lacp trunkport em0})
end
it 'should support a partial example' do
it 'supports a partial example' do
c = {
:proto => 'lacp',
:interface => [
'em0',
'em1',
'em2',
'em3',
]
proto: 'lacp',
interface: %w(
em0
em1
em2
em3
)
}
expect(trunkif.new(c).content).to match(/trunkproto lacp trunkport em0 trunkport em1 trunkport em2 trunkport em3/)
expect(trunkif.new(c).content).to match(%r{trunkproto lacp trunkport em0 trunkport em1 trunkport em2 trunkport em3})
end
end
end

64
spec/unit/bsd/hostname_if/vlan_spec.rb
View File

@ -4,50 +4,50 @@ describe 'Vlan' do
subject(:vlanif) { Hostname_if::Vlan }
describe 'content' do
it 'should support a full example' do
it 'supports a full example' do
c = {
:id => 1,
:device => 'em0',
:address => ['10.0.0.1/24'],
id: 1,
device: 'em0',
address: ['10.0.0.1/24']
}
wanted = [
'vlan 1 vlandev em0',
'inet 10.0.0.1 255.255.255.0 NONE',
'vlan 1 vlandev em0',
'inet 10.0.0.1 255.255.255.0 NONE'
]
expect(vlanif.new(c).content).to match(wanted.join('\n'))
end
it 'should support a partial example' do
it 'supports a partial example' do
c = {
:id => 1,
:device => 'em0',
:address => ['10.0.0.1/24'],
id: 1,
device: 'em0',
address: ['10.0.0.1/24']
}
wanted = [
'vlan 1 vlandev em0',
'inet 10.0.0.1 255.255.255.0 NONE',
'vlan 1 vlandev em0',
'inet 10.0.0.1 255.255.255.0 NONE'
]
expect(vlanif.new(c).content).to match(wanted.join('\n'))
end
it 'should support a allow an array of addresses' do
it 'supports a allow an array of addresses' do
c = {
:id => 1,
:device => 'em0',
:address => [
id: 1,
device: 'em0',
address: [
'10.0.0.1/24',
'10.1.0.1/24',
'fc00:1::/64',
'fc00:2::/64',
'fc00:2::/64'
]
}
wanted = [
'vlan 1 vlandev em0',
'inet 10.0.0.1 255.255.255.0 NONE',
'inet alias 10.1.0.1 255.255.255.0 NONE',
'inet6 fc00:1:: 64',
'inet6 alias fc00:2:: 64'
'vlan 1 vlandev em0',
'inet 10.0.0.1 255.255.255.0 NONE',
'inet alias 10.1.0.1 255.255.255.0 NONE',
'inet6 fc00:1:: 64',
'inet6 alias fc00:2:: 64'
]
expect(vlanif.new(c).content).to match(wanted.join('\n'))
@ -55,23 +55,23 @@ describe 'Vlan' do
end
describe '#values' do
it 'should return a list of values for a full example' do
it 'returns a list of values for a full example' do
c = {
:id => 1,
:device => 'em0',
:address => [
id: 1,
device: 'em0',
address: [
'10.0.0.1/24',
'10.1.0.1/24',
'fc00:1::/64',
'fc00:2::/64',
'fc00:2::/64'
]
}
wanted = [
'vlan 1 vlandev em0',
'inet 10.0.0.1 255.255.255.0 NONE',
'inet alias 10.1.0.1 255.255.255.0 NONE',
'inet6 fc00:1:: 64',
'inet6 alias fc00:2:: 64'
'vlan 1 vlandev em0',
'inet 10.0.0.1 255.255.255.0 NONE',
'inet alias 10.1.0.1 255.255.255.0 NONE',
'inet6 fc00:1:: 64',
'inet6 alias fc00:2:: 64'
]
expect(vlanif.new(c).values).to match_array(wanted)

33
spec/unit/bsd/hostname_if/wifi_spec.rb
View File

@ -4,37 +4,36 @@ describe 'Wifi' do
subject(:wifiif) { Hostname_if::Wifi }
describe 'content' do
it 'should support a minimal example' do
it 'supports a minimal example' do
c = {
:network_name => 'myssid',
network_name: 'myssid'
}
expect(wifiif.new(c).content).to match(/nwid myssid/)
expect(wifiif.new(c).content).to match(%r{nwid myssid})
end
it 'should support a minimal example with dhcp' do
it 'supports a minimal example with dhcp' do
c = {
:network_name => 'myssid',
:address => ['dhcp'],
network_name: 'myssid',
address: ['dhcp']
}
expect(wifiif.new(c).content).to match(/dhcp\nnwid myssid/)
expect(wifiif.new(c).content).to match(%r{dhcp\nnwid myssid})
end
it 'should support a partial example' do
it 'supports a partial example' do
c = {
:network_name => 'myssid',
:wpa_key => 'mykey',
network_name: 'myssid',
wpa_key: 'mykey'
}
expect(wifiif.new(c).content).to match(/nwid myssid wpakey mykey/)
expect(wifiif.new(c).content).to match(%r{nwid myssid wpakey mykey})
end
it 'should support a full example' do
it 'supports a full example' do
c = {
:network_name => 'myssid',
:wpa_key => 'mykey',
:address => ['10.0.0.1/24'],
network_name: 'myssid',
wpa_key: 'mykey',
address: ['10.0.0.1/24']
}
expect(wifiif.new(c).content).to match(/inet 10.0.0.1 255.255.255.0 NONE\nnwid myssid wpakey mykey/)
expect(wifiif.new(c).content).to match(%r{inet 10.0.0.1 255.255.255.0 NONE\nnwid myssid wpakey mykey})
end
end
end

233
spec/unit/bsd/hostname_if_spec.rb
View File

@ -5,232 +5,231 @@ describe 'Hostname_if' do
describe 'initialize' do
context 'when minimal configuration is passed' do
it 'should not error' do
expect { hif.new({:desc => 'String goes here'}) }.to_not raise_error
it 'does not error' do
expect { hif.new(desc: 'String goes here') }.not_to raise_error
end
end
end
describe "content" do
it "should append the options string on the first line when options are present" do
describe 'content' do
it 'appends the options string on the first line when options are present' do
c = {
:options => ["mtu 1500"]
options: ['mtu 1500']
}
expect(hif.new(c).content.split("\n").first).to match(/mtu 1500/)
expect(hif.new(c).content.split("\n").first).to match(%r{mtu 1500})
end
it "should append multiple options on the first line when multiple options are present" do
it 'appends multiple options on the first line when multiple options are present' do
c = {
:options => [
"mtu 1500",
"media 100baseTX",
],
options: [
'mtu 1500',
'media 100baseTX'
]
}
expect(hif.new(c).content.split("\n").first).to match(/mtu 1500/)
expect(hif.new(c).content.split("\n").first).to match(/media 100baseTX/)
expect(hif.new(c).content.split("\n").first).to match(%r{mtu 1500})
expect(hif.new(c).content.split("\n").first).to match(%r{media 100baseTX})
end
it "should append multiple options on the first line with a description" do
it 'appends multiple options on the first line with a description' do
c = {
:desc => "Default interface",
:options => [
"mtu 1500",
"media 100baseTX",
],
desc: 'Default interface',
options: [
'mtu 1500',
'media 100baseTX'
]
}
expect(hif.new(c).content.split("\n").first).to match(/mtu 1500/)
expect(hif.new(c).content.split("\n").first).to match(/media 100baseTX/)
expect(hif.new(c).content.split("\n").first).to match(/Default interface/)
expect(hif.new(c).content.split("\n").first).to match(%r{mtu 1500})
expect(hif.new(c).content.split("\n").first).to match(%r{media 100baseTX})
expect(hif.new(c).content.split("\n").first).to match(%r{Default interface})
end
it "should set the the dynamic property of the interface is specified" do
it 'sets the the dynamic property of the interface is specified' do
c = {
:raw_values => ['dhcp'],
raw_values: ['dhcp']
}
expect(hif.new(c).content).to match(/^dhcp/)
expect(hif.new(c).content).to match(%r{^dhcp})
end
context 'with rtsol given for IPv6' do
it "should set the the dynamic property of the interface is specified for all AF setting inet6 autoconf for rtsol" do
it 'sets the the dynamic property of the interface is specified for all AF setting inet6 autoconf for rtsol' do
c = {
:raw_values => [
'dhcp',
'rtsol',
]
raw_values: %w(
dhcp
rtsol
)
}
expect(hif.new(c).content).to match(/^dhcp/)
expect(hif.new(c).content).to match(/^rtsol/)
expect(hif.new(c).content).to match(%r{^dhcp})
expect(hif.new(c).content).to match(%r{^rtsol})
end
end
it "should set the primary interface address and prefix" do
it 'sets the primary interface address and prefix' do
c = {
:raw_values => ['fc01::/7'],
raw_values: ['fc01::/7']
}
expect(hif.new(c).content).to match(/fc01:: 7/)
expect(hif.new(c).content).to match(%r{fc01:: 7})
end
it "should set multiple interface addresses" do
it 'sets multiple interface addresses' do
c = {
:raw_values => [
raw_values: [
'123.123.123.123/29',
'172.16.0.1/27',
'fc01::/7',
'2001:100:fed:beef::/64',
'2001:100:fed:beef::/64'
]
}
expect(hif.new(c).content).to match(/inet 123.123.123.123 255.255.255.248 NONE/)
expect(hif.new(c).content).to match(/inet alias 172.16.0.1 255.255.255.224 NONE/)
expect(hif.new(c).content).to match(/inet6 fc01:: 7/)
expect(hif.new(c).content).to match(/inet6 alias 2001:100:fed:beef:: 64/)
expect(hif.new(c).content).to match(%r{inet 123.123.123.123 255.255.255.248 NONE})
expect(hif.new(c).content).to match(%r{inet alias 172.16.0.1 255.255.255.224 NONE})
expect(hif.new(c).content).to match(%r{inet6 fc01:: 7})
expect(hif.new(c).content).to match(%r{inet6 alias 2001:100:fed:beef:: 64})
end
it "should set everything when provided" do
it 'sets everything when provided' do
c = {
:desc => "Default interface",
:options => [
"mtu 1500",
"media 100baseTX",
desc: 'Default interface',
options: [
'mtu 1500',
'media 100baseTX'
],
:raw_values => [
raw_values: [
'123.123.123.123/29',
'172.16.0.1/27',
'fc01::/7',
'2001:100:fed:beef::/64',
'2001:100:fed:beef::/64'
]
}
expect(hif.new(c).content).to match(/inet 123.123.123.123 255.255.255.248 NONE/)
expect(hif.new(c).content).to match(/inet alias 172.16.0.1 255.255.255.224 NONE/)
expect(hif.new(c).content).to match(/inet6 fc01:: 7/)
expect(hif.new(c).content).to match(/inet6 alias 2001:100:fed:beef:: 64/)
expect(hif.new(c).content.split("\n").first).to match(/mtu 1500/)
expect(hif.new(c).content.split("\n").first).to match(/media 100baseTX/)
expect(hif.new(c).content.split("\n").first).to match(/Default interface/)
expect(hif.new(c).content).to match(%r{inet 123.123.123.123 255.255.255.248 NONE})
expect(hif.new(c).content).to match(%r{inet alias 172.16.0.1 255.255.255.224 NONE})
expect(hif.new(c).content).to match(%r{inet6 fc01:: 7})
expect(hif.new(c).content).to match(%r{inet6 alias 2001:100:fed:beef:: 64})
expect(hif.new(c).content.split("\n").first).to match(%r{mtu 1500})
expect(hif.new(c).content.split("\n").first).to match(%r{media 100baseTX})
expect(hif.new(c).content.split("\n").first).to match(%r{Default interface})
end
it "should clear the description string when called multiple times" do
it 'clears the description string when called multiple times' do
c = {
:desc => "Default interface",
:options => [
"mtu 1500",
"media 100baseTX",
desc: 'Default interface',
options: [
'mtu 1500',
'media 100baseTX'
],
:raw_values => [
raw_values: [
'123.123.123.123/29',
'172.16.0.1/27',
'fc01::/7',
'2001:100:fed:beef::/64',
'2001:100:fed:beef::/64'
]
}
expect(hif.new(c).content.split("\n").first).to_not match(/Default interface.*Default interface/)
expect(hif.new(c).content.split("\n").first).to_not match(/Default interface.*Default interface/)
expect(hif.new(c).content.split("\n").first).to_not match(/Default interface.*Default interface/)
expect(hif.new(c).content.split("\n").first).not_to match(%r{Default interface.*Default interface})
expect(hif.new(c).content.split("\n").first).not_to match(%r{Default interface.*Default interface})
expect(hif.new(c).content.split("\n").first).not_to match(%r{Default interface.*Default interface})
end
it "should not raise error when options are :udnef" do
it 'does not raise error when options are :udnef' do
c = {
:desc => :undef,
:options => :undef,
:raw_values => [
desc: :undef,
options: :undef,
raw_values: [
'123.123.123.123/29',
'172.16.0.1/27',
'fc01::/7',
'2001:100:fed:beef::/64',
'2001:100:fed:beef::/64'
]
}
expect { hif.new(c).content }.to_not raise_error
expect { hif.new(c).content }.not_to raise_error
end
it "should support setting the interface to up" do
it 'supports setting the interface to up' do
c = {
:raw_values => [
'up',
raw_values: [
'up'
]
}
expect(hif.new(c).content).to match(/^up/)
expect(hif.new(c).content).to match(%r{^up})
end
it "should support setting the interface to down" do
it 'supports setting the interface to down' do
c = {
:raw_values => [
'down',
raw_values: [
'down'
]
}
expect(hif.new(c).content).to match(/^down/)
expect(hif.new(c).content).to match(%r{^down})
end
it "should support setting the interface to up and setting the description" do
it 'supports setting the interface to up and setting the description' do
c = {
:desc => "I am an interface",
:raw_values => [
'up',
desc: 'I am an interface',
raw_values: [
'up'
]
}
expect(hif.new(c).content).to match(/^description "I am an interface"\nup/)
expect(hif.new(c).content).to match(%r{^description "I am an interface"\nup})
end
it "should support the !command syntax in the hostname.if(5) manpage" do
it 'supports the !command syntax in the hostname.if(5) manpage' do
c = {
:desc => "Uplink",
:raw_values => [
desc: 'Uplink',
raw_values: [
'10.0.1.12/24',
'10.0.1.13/24',
'10.0.1.14/24',
'10.0.1.15/24',
'10.0.1.16/24',
'!route add 65.65.65.65 10.0.1.13',
'up',
'up'
],
:options => [
options: [
'media 100baseTX'
]
}
expect(hif.new(c).content).to match(/10.0.1.12 255.255.255.0/)
expect(hif.new(c).content).to match(/10.0.1.13 255.255.255.0/)
expect(hif.new(c).content).to match(/10.0.1.14 255.255.255.0/)
expect(hif.new(c).content).to match(/10.0.1.15 255.255.255.0/)
expect(hif.new(c).content).to match(/10.0.1.16 255.255.255.0/)
expect(hif.new(c).content).to match(/^!route add 65.65.65.65 10.0.1.13$/)
expect(hif.new(c).content).to match(/^up$/)
expect(hif.new(c).content).to match(/media 100baseTX/)
expect(hif.new(c).content).to match(/description "?Uplink"?/)
expect(hif.new(c).content).to match(%r{10.0.1.12 255.255.255.0})
expect(hif.new(c).content).to match(%r{10.0.1.13 255.255.255.0})
expect(hif.new(c).content).to match(%r{10.0.1.14 255.255.255.0})
expect(hif.new(c).content).to match(%r{10.0.1.15 255.255.255.0})
expect(hif.new(c).content).to match(%r{10.0.1.16 255.255.255.0})
expect(hif.new(c).content).to match(%r{^!route add 65.65.65.65 10.0.1.13$})
expect(hif.new(c).content).to match(%r{^up$})
expect(hif.new(c).content).to match(%r{media 100baseTX})
expect(hif.new(c).content).to match(%r{description "?Uplink"?})
end
it "should fail when the type is not a string" do
it 'fails when the type is not a string' do
c = {
:type => ['gif'],
:desc => "I am a tunnel interface",
:raw_values => [
'up',
type: ['gif'],
desc: 'I am a tunnel interface',
raw_values: [
'up'
]
}
expect { hif.new(c).content }.to raise_error(ArgumentError, /Config option.*must be a String/)
expect { hif.new(c).content }.to raise_error(ArgumentError, %r{Config option.*must be a String})
end
it "should support the gre interface type" do
it 'supports the gre interface type' do
c = {
:type => 'gre',
:raw_values => [
type: 'gre',
raw_values: [
'192.168.100.1 192.168.100.2 netmask 0xffffffff link0 up',
'tunnel 10.0.1.30 10.0.1.31',
'tunnel 10.0.1.30 10.0.1.31'
]
}
expect(hif.new(c).content).to match(/192.168.100.1 192.168.100.2 netmask 0xffffffff link0 up/)
expect(hif.new(c).content).to match(/tunnel 10.0.1.30 10.0.1.31/)
expect(hif.new(c).content).to match(%r{192.168.100.1 192.168.100.2 netmask 0xffffffff link0 up})
expect(hif.new(c).content).to match(%r{tunnel 10.0.1.30 10.0.1.31})
end
it "should support the tun interface type" do
it 'supports the tun interface type' do
c = {
:type => 'tun',
:raw_values => [
type: 'tun',
raw_values: [
'up',
'!/usr/local/sbin/openvpn --daemon --config /etc/openvpn/vpn.ovpn --cd /etc/openvpn',
'!/usr/local/sbin/openvpn --daemon --config /etc/openvpn/vpn.ovpn --cd /etc/openvpn'
]
}
content = hif.new(c).content
expect(content).to match(/^up$/)
expect(content).to match(%r{^up$})
expect(content).to match(/^!\/usr\/local\/sbin\/openvpn/)
end
end
end

85
spec/unit/bsd/ifconfig_spec.rb
View File

@ -1,78 +1,75 @@
require 'puppet_x/bsd/ifconfig'
describe 'PuppetX::BSD::Ifconfig' do
context "on OpenBSD" do
context 'on OpenBSD' do
context '#parse' do
it "should return the desired hash for a single interface" do
output = File.read("spec/fixtures/ifconfig_openbsd.em.up")
it 'returns the desired hash for a single interface' do
output = File.read('spec/fixtures/ifconfig_openbsd.em.up')
wanted = {:em0=>{:flags=>["UP", "BROADCAST", "RUNNING", "SIMPLEX", "MULTICAST"], :mtu=>"1500", :inet6=>["fe80::200:9999:ffff:6404/64", "2fff:fff:ffff::10:10/64"], :inet=>"10.0.0.10/255.255.255.0"}}
wanted = { em0: { flags: %w(UP BROADCAST RUNNING SIMPLEX MULTICAST), mtu: '1500', inet6: ['fe80::200:9999:ffff:6404/64', '2fff:fff:ffff::10:10/64'], inet: '10.0.0.10/255.255.255.0' } }
expect(PuppetX::BSD::Ifconfig.new(output).parse).to eq(wanted)
end
it "should return the desired hash for a full example" do
output = File.read("spec/fixtures/ifconfig_openbsd.full")
it 'returns the desired hash for a full example' do
output = File.read('spec/fixtures/ifconfig_openbsd.full')
wanted = {:lo0=>{:flags=>["UP", "LOOPBACK", "RUNNING", "MULTICAST"], :mtu=>"32768", :inet6=>["fe80::1/64", "::1/128"], :inet=>"127.0.0.1/255.0.0.0"}, :em0=>{:flags=>["UP", "BROADCAST", "RUNNING", "SIMPLEX", "MULTICAST"], :mtu=>"1500", :inet=>"10.0.31.2/255.255.255.252", :inet6=>["fe80::200:24ff:fed0:6404/64", "2001:1234:abcd:f::10/80"]}, :em1=>{:flags=>["BROADCAST", "SIMPLEX", "MULTICAST"], :mtu=>"1500"}, :em2=>{:flags=>["BROADCAST", "SIMPLEX", "MULTICAST"], :mtu=>"1500"}, :em3=>{:flags=>["BROADCAST", "SIMPLEX", "MULTICAST"], :mtu=>"1500"}, :em4=>{:flags=>["UP", "BROADCAST", "RUNNING", "PROMISC", "ALLMULTI", "SIMPLEX", "MULTICAST"], :mtu=>"1500"}, :em5=>{:flags=>["UP", "BROADCAST", "RUNNING", "PROMISC", "ALLMULTI", "SIMPLEX", "MULTICAST"], :mtu=>"1500"}, :em6=>{:flags=>["UP", "BROADCAST", "RUNNING", "PROMISC", "ALLMULTI", "SIMPLEX", "MULTICAST"], :mtu=>"1500"}, :em7=>{:flags=>["UP", "BROADCAST", "RUNNING", "PROMISC", "ALLMULTI", "SIMPLEX", "MULTICAST"], :mtu=>"1500"}, :vether0=>{:flags=>["UP", "BROADCAST", "RUNNING", "PROMISC", "SIMPLEX", "MULTICAST"], :mtu=>"1500", :inet6=>["fe80::fce1:baff:fed0:7c4d/64", "2001:1234:abcd:0:1::/80", "fc04::/64"], :inet=>"10.0.31.238/255.255.255.240"}, :bridge0=>{:flags=>["UP", "RUNNING"]}, :pflog0=>{:flags=>["UP", "RUNNING", "PROMISC"], :mtu=>"33144"}, :bridge1=>{:flags=>["UP", "RUNNING"]}, :vlan88=>{:flags=>["UP", "BROADCAST", "RUNNING", "SIMPLEX", "MULTICAST"], :mtu=>"1500", :inet6=>["fe80::fce1:baff:fed1:1338/64", "fc05::/64"]}, :vether1=>{:flags=>["UP", "BROADCAST", "RUNNING", "SIMPLEX", "MULTICAST"], :mtu=>"1500"}}
wanted = { lo0: { flags: %w(UP LOOPBACK RUNNING MULTICAST), mtu: '32768', inet6: ['fe80::1/64', '::1/128'], inet: '127.0.0.1/255.0.0.0' }, em0: { flags: %w(UP BROADCAST RUNNING SIMPLEX MULTICAST), mtu: '1500', inet: '10.0.31.2/255.255.255.252', inet6: ['fe80::200:24ff:fed0:6404/64', '2001:1234:abcd:f::10/80'] }, em1: { flags: %w(BROADCAST SIMPLEX MULTICAST), mtu: '1500' }, em2: { flags: %w(BROADCAST SIMPLEX MULTICAST), mtu: '1500' }, em3: { flags: %w(BROADCAST SIMPLEX MULTICAST), mtu: '1500' }, em4: { flags: %w(UP BROADCAST RUNNING PROMISC ALLMULTI SIMPLEX MULTICAST), mtu: '1500' }, em5: { flags: %w(UP BROADCAST RUNNING PROMISC ALLMULTI SIMPLEX MULTICAST), mtu: '1500' }, em6: { flags: %w(UP BROADCAST RUNNING PROMISC ALLMULTI SIMPLEX MULTICAST), mtu: '1500' }, em7: { flags: %w(UP BROADCAST RUNNING PROMISC ALLMULTI SIMPLEX MULTICAST), mtu: '1500' }, vether0: { flags: %w(UP BROADCAST RUNNING PROMISC SIMPLEX MULTICAST), mtu: '1500', inet6: ['fe80::fce1:baff:fed0:7c4d/64', '2001:1234:abcd:0:1::/80', 'fc04::/64'], inet: '10.0.31.238/255.255.255.240' }, bridge0: { flags: %w(UP RUNNING) }, pflog0: { flags: %w(UP RUNNING PROMISC), mtu: '33144' }, bridge1: { flags: %w(UP RUNNING) }, vlan88: { flags: %w(UP BROADCAST RUNNING SIMPLEX MULTICAST), mtu: '1500', inet6: ['fe80::fce1:baff:fed1:1338/64', 'fc05::/64'] }, vether1: { flags: %w(UP BROADCAST RUNNING SIMPLEX MULTICAST), mtu: '1500' } }
expect(PuppetX::BSD::Ifconfig.new(output).parse).to eq(wanted)
end
end
context '#interfaces' do
it "should return the interface list " do
output = File.read("spec/fixtures/ifconfig_openbsd.full")
it 'returns the interface list' do
output = File.read('spec/fixtures/ifconfig_openbsd.full')
should = [ "lo0", "em0", "em1", "em2", "em3", "em4", "em5", "em6",
"em7", "enc0", "vether0", "bridge0", "pflog0", "bridge1",
"vlan88", "vether1" ]
should = %w(lo0 em0 em1 em2 em3 em4 em5 em6
em7 enc0 vether0 bridge0 pflog0 bridge1
vlan88 vether1)
expect(PuppetX::BSD::Ifconfig.new(output).interfaces).to eq(should)
end
end
end
context "on FreeBSD" do
context 'on FreeBSD' do
context '#parse' do
it "should return the desired hash for a single interface" do
output = File.read("spec/fixtures/ifconfig_freebsd.em.up")
it 'returns the desired hash for a single interface' do
output = File.read('spec/fixtures/ifconfig_freebsd.em.up')
wanted = {:em0=>{:flags=>["UP", "BROADCAST", "RUNNING", "SIMPLEX", "MULTICAST"], :metric=>"0", :mtu=>"9000", :inet=>"10.0.0.10/255.255.255.0", :inet6=>["fe80::225:9999:ffff:ac26/64", "2fff:fff:ffff:1ab::10:10/64"]}}
wanted = { em0: { flags: %w(UP BROADCAST RUNNING SIMPLEX MULTICAST), metric: '0', mtu: '9000', inet: '10.0.0.10/255.255.255.0', inet6: ['fe80::225:9999:ffff:ac26/64', '2fff:fff:ffff:1ab::10:10/64'] } }
expect(PuppetX::BSD::Ifconfig.new(output).parse).to eq(wanted)
end
it "should return the desired hash for a full example" do
output = File.read("spec/fixtures/ifconfig_freebsd.full")
it 'returns the desired hash for a full example' do
output = File.read('spec/fixtures/ifconfig_freebsd.full')
wanted = { :igb0 => {:flags=>["UP", "BROADCAST", "RUNNING",
"SIMPLEX", "MULTICAST"],
:metric=>"0", :mtu=>"1500",
:inet=>["10.0.0.21/255.255.255.0",
"10.0.0.124/255.255.255.255",
"10.0.0.125/255.255.255.255"],
:inet6=>["fe80::225:90ff:fe5c:f7cc/64",
"2fff:fff:ffff::100/64",
"2fff:fff:ffff::103/128",
"2fff:fff:ffff::106/128",
"2fff:fff:ffff::5/128",
"2fff:fff:ffff::105/128",
"2fff:fff:ffff::109/128",
"2fff:fff:ffff::7/128"]
}, :igb1 => {:flags=>["BROADCAST", "OACTIVE", "SIMPLEX", "MULTICAST"],
:metric=>"0", :mtu=>"1500" }, :lo0 => {:flags=>["UP",
"LOOPBACK",
"RUNNING",
"MULTICAST"],
:metric=>"0",
:mtu=>"16384",
:inet6=>["::1/128",
"fe80::1/64"],
:inet=>"127.0.0.1/255.0.0.0"
}, }
wanted = { igb0: { flags: %w(UP BROADCAST RUNNING
SIMPLEX MULTICAST),
metric: '0', mtu: '1500',
inet: ['10.0.0.21/255.255.255.0',
'10.0.0.124/255.255.255.255',
'10.0.0.125/255.255.255.255'],
inet6: ['fe80::225:90ff:fe5c:f7cc/64',
'2fff:fff:ffff::100/64',
'2fff:fff:ffff::103/128',
'2fff:fff:ffff::106/128',
'2fff:fff:ffff::5/128',
'2fff:fff:ffff::105/128',
'2fff:fff:ffff::109/128',
'2fff:fff:ffff::7/128'] }, igb1: { flags: %w(BROADCAST OACTIVE SIMPLEX MULTICAST),
metric: '0', mtu: '1500' }, lo0: { flags: %w(UP
LOOPBACK
RUNNING
MULTICAST),
metric: '0',
mtu: '16384',
inet6: ['::1/128',
'fe80::1/64'],
inet: '127.0.0.1/255.0.0.0' } }
expect(PuppetX::BSD::Ifconfig.new(output).parse).to eq(wanted)
end
end
end
end

60
spec/unit/bsd/puppet_interface_spec.rb
View File

@ -1,65 +1,63 @@
require 'spec_helper'
require 'puppet_x/bsd/puppet_interface'
describe 'PuppetX::BSD::PuppetInterface' do
let(:demo_class) {
let(:demo_class) do
class DemoClass < PuppetX::BSD::PuppetInterface
super
options :one, :two, :three
validation :name
end
}
end
context 'configure' do
it 'should fail validation when an array is received' do
it 'fails validation when an array is received' do
c = PuppetX::BSD::PuppetInterface.new
expect{ c.configure([]) }.to raise_error(ArgumentError, /must be a Hash/)
expect { c.configure([]) }.to raise_error(ArgumentError, %r{must be a Hash})
end
it 'should not fail when no options or validation is passed' do
it 'does not fail when no options or validation is passed' do
c = PuppetX::BSD::PuppetInterface.new
expect{ c.configure({}) }.to_not raise_error
expect { c.configure({}) }.not_to raise_error
end
context 'when options are available' do
it 'should return a boring yet valid config' do
it 'returns a boring yet valid config' do
c = PuppetX::BSD::PuppetInterface.new
c.options :one, :two, :three
expect{ c.configure({}) }.to_not raise_error
expect { c.configure({}) }.not_to raise_error
end
end
context 'when validation is required but not present' do
it 'should fail with an ArgumentError' do
it 'fails with an ArgumentError' do
c = PuppetX::BSD::PuppetInterface.new
c.validation :one, :two, :three
expect{ c.configure({}) }.to raise_error(ArgumentError, /required configuration item not found/)
expect { c.configure({}) }.to raise_error(ArgumentError, %r{required configuration item not found})
end
end
context 'when validation is required and present' do
it 'should configure successfully' do
it 'configures successfully' do
c = PuppetX::BSD::PuppetInterface.new
c.validation :one, :two, :three
wanted = {
one: 'itemone',
two: 'itemtwo',
three: 'itemthree',
three: 'itemthree'
}
expect{ c.configure(wanted) }.to_not raise_error
expect { c.configure(wanted) }.not_to raise_error
expect(c.config).to eq(wanted)
end
end
context 'when validation is required and present with options' do
it 'should configure successfully with no options passed' do
it 'configures successfully with no options passed' do
c = PuppetX::BSD::PuppetInterface.new
c.validation :one, :two, :three
c.options :four, :five
@ -67,14 +65,14 @@ describe 'PuppetX::BSD::PuppetInterface' do
config = {
one: 'itemone',
two: 'itemtwo',
three: 'itemthree',
three: 'itemthree'
}
expect{ c.configure(config) }.to_not raise_error
expect { c.configure(config) }.not_to raise_error
expect(c.config).to eq(config)
end
it 'should include options in the config when options are passed' do
it 'includes options in the config when options are passed' do
c = PuppetX::BSD::PuppetInterface.new
c.validation :one, :two, :three
c.options :four, :five
@ -83,16 +81,16 @@ describe 'PuppetX::BSD::PuppetInterface' do
one: 'itemone',
two: 'itemtwo',
three: 'itemthree',
five: 'itemfive',
five: 'itemfive'
}
expect{ c.configure(config) }.to_not raise_error
expect { c.configure(config) }.not_to raise_error
expect(c.config).to eq(config)
end
end
context 'when mutliopts is set' do
it 'should fail when option values are not an array' do
it 'fails when option values are not an array' do
c = PuppetX::BSD::PuppetInterface.new
c.options :one, :two
c.multiopts :one
@ -100,32 +98,32 @@ describe 'PuppetX::BSD::PuppetInterface' do
config = {
one: 'string'
}
expect{ c.configure(config) }.to raise_error(ArgumentError, /Multi-opt one is not an array/)
expect { c.configure(config) }.to raise_error(ArgumentError, %r{Multi-opt one is not an array})
end
it 'should configure when option values are an array' do
it 'configures when option values are an array' do
c = PuppetX::BSD::PuppetInterface.new
c.options :one, :two
c.multiopts :one
config = {
one: ['string', 'stringagain']
one: %w(string stringagain)
}
expect{ c.configure(config) }.to_not raise_error
expect { c.configure(config) }.not_to raise_error
end
end
context 'oneof' do
it 'should fail when oneof config values are not present' do
it 'fails when oneof config values are not present' do
c = PuppetX::BSD::PuppetInterface.new
c.options :one, :two, :three
c.oneof :one, :two
config = {}
expect{ c.configure(config) }.to raise_error(ArgumentError, /At least one of.*is required/)
expect { c.configure(config) }.to raise_error(ArgumentError, %r{At least one of.*is required})
end
it 'should configure when one oneof config value is present' do
it 'configures when one oneof config value is present' do
c = PuppetX::BSD::PuppetInterface.new
c.options :one, :two, :three
c.oneof :one, :two
@ -133,10 +131,8 @@ describe 'PuppetX::BSD::PuppetInterface' do
config = {
one: 'string'
}
expect{ c.configure(config) }.to_not raise_error
expect { c.configure(config) }.not_to raise_error
end
end
end
end

81
spec/unit/bsd/rc_conf/vlan_spec.rb
View File

@ -1,96 +1,95 @@
require 'puppet_x/bsd/rc_conf/vlan'
describe 'Vlan' do
subject(:vlan) { Vlan }
describe 'validation' do
context 'when the config is invalid' do
it 'should fail if no config is supplied' do
it 'fails if no config is supplied' do
c = {}
expect {
expect do
vlan.new(c).content
}.to raise_error(ArgumentError)
end.to raise_error(ArgumentError)
end
it "should raise an error if device is missing" do
it 'raises an error if device is missing' do
c = {
:id => 1,
id: 1
}
expect {
expect do
vlan.new(c).content
}.to raise_error(ArgumentError, /required configuration item not found: device/)
end.to raise_error(ArgumentError, %r{required configuration item not found: device})
end
it "should not raise an error if address is missing" do
it 'does not raise an error if address is missing' do
c = {
:id => 1,
:device => 'em0',
id: 1,
device: 'em0'
}
expect {
expect do
vlan.new(c).content
}.not_to raise_error
end.not_to raise_error
end
it "should not raise an error if address is an empty array" do
it 'does not raise an error if address is an empty array' do
c = {
:id => 1,
:device => 'em0',
:address => [],
id: 1,
device: 'em0',
address: []
}
expect {
expect do
vlan.new(c).content
}.not_to raise_error
end.not_to raise_error
end
it "should not raise an error if address is present" do
it 'does not raise an error if address is present' do
c = {
:id => 1,
:device => 'em0',
:address => ['10.0.0.0/24'],
id: 1,
device: 'em0',
address: ['10.0.0.0/24']
}
expect {
expect do
vlan.new(c).content
}.not_to raise_error
end.not_to raise_error
end
it "should raise an error when an invalid option is received" do
it 'raises an error when an invalid option is received' do
c = {
:id => 1,
:device => 'em0',
:address => ['10.0.0.0/24'],
:random => '1',
id: 1,
device: 'em0',
address: ['10.0.0.0/24'],
random: '1'
}
expect {
expect do
vlan.new(c).content
}.to raise_error(ArgumentError, /unknown configuration item/)
end.to raise_error(ArgumentError, %r{unknown configuration item})
end
end
end
describe '#content' do
context 'when only a device and a vlan are supplied' do
it 'should return the ifconfig string' do
it 'returns the ifconfig string' do
c = {
:id => 1,
:device => 'em0',
id: 1,
device: 'em0'
}
wanted = [
'vlan 1 vlandev em0',
'vlan 1 vlandev em0'
]
expect(vlan.new(c).content).to match(wanted.join('\n'))
end
end
context 'when a single address is passed' do
it 'should return only the vlan string' do
it 'returns only the vlan string' do
c = {
:id => 1,
:device => 'em0',
:address => ['10.0.0.1/24'],
id: 1,
device: 'em0',
address: ['10.0.0.1/24']
}
wanted = [
'vlan 1 vlandev em0',
'vlan 1 vlandev em0'
]
expect(vlan.new(c).content).to match(wanted.join('\n'))
end

159
spec/unit/bsd/rc_conf_spec.rb
View File

@ -5,78 +5,79 @@ describe 'Rc_conf' do
describe 'initialize' do
context 'when minimal configuration is passed' do
it 'should not error' do
expect { rc.new({name: 'em0'}) }.to_not raise_error
it 'does not error' do
expect { rc.new(name: 'em0') }.not_to raise_error
end
end
end
describe '#get_hash' do
context 'with a dynamic v4-only config' do
it "should return a valid config" do
it 'returns a valid config' do
hash = {
:re0 => {
:addrs => [
'DHCP',
],
re0: {
addrs: [
'DHCP'
]
}
}
c = {
:name => 're0',
:addresses => [
name: 're0',
addresses: [
'dhcp'
]
}
expect(rc.new(c).get_hash).to eq(hash)
end
context "when an empty address set is passed" do
it "should return useless hash" do
context 'when an empty address set is passed' do
it 'returns useless hash' do
hash = {
:re0=>{}
re0: {}
}
c = {
:name => 're0',
:addresses => [],
name: 're0',
addresses: []
}
expect(rc.new(c).get_hash).to eq(hash)
end
end
context "when a single address is passed" do
it "should return a correctly formatted hash" do
context 'when a single address is passed' do
it 'returns a correctly formatted hash' do
hash = {
:re0=>{:addrs=>["inet 10.0.0.1/24"]}
re0: { addrs: ['inet 10.0.0.1/24'] }
}
c = {
:name => 're0',
:addresses => [
name: 're0',
addresses: [
'10.0.0.1/24'
],
]
}
expect(rc.new(c).get_hash).to eq(hash)
end
end
context "when multiple addresses are passed" do
it "should return a correctly formatted hash" do
context 'when multiple addresses are passed' do
it 'returns a correctly formatted hash' do
hash = {
:re0 => {
:addrs=>["inet 10.0.0.1/24"],
:aliases=>[
"inet 10.0.0.2/24",
"inet 10.0.0.3/24"]}
re0: {
addrs: ['inet 10.0.0.1/24'],
aliases: [
'inet 10.0.0.2/24',
'inet 10.0.0.3/24'
]
}
}
c = {
:name => 're0',
:addresses => [
name: 're0',
addresses: [
'10.0.0.1/24',
'10.0.0.2/24',
'10.0.0.3/24'
],
]
}
expect(rc.new(c).get_hash).to eq(hash)
@ -85,35 +86,34 @@ describe 'Rc_conf' do
end
context 'when a full config is supplied' do
it 'should return the desired hash' do
it 'returns the desired hash' do
hash = {
:re0 => {
:addrs => [
"inet 10.0.1.12/24 mtu 9000",
"inet6 fc00::123/64",
],
:aliases => [
"inet 10.0.1.13/24",
"inet 10.0.1.14/24",
"inet6 fc00::124/64",
"inet6 fc00::125/64",
re0: {
addrs: [
'inet 10.0.1.12/24 mtu 9000',
'inet6 fc00::123/64'
],
aliases: [
'inet 10.0.1.13/24',
'inet 10.0.1.14/24',
'inet6 fc00::124/64',
'inet6 fc00::125/64'
]
}
}
c = {
:name => 're0',
:desc => "Uplink",
:addresses => [
name: 're0',
desc: 'Uplink',
addresses: [
'10.0.1.12/24',
'10.0.1.13/24',
'10.0.1.14/24',
'fc00::123/64',
'fc00::124/64',
'fc00::125/64',
'fc00::125/64'
],
:mtu => 9000,
mtu: 9000
}
expect(rc.new(c).get_hash).to eq(hash)
end
@ -122,54 +122,53 @@ describe 'Rc_conf' do
describe '#to_create_resources' do
context 'when only mtu is spplied' do
it {
it do
hash = {
'ifconfig_re0' => {
'value' => 'mtu 9000',
},
'value' => 'mtu 9000'
}
}
c = {
:name => 're0',
:mtu => 9000,
name: 're0',
mtu: 9000
}
expect(rc.new(c).to_create_resources).to eq(hash)
}
end
end
context 'when a full interface config is supplied' do
it 'should convert the hash for create_resources()' do
it 'converts the hash for create_resources()' do
hash = {
'ifconfig_re0' => {
'value' => 'inet 10.0.1.12/24 mtu 9000',
'value' => 'inet 10.0.1.12/24 mtu 9000'
},
'ifconfig_re0_alias0' => {
'value' => 'inet 10.0.1.13/24',
'value' => 'inet 10.0.1.13/24'
},
'ifconfig_re0_alias1' => {
'value' => 'inet 10.0.1.14/24',
'value' => 'inet 10.0.1.14/24'
},
'ifconfig_re0_ipv6' => {
'value' => 'inet6 fc00::123/64',
'value' => 'inet6 fc00::123/64'
},
'ifconfig_re0_alias2' => {
'value' => 'inet6 fc00::124/64',
},
'value' => 'inet6 fc00::124/64'
}
}
c = {
:name => 're0',
:desc => "Uplink",
:addresses => [
name: 're0',
desc: 'Uplink',
addresses: [
'10.0.1.12/24',
'10.0.1.13/24',
'10.0.1.14/24',
'fc00::123/64',
'fc00::124/64',
'fc00::124/64'
],
:options => [
'mtu 9000',
options: [
'mtu 9000'
]
}
expect(rc.new(c).to_create_resources).to eq(hash)
@ -177,19 +176,19 @@ describe 'Rc_conf' do
end
context 'when only a vlan configuration is supplied' do
it 'should convert the hash for create_resources()' do
it 'converts the hash for create_resources()' do
hash = {
'ifconfig_vlan100' => {
'value' => 'vlan 100 vlandev re0',
'value' => 'vlan 100 vlandev re0'
}
}
c = {
:name => 'vlan100',
:desc => "Uplink",
:options => [
name: 'vlan100',
desc: 'Uplink',
options: [
'vlan 100',
'vlandev re0',
'vlandev re0'
]
}
expect(rc.new(c).to_create_resources).to eq(hash)
@ -197,15 +196,15 @@ describe 'Rc_conf' do
end
end
describe "#options_string" do
context "when options are supplied" do
it "should return the formatted string of options" do
describe '#options_string' do
context 'when options are supplied' do
it 'returns the formatted string of options' do
wanted = 'vlan 100 vlandev re0'
c = {
:name => 'vlan100',
:options => [
name: 'vlan100',
options: [
'vlan 100',
'vlandev re0',
'vlandev re0'
]
}
expect(rc.new(c).options_string).to eq(wanted)

40
spec/unit/bsd/util_spec.rb
View File

@ -3,51 +3,49 @@ require 'puppet_x/bsd/util'
describe 'PuppetX::BSD::Util' do
context '#uber_merge' do
it 'combinds simple hashes' do
h1 = { one: 1 }
h2 = { two: 2 }
it 'should combind simple hashes' do
h1 = {:one => 1}
h2 = {:two => 2}
wanted = {:one => 1, :two => 2}
wanted = { one: 1, two: 2 }
expect(PuppetX::BSD::Util.uber_merge(h1, h2)).to eq(wanted)
end
it 'should combine nested hashses' do
h1 = {:one => 1}
h2 = {:two => 2}
it 'combines nested hashses' do
h1 = { one: 1 }
h2 = { two: 2 }
wanted = {:one => 1, :two => 2}
wanted = { one: 1, two: 2 }
expect(PuppetX::BSD::Util.uber_merge(h1, h2)).to eq(wanted)
end
it 'should handle an empty initial hash' do
it 'handles an empty initial hash' do
h1 = {}
h2 = {:one => 1}
h2 = { one: 1 }
wanted = {:one => 1}
wanted = { one: 1 }
expect(PuppetX::BSD::Util.uber_merge(h1, h2)).to eq(wanted)
end
it 'should handle an initial hash with an array for value' do
h1 = {:one => ['a', 'b']}
h2 = {:two => {'eh' => 'a', 'bee' => 'b'}}
it 'handles an initial hash with an array for value' do
h1 = { one: %w(a b) }
h2 = { two: { 'eh' => 'a', 'bee' => 'b' } }
wanted = {:one => ['a', 'b'],:two => {'eh' => 'a', 'bee' => 'b' }}
wanted = { one: %w(a b), two: { 'eh' => 'a', 'bee' => 'b' } }
expect(PuppetX::BSD::Util.uber_merge(h1, h2)).to eq(wanted)
end
it 'Should combine values into an array' do
h1 = {:root => {:sub => 1}}
h2 = {:root => {:sub => 2}}
it 'combines values into an array' do
h1 = { root: { sub: 1 } }
h2 = { root: { sub: 2 } }
wanted = {:root => {:sub => [1,2]}}
wanted = { root: { sub: [1, 2] } }
expect(PuppetX::BSD::Util.uber_merge(h1, h2)).to eq(wanted)
end
end
end

122
spec/unit/puppet/provider/bsd_interface/ifconfig_spec.rb
View File

@ -6,52 +6,54 @@ describe Puppet::Type.type(:bsd_interface).provider(:ifconfig) do
let(:em_interface) do
Puppet::Type.type(:bsd_interface).new(
:name => 'em0',
:provider => em_provider)
name: 'em0',
provider: em_provider
)
end
let(:em_provider) { described_class.new(:name => 'em0') }
let(:em_provider) { described_class.new(name: 'em0') }
let(:vlan_interface) do
Puppet::Type.type(:bsd_interface).new(
:name => 'vlan0',
:provider => vlan_provider)
name: 'vlan0',
provider: vlan_provider
)
end
let(:vlan_provider) { described_class.new(:name => 'vlan0') }
let(:vlan_provider) { described_class.new(name: 'vlan0') }
context "#instances" do
let(:output) { File.read("spec/fixtures/ifconfig_openbsd.full") }
context '#instances' do
let(:output) { File.read('spec/fixtures/ifconfig_openbsd.full') }
before do
expect(described_class).to receive(:execute).with(['/sbin/ifconfig', '-C'], {:failonfail=>false, :combine=>true}) { 'vlan pflog' }
expect(described_class).to receive(:execute).with(['/sbin/ifconfig'], {:failonfail=>false, :combine=>true}) { output }
expect(described_class).to receive(:execute).with(['/sbin/ifconfig', '-C'], failonfail: false, combine: true) { 'vlan pflog' }
expect(described_class).to receive(:execute).with(['/sbin/ifconfig'], failonfail: false, combine: true) { output }
end
it 'should return some instances' do
it 'returns some instances' do
expect(described_class.instances.size).to eq(15)
end
it "should return an array of interfaces" do
it 'returns an array of interfaces' do
expect(described_class.instances.class).to be(Array)
end
it 'should return the resource dc=bar,dc=com' do
expect(described_class.instances[1].instance_variable_get("@property_hash")).to eq(
{:ensure => :present, :provider=>:bsd_interface, :name=>"em0", :flags=>["UP", "BROADCAST", "RUNNING", "SIMPLEX", "MULTICAST"], :mtu=>1500, :destroyable=>:false, :state => :up}
it 'returns the resource dc=bar,dc=com' do
expect(described_class.instances[1].instance_variable_get('@property_hash')).to eq(
ensure: :present, provider: :bsd_interface, name: 'em0', flags: %w(UP BROADCAST RUNNING SIMPLEX MULTICAST), mtu: 1500, destroyable: :false, state: :up
)
end
it "should return all interfaces names" do
expect(described_class.instances.map(&:name).sort).to eq(["bridge0", "bridge1", "em0", "em1", "em2", "em3", "em4", "em5", "em6", "em7", "lo0", "pflog0", "vether0", "vether1", "vlan88"])
it 'returns all interfaces names' do
expect(described_class.instances.map(&:name).sort).to eq(%w(bridge0 bridge1 em0 em1 em2 em3 em4 em5 em6 em7 lo0 pflog0 vether0 vether1 vlan88))
end
end
[:up, :down, :create, :destroy].each {|m| it { should respond_to(m) } }
[:up, :down, :create, :destroy].each { |m| it { is_expected.to respond_to(m) } }
context "#flush" do
states = ['up','absent','down']
ensure_states = ['present','up','absent','down']
if_types = ['pseudo', 'real']
platforms = ['OpenBSD','FreeBSD']
context '#flush' do
states = %w(up absent down)
ensure_states = %w(present up absent down)
if_types = %w(pseudo real)
platforms = %w(OpenBSD FreeBSD)
platforms.each do |platform|
context "on #{platform}" do
states.each do |state|
@ -72,38 +74,42 @@ describe Puppet::Type.type(:bsd_interface).provider(:ifconfig) do
let(:info) { File.read(ifconfig_fixture) }
case state
when 'present','down','up'
it 'should return a single instance' do
expect(described_class).to receive(:execute).with(['/sbin/ifconfig', '-C'], {:failonfail=>false, :combine=>true}) { 'vlan pflog' }
expect(described_class).to receive(:execute).with(['/sbin/ifconfig'], {:failonfail=>false, :combine=>true}) { info }
when 'present', 'down', 'up'
it 'returns a single instance' do
expect(described_class).to receive(:execute).with(['/sbin/ifconfig', '-C'], failonfail: false, combine: true) { 'vlan pflog' }
expect(described_class).to receive(:execute).with(['/sbin/ifconfig'], failonfail: false, combine: true) { info }
expect(described_class.instances.size).to eq(1)
end
when 'absent'
it 'should return zero instances' do
expect(described_class).to receive(:execute).with(['/sbin/ifconfig', '-C'], {:failonfail=>false, :combine=>true}) { 'vlan pflog' }
expect(described_class).to receive(:execute).with(['/sbin/ifconfig'], {:failonfail=>false, :combine=>true}) { info }
it 'returns zero instances' do
expect(described_class).to receive(:execute).with(['/sbin/ifconfig', '-C'], failonfail: false, combine: true) { 'vlan pflog' }
expect(described_class).to receive(:execute).with(['/sbin/ifconfig'], failonfail: false, combine: true) { info }
expect(described_class.instances.size).to eq(0)
end
end
ensure_states.each do |ensure_state|
context "when ensure is #{ensure_state}" do
let!(:provider) { described_class.new(
:name => ifname,
:ensure => ensure_state
) }
let!(:provider) do
described_class.new(
name: ifname,
ensure: ensure_state
)
end
let!(:interface) { Puppet::Type.type(:bsd_interface).new(
:name => ifname,
:provider => provider,
:ensure => state,
) }
let!(:interface) do
Puppet::Type.type(:bsd_interface).new(
name: ifname,
provider: provider,
ensure: state
)
end
# We only call instances on these states, which we expect to call ifconfig twice.
if ['present', 'up', 'down'].include? state
if %w(present up down).include? state
before do
expect(described_class).to receive(:execute).with(['/sbin/ifconfig', '-C'], {:failonfail=>false, :combine=>true}) { 'vlan pflog' }
expect(described_class).to receive(:execute).with(['/sbin/ifconfig'], {:failonfail=>false, :combine=>true}) { info }
expect(described_class).to receive(:execute).with(['/sbin/ifconfig', '-C'], failonfail: false, combine: true) { 'vlan pflog' }
expect(described_class).to receive(:execute).with(['/sbin/ifconfig'], failonfail: false, combine: true) { info }
end
end
@ -118,9 +124,9 @@ describe Puppet::Type.type(:bsd_interface).provider(:ifconfig) do
it 'leave the interface untouched' do
i = described_class.instances[0]
if if_type == 'pseudo'
expect(i).to_not receive(:execute).with(['/sbin/ifconfig', ifname, 'create'], {:failonfail=>false, :combine=>true})
expect(i).not_to receive(:execute).with(['/sbin/ifconfig', ifname, 'create'], failonfail: false, combine: true)
end
expect(i).to_not receive(:execute).with(['/sbin/ifconfig', ifname, 'up'], {:failonfail=>false, :combine=>true})
expect(i).not_to receive(:execute).with(['/sbin/ifconfig', ifname, 'up'], failonfail: false, combine: true)
i.up
i.flush
end
@ -128,29 +134,29 @@ describe Puppet::Type.type(:bsd_interface).provider(:ifconfig) do
it 'leave the interface untouched' do
i = described_class.instances[0]
if if_type == 'pseudo'
expect(i).to_not receive(:execute).with(['/sbin/ifconfig', ifname, 'create'], {:failonfail=>false, :combine=>true})
expect(i).not_to receive(:execute).with(['/sbin/ifconfig', ifname, 'create'], failonfail: false, combine: true)
end
expect(i).to_not receive(:execute).with(['/sbin/ifconfig', ifname, 'up'], {:failonfail=>false, :combine=>true})
expect(i).not_to receive(:execute).with(['/sbin/ifconfig', ifname, 'up'], failonfail: false, combine: true)
i.flush
end
when 'down'
it 'should bring the interface down' do
it 'brings the interface down' do
i = described_class.instances[0]
if if_type == 'pseudo'
expect(i).to_not receive(:execute).with(['/sbin/ifconfig', ifname, 'create'], {:failonfail=>false, :combine=>true})
expect(i).to_not receive(:execute).with(['/sbin/ifconfig', ifname, 'destroy'], {:failonfail=>false, :combine=>true})
expect(i).not_to receive(:execute).with(['/sbin/ifconfig', ifname, 'create'], failonfail: false, combine: true)
expect(i).not_to receive(:execute).with(['/sbin/ifconfig', ifname, 'destroy'], failonfail: false, combine: true)
end
expect(i).to receive(:execute).with(['/sbin/ifconfig', ifname, 'down'], {:failonfail=>false, :combine=>true})
expect(i).to receive(:execute).with(['/sbin/ifconfig', ifname, 'down'], failonfail: false, combine: true)
i.down
i.flush
end
when 'absent'
it 'should bring down and destroy the interface when necessary' do
it 'brings down and destroy the interface when necessary' do
i = described_class.instances[0]
expect(i).to receive(:execute).with(['/sbin/ifconfig', ifname, 'down'], {:failonfail=>false, :combine=>true})
expect(i).to receive(:execute).with(['/sbin/ifconfig', ifname, 'down'], failonfail: false, combine: true)
if if_type == 'pseudo'
expect(i).to_not receive(:execute).with(['/sbin/ifconfig', ifname, 'create'], {:failonfail=>false, :combine=>true})
expect(i).to receive(:execute).with(['/sbin/ifconfig', ifname, 'destroy'], {:failonfail=>false, :combine=>true})
expect(i).not_to receive(:execute).with(['/sbin/ifconfig', ifname, 'create'], failonfail: false, combine: true)
expect(i).to receive(:execute).with(['/sbin/ifconfig', ifname, 'destroy'], failonfail: false, combine: true)
end
i.destroy
i.flush
@ -164,10 +170,10 @@ describe Puppet::Type.type(:bsd_interface).provider(:ifconfig) do
case ensure_state
when 'up'
it 'should bring up the interface' do
it 'brings up the interface' do
i = described_class.instances[0]
i.up
expect(i).to receive(:execute).with(['/sbin/ifconfig', ifname, 'up'], {:failonfail=>false, :combine=>true})
expect(i).to receive(:execute).with(['/sbin/ifconfig', ifname, 'up'], failonfail: false, combine: true)
i.flush
end
when 'present'
@ -175,13 +181,12 @@ describe Puppet::Type.type(:bsd_interface).provider(:ifconfig) do
when 'absent'
end
when 'absent'
it 'should be absent' do
it 'is absent' do
expect(provider.state).to eq(:absent)
end
end
end
end
end
end
end
@ -189,5 +194,4 @@ describe Puppet::Type.type(:bsd_interface).provider(:ifconfig) do
end
end
end
end

13
spec/unit/puppet/type/bsd_interface_spec.rb
View File

@ -1,24 +1,23 @@
require 'spec_helper'
#require 'puppet/provider/bsd_interface/ifconfig'
# require 'puppet/provider/bsd_interface/ifconfig'
type_class = Puppet::Type.type(:bsd_interface)
describe type_class do
[:absent, :present].each do |v|
it "should support #{v} as a value to :ensure" do
em = type_class.new(:name => 'em0', :ensure => v)
em = type_class.new(name: 'em0', ensure: v)
expect(em.should(:ensure)).to eq(v)
end
end
it "should alias :up to :present as a value to :ensure" do
em = type_class.new(:name => 'em0', :ensure => :up)
it 'aliases :up to :present as a value to :ensure' do
em = type_class.new(name: 'em0', ensure: :up)
expect(em.should(:ensure)).to eq(:present)
end
it "should alias :down to :absent as a value to :ensure" do
em = type_class.new(:name => 'em0', :ensure => :down)
it 'aliases :down to :absent as a value to :ensure' do
em = type_class.new(name: 'em0', ensure: :down)
expect(em.should(:ensure)).to eq(:absent)
end
end