puppet-retrospec 0.11.0 → 0.12.0

data/spec/unit/puppet-retrospec_spec.rb

@@ -1,38 +1,42 @@
 require 'spec_helper'
 require 'fakefs/safe'
 
-describe "puppet-retrospec" do
+describe 'puppet-retrospec' do
   after :all do
     # enabling the removal slows down tests, but from time to time we may need to
     FileUtils.rm_rf(fixture_modules_path) if ENV['RETROSPEC_CLEAN_UP_TEST_MODULES'] =~ /true/
   end
 
+  let(:template_dir) do
+    retrospec_templates_path
+  end
+
   let(:global_config) do
-     {'author' => 'Corey Osman'}
+    { 'author' => 'Corey Osman' }
   end
 
   let(:plugin_config) do
     {
-    # 'plugins::puppet::template_dir' => '/Users',
-    # 'plugins::puppet::templates::url' => '',
-    # 'plugins::puppet::templates::ref'  => '',
-    # 'plugins::puppet::enable_future_parser' => '',
-    # 'plugins::puppet::enable_beaker_tests' => '',
-    # 'plugins::puppet::namespace' => '',
-    # 'plugins::puppet::auto_create' => '',
+      # 'plugins::puppet::template_dir' => '/Users',
+      # 'plugins::puppet::templates::url' => '',
+      # 'plugins::puppet::templates::ref'  => '',
+      # 'plugins::puppet::enable_future_parser' => '',
+      # 'plugins::puppet::enable_beaker_tests' => '',
+      # 'plugins::puppet::namespace' => '',
+      # 'plugins::puppet::auto_create' => '',
     }
   end
 
   let(:global_opts) do
-    {:module_path => File.join(fixture_modules_path, 'tomcat')}
+    { :module_path => File.join(fixture_modules_path, 'tomcat') }
   end
 
   let(:plugin_opts) do
-     {}
+    {}
   end
 
   before :all do
-    #enabling the removal of real modules slows down tests, but from time to time we may need to
+    # enabling the removal of real modules slows down tests, but from time to time we may need to
     FileUtils.rm_rf(fixture_modules_path) if ENV['RETROSPEC_CLEAN_UP_TEST_MODULES'] =~ /true/
     install_module('puppetlabs-tomcat')
     @path = File.join(fixture_modules_path, 'tomcat')
@@ -40,8 +44,8 @@ describe "puppet-retrospec" do
 
   before :each do
     clean_up_spec_dir(@path)
-    @opts = {:module_path => @path, :enable_beaker_tests => false, :name => 'name-test123',
-             :enable_user_templates => false, :template_dir => '/tmp/.retrospec_templates' }
+    @opts = { :module_path => @path, :enable_beaker_tests => false, :name => 'name-test123',
+              :enable_user_templates => false, :template_dir => template_dir }
   end
 
   it 'should run without errors using new' do
@@ -50,45 +54,24 @@ describe "puppet-retrospec" do
   end
 
   it 'should set the parser to future' do
-    opts = {:module_path => @path, :enable_beaker_tests => false,
-            :enable_user_templates => false, :template_dir => nil, :enable_future_parser => true }
+    opts = { :module_path => @path, :enable_beaker_tests => false,
+             :enable_user_templates => false, :template_dir => nil, :enable_future_parser => true }
     tomcat = Retrospec::Plugins::V1::Puppet.new(opts[:module_path], opts)
     tomcat.post_init
     expect(tomcat.context.instance.future_parser).to eq(true)
   end
-  describe 'new module' do
-    after :each do
-      FileUtils.rm_rf('/tmp/new_module')
-    end
-    it 'should create a module when it does not exist' do
-      opts = {'plugins::puppet::author' => 'test_name', :module_path => '/tmp/new_module', :create => true,
-              :namespace => 'retrospec', :enable_beaker_tests => false,
-              :enable_user_templates => false, :name => 'moduletest',
-              :template_dir => File.expand_path(File.join(ENV['HOME'], '.retrospec', 'repos', 'retrospec-puppet-templates')),
-                                                :enable_future_parser => true }
-      ENV['RETROSPEC_PUPPET_AUTO_GENERATE'] = 'true'
-      new_module = Retrospec::Plugins::V1::Puppet.new(opts[:module_path], opts)
-      allow(new_module).to receive(:gets).and_return("y\n")
-      new_module.new_module(opts)
-      new_module.post_init
-      new_module.run
-      expect(File.exists?(File.join(new_module.manifest_dir, 'init.pp'))).to eq(true)
-      expect(File.exists?(File.join(new_module.module_path, 'metadata.json'))).to eq(true)
-      expect(JSON.parse(File.read(File.join(new_module.module_path, 'metadata.json')))['author']).to eq('test_name')
-    end
-  end
 
   it 'should create files without error' do
     tomcat = Retrospec::Plugins::V1::Puppet.new(@opts[:module_path], @opts)
     tomcat.post_init
     tomcat.create_files
-    expect(File.exists?(File.join(@path, 'Gemfile'))).to eq(true)
-    expect(File.exists?(File.join(@path, 'Rakefile'))).to eq(true)
-    expect(File.exists?(File.join(@path, 'spec','spec_helper.rb'))).to eq(true)
-    expect(File.exists?(File.join(@path, '.travis.yml'))).to eq(true)
-    expect(File.exists?(File.join(@path, 'spec', 'shared_contexts.rb'))).to eq(true)
-    expect(File.exists?(File.join(@path, '.fixtures.yml'))).to eq(true)
-    expect(File.exists?(File.join(@path, 'spec','classes','tomcat_spec.rb'))).to eq(true)
+    expect(File.exist?(File.join(@path, 'Gemfile'))).to eq(true)
+    expect(File.exist?(File.join(@path, 'Rakefile'))).to eq(true)
+    expect(File.exist?(File.join(@path, 'spec', 'spec_helper.rb'))).to eq(true)
+    expect(File.exist?(File.join(@path, '.travis.yml'))).to eq(true)
+    expect(File.exist?(File.join(@path, 'spec', 'shared_contexts.rb'))).to eq(true)
+    expect(File.exist?(File.join(@path, '.fixtures.yml'))).to eq(true)
+    expect(File.exist?(File.join(@path, 'spec', 'classes', 'tomcat_spec.rb'))).to eq(true)
   end
 
   it 'should create acceptance test files' do
@@ -97,12 +80,11 @@ describe "puppet-retrospec" do
     tomcat.post_init
     spec_path = File.expand_path(File.join(@path, 'spec'))
     tomcat.create_files
-    expect(File.exists?(File.join(spec_path, 'spec_helper_acceptance.rb'))).to eq(true)
-    expect(File.exists?(File.join(spec_path, 'acceptance'))).to eq(true)
-    expect(File.exists?(File.join(spec_path, 'acceptance', 'classes', 'tomcat_spec.rb'))).to eq(true)
-    expect(File.exists?(File.join(spec_path, 'acceptance', 'nodesets'))).to eq(true)
-    expect(File.exists?(File.join(spec_path, 'acceptance', 'nodesets', 'default.yml'))).to eq(true)
-
+    expect(File.exist?(File.join(spec_path, 'spec_helper_acceptance.rb'))).to eq(true)
+    expect(File.exist?(File.join(spec_path, 'acceptance'))).to eq(true)
+    expect(File.exist?(File.join(spec_path, 'acceptance', 'classes', 'tomcat_spec.rb'))).to eq(true)
+    expect(File.exist?(File.join(spec_path, 'acceptance', 'nodesets'))).to eq(true)
+    expect(File.exist?(File.join(spec_path, 'acceptance', 'nodesets', 'default.yml'))).to eq(true)
   end
 
   it 'should not create acceptance test files' do
@@ -112,11 +94,11 @@ describe "puppet-retrospec" do
     tomcat.post_init
     spec_path = File.expand_path(File.join(@path, 'spec'))
     tomcat.create_files
-    expect(File.exists?(File.join(spec_path, 'spec_helper_acceptance.rb'))).to eq(false)
-    expect(File.exists?(File.join(spec_path, 'acceptance'))).to eq(true)
-    expect(File.exists?(File.join(spec_path, 'acceptance', 'classes', 'tomcat_spec.rb'))).to eq(false)
-    expect(File.exists?(File.join(spec_path, 'acceptance', 'nodesets'))).to eq(false)
-    expect(File.exists?(File.join(spec_path, 'acceptance', 'nodesets', 'default.yml'))).to eq(false)
+    expect(File.exist?(File.join(spec_path, 'spec_helper_acceptance.rb'))).to eq(false)
+    expect(File.exist?(File.join(spec_path, 'acceptance'))).to eq(true)
+    expect(File.exist?(File.join(spec_path, 'acceptance', 'classes', 'tomcat_spec.rb'))).to eq(false)
+    expect(File.exist?(File.join(spec_path, 'acceptance', 'nodesets'))).to eq(false)
+    expect(File.exist?(File.join(spec_path, 'acceptance', 'nodesets', 'default.yml'))).to eq(false)
   end
 
   it 'should create proper spec helper file' do
@@ -125,7 +107,7 @@ describe "puppet-retrospec" do
     filepath = File.expand_path(File.join(@path, 'spec', 'spec_helper.rb'))
     tomcat.safe_create_module_files
     path = tomcat.module_path
-    expect(File.exists?(filepath)).to eq(true)
+    expect(File.exist?(filepath)).to eq(true)
   end
 
   it 'should create proper shared context file' do
@@ -133,7 +115,7 @@ describe "puppet-retrospec" do
     tomcat.post_init
     filepath = File.expand_path(File.join(@path, 'spec', 'shared_contexts.rb'))
     tomcat.safe_create_module_files
-    expect(File.exists?(filepath)).to eq(true)
+    expect(File.exist?(filepath)).to eq(true)
   end
 
   it 'should produce hiera data' do
@@ -142,47 +124,47 @@ describe "puppet-retrospec" do
     filepath = File.expand_path(File.join(@path, 'spec', 'shared_contexts.rb'))
     tomcat.safe_create_module_files
     path = tomcat.module_path
-    expect(tomcat.context.all_hiera_data).to eq({"tomcat::catalina_home"=>nil,
-                                                 "tomcat::user"=>nil,
-                                                 "tomcat::group"=>nil,
-                                                 "tomcat::install_from_source"=>nil,
-                                                 "tomcat::purge_connectors"=>nil,
-                                                 "tomcat::purge_realms"=>nil,
-                                                 "tomcat::manage_user"=>nil,
-                                                 "tomcat::manage_group"=>nil}
-                                             )
+    expect(tomcat.context.all_hiera_data).to eq('tomcat::catalina_home' => nil,
+                                                'tomcat::user' => nil,
+                                                'tomcat::group' => nil,
+                                                'tomcat::install_from_source' => nil,
+                                                'tomcat::purge_connectors' => nil,
+                                                'tomcat::purge_realms' => nil,
+                                                'tomcat::manage_user' => nil,
+                                                'tomcat::manage_group' => nil
+                                               )
 
     expect(File.read(filepath)).to include('#"tomcat::catalina_home" => \'\',')
   end
 
   it 'should create acceptance spec helper file' do
-    opts = {:module_path => @path, :enable_beaker_tests => true,
-             :template_dir => '/tmp/my_templates' }
+    opts = { :module_path => @path, :enable_beaker_tests => true,
+             :template_dir => template_dir }
     tomcat = Retrospec::Plugins::V1::Puppet.new(@opts[:module_path], opts)
     tomcat.post_init
     filepath = File.expand_path(File.join(@path, 'spec', 'spec_helper_acceptance.rb'))
     tomcat.safe_create_module_files
-    expect(File.exists?(filepath)).to eq(true)
+    expect(File.exist?(filepath)).to eq(true)
   end
 
   it 'should not create acceptance spec helper file' do
-    opts = {:module_path => @path, :enable_beaker_tests => false,
-             :template_dir => '/tmp/my_templates' }
+    opts = { :module_path => @path, :enable_beaker_tests => false,
+             :template_dir => template_dir }
     filepath = File.expand_path(File.join(@path, 'spec', 'spec_helper_acceptance.rb'))
     tomcat = Retrospec::Plugins::V1::Puppet.new(@opts[:module_path], opts)
     tomcat.post_init
     tomcat.safe_create_module_files
-    expect(File.exists?(filepath)).to eq(false)
+    expect(File.exist?(filepath)).to eq(false)
   end
 
   it 'should create 15 nodesets' do
-    opts = {:module_path => @path, :enable_beaker_tests => true,
-            :template_dir =>  '/tmp/my_templates' }
+    opts = { :module_path => @path, :enable_beaker_tests => true,
+             :template_dir => template_dir }
     tomcat = Retrospec::Plugins::V1::Puppet.new(@opts[:module_path], opts)
     tomcat.post_init
     filepath = File.expand_path(File.join(@path, 'spec', 'acceptance', 'nodesets', 'default.yml'))
     tomcat.safe_create_module_files
-    expect(File.exists?(filepath)).to eq(true)
+    expect(File.exist?(filepath)).to eq(true)
     expect(Dir.glob(File.expand_path(File.join(@path, 'spec', 'acceptance', 'nodesets', '*.yml'))).length).to eq 15
   end
 
@@ -191,7 +173,7 @@ describe "puppet-retrospec" do
     tomcat.post_init
     filepath = File.expand_path(File.join(@path, 'Gemfile'))
     tomcat.safe_create_module_files
-    expect(File.exists?(filepath)).to eq(true)
+    expect(File.exist?(filepath)).to eq(true)
   end
 
   it 'should create Rakefile file' do
@@ -199,85 +181,84 @@ describe "puppet-retrospec" do
     tomcat.post_init
     filepath = File.expand_path(File.join(@path, 'Rakefile'))
     tomcat.safe_create_module_files
-    expect(File.exists?(filepath)).to eq(true)
+    expect(File.exist?(filepath)).to eq(true)
   end
 
   it 'should create proper fixtures file' do
-    filepath = File.expand_path(File.join(@path,'.fixtures.yml'))
-    FileUtils.rm_f(filepath)  # ensure we have a clean state
+    filepath = File.expand_path(File.join(@path, '.fixtures.yml'))
+    FileUtils.rm_f(filepath) # ensure we have a clean state
     tomcat = Retrospec::Plugins::V1::Puppet.new(@opts[:module_path], @opts)
     tomcat.post_init
     tomcat.safe_create_module_files
-    expect(File.exists?(filepath)).to eq(true)
+    expect(File.exist?(filepath)).to eq(true)
   end
 
   it 'should not create any files when 0 resources exists' do
     my_path = File.expand_path(File.join('spec', 'fixtures', 'fixture_modules', 'zero_resource_module'))
     my_retro = Retrospec::Plugins::V1::Puppet.new(my_path, @opts)
-    my_retro.should_not_receive(:safe_create_file).with(anything,'resource_spec_file.erb')
+    my_retro.should_not_receive(:safe_create_file).with(anything, 'resource_spec_file.erb')
   end
 
   it 'should create a file from a template' do
     tomcat = Retrospec::Plugins::V1::Puppet.new(@opts[:module_path], @opts)
     tomcat.post_init
-    file_path = File.join(@path,'.fixtures.yml')
-    template_file = File.join(tomcat.template_dir,'module_files','.fixtures.yml.retrospec.erb')
+    file_path = File.join(@path, '.fixtures.yml')
+    template_file = File.join(tomcat.template_dir, 'module_files', '.fixtures.yml.retrospec.erb')
     tomcat.safe_create_template_file(file_path, template_file, tomcat.context)
-    expect(File.exists?(file_path)).to eq(true)
+    expect(File.exist?(file_path)).to eq(true)
   end
 
   describe 'generate_file_path' do
     describe 'classes' do
       it 'should generate a acceptance test path correctly' do
-        type = double("type")
+        type = double('type')
         allow(type).to receive(:type).and_return(:hostclass)
         allow(type).to receive(:name).and_return('tomcat::config::server::connector')
         tomcat = Retrospec::Plugins::V1::Puppet.new(@opts[:module_path], @opts)
-        expect(tomcat.generate_file_path(type, true)).to eq("spec/acceptance/classes/config/server/connector_spec.rb")
+        expect(tomcat.generate_file_path(type, true)).to eq('spec/acceptance/classes/config/server/connector_spec.rb')
       end
       it 'should generate a normal test path correctly' do
-        type = double("type")
+        type = double('type')
         allow(type).to receive(:type).and_return(:hostclass)
         allow(type).to receive(:name).and_return('tomcat::config::server::connector')
         tomcat = Retrospec::Plugins::V1::Puppet.new(@opts[:module_path], @opts)
-        expect(tomcat.generate_file_path(type, false)).to eq("spec/classes/config/server/connector_spec.rb")
+        expect(tomcat.generate_file_path(type, false)).to eq('spec/classes/config/server/connector_spec.rb')
       end
     end
 
     describe 'defines' do
       it 'should generate a acceptance test path correctly' do
-        type = double("type")
+        type = double('type')
         allow(type).to receive(:type).and_return(:definition)
         allow(type).to receive(:name).and_return('tomcat::config::server::connector')
         tomcat = Retrospec::Plugins::V1::Puppet.new(@opts[:module_path], @opts)
-        expect(tomcat.generate_file_path(type, true)).to eq("spec/acceptance/defines/config/server/connector_spec.rb")
+        expect(tomcat.generate_file_path(type, true)).to eq('spec/acceptance/defines/config/server/connector_spec.rb')
       end
 
       it 'should generate a normal test path correctly' do
-        type = double("type")
+        type = double('type')
         allow(type).to receive(:type).and_return(:definition)
         allow(type).to receive(:name).and_return('tomcat::config::server::connector')
         tomcat = Retrospec::Plugins::V1::Puppet.new(@opts[:module_path], @opts)
-        expect(tomcat.generate_file_path(type, false)).to eq("spec/defines/config/server/connector_spec.rb")
+        expect(tomcat.generate_file_path(type, false)).to eq('spec/defines/config/server/connector_spec.rb')
       end
     end
 
     describe 'nodes' do
       it 'should generate a normal test path correctly' do
-        type = double("type")
+        type = double('type')
         allow(type).to receive(:type).and_return(:node)
         allow(type).to receive(:name).and_return('server1.example.com')
         tomcat = Retrospec::Plugins::V1::Puppet.new(@opts[:module_path], @opts)
-        expect(tomcat.generate_file_path(type, true)).to eq("spec/acceptance/hosts/server1.example.com_spec.rb")
+        expect(tomcat.generate_file_path(type, true)).to eq('spec/acceptance/hosts/server1.example.com_spec.rb')
       end
     end
   end
 
   it 'should generate a test file name correctly' do
-     tomcat = Retrospec::Plugins::V1::Puppet.new(@opts[:module_path], @opts)
-     expect(tomcat.generate_file_name('tomcat::config::server::connector')).to eq('connector_spec.rb')
-     expect(tomcat.generate_file_name('tomcat')).to eq('tomcat_spec.rb')
-     expect(tomcat.generate_file_name('tomcat::config')).to eq('config_spec.rb')
+    tomcat = Retrospec::Plugins::V1::Puppet.new(@opts[:module_path], @opts)
+    expect(tomcat.generate_file_name('tomcat::config::server::connector')).to eq('connector_spec.rb')
+    expect(tomcat.generate_file_name('tomcat')).to eq('tomcat_spec.rb')
+    expect(tomcat.generate_file_name('tomcat::config')).to eq('config_spec.rb')
   end
-
-end
+end

data/spec/unit/resource_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe "resource" do
+describe 'resource' do
   after :all do
     # enabling the removal slows down tests, but from time to time we may need to
     FileUtils.rm_rf(fixture_modules_path) if ENV['RETROSPEC_CLEAN_UP_TEST_MODULES'] =~ /true/
@@ -17,7 +17,7 @@ describe "resource" do
   end
 
   describe 'one resource module' do
-    let(:instance) {Utilities::PuppetModule.send :new}
+    let(:instance) { Utilities::PuppetModule.send :new }
     before :each do
       my_path = File.expand_path(File.join('spec', 'fixtures', 'fixture_modules', 'one_resource_module'))
       @m = instance
@@ -26,40 +26,39 @@ describe "resource" do
     end
 
     it 'should initialize with one resource' do
-      r = Resource.all(@m.types.find {|x| x.name == 'one_resource'})
+      r = Resource.all(@m.types.find { |x| x.name == 'one_resource' })
       expect(r.length).to eq(1)
-      expect(r[0].parameters).to eq({"ensure"=>"present"})
-      expect(r[0].title).to eq("/tmp/test")
-      expect(r[0].type).to eq("file")
+      expect(r[0].parameters).to eq('ensure' => 'present')
+      expect(r[0].title).to eq('/tmp/test')
+      expect(r[0].type).to eq('file')
     end
 
     it 'should initialize with two resources' do
-      test_type = @m.types.find {|x| x.name == 'one_resource::another_resource'}
+      test_type = @m.types.find { |x| x.name == 'one_resource::another_resource' }
       VariableStore.populate(test_type)
       r = Resource.all(test_type)
       expect(r.length).to eq(2)
-      expect(r[0].parameters).to eq({"ensure"=>"present"})
-      expect(r[0].title).to eq("/tmp/test2")
-      expect(r[0].type).to eq("file")
-      expect(r[1].parameters).to eq({"ensure"=>"present","content" => "/tmp/test3/test3183/oohhhh"})
-      expect(r[1].title).to eq("/tmp/test3")
-      expect(r[1].type).to eq("file")
+      expect(r[0].parameters).to eq('ensure' => 'present')
+      expect(r[0].title).to eq('/tmp/test2')
+      expect(r[0].type).to eq('file')
+      expect(r[1].parameters).to eq('ensure' => 'present', 'content' => '/tmp/test3/test3183/oohhhh')
+      expect(r[1].title).to eq('/tmp/test3')
+      expect(r[1].type).to eq('file')
     end
 
     it 'should return resources' do
-      test_type = @m.types.find {|x| x.name == 'one_resource::another_resource'}
+      test_type = @m.types.find { |x| x.name == 'one_resource::another_resource' }
       expect(Resource.all(test_type.code).length).to eq(2)
     end
-
   end
   describe 'zero module' do
-    let(:instance) {Utilities::PuppetModule.send :new}
+    let(:instance) { Utilities::PuppetModule.send :new }
     it 'can process an empty class' do
       my_path = File.expand_path(File.join('spec', 'fixtures', 'fixture_modules', 'zero_resource_module'))
       m = instance
       m.module_path = my_path
       m.create_tmp_module_path(my_path)
-      test_type = m.types.find {|x| x.name == 'empty_class'}
+      test_type = m.types.find { |x| x.name == 'empty_class' }
       r = Resource.all(test_type)
       expect(r.size).to eq(0)
     end

data/spec/unit/spec_object_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe 'spec_object' do
+
+  let(:path) do
+    File.join(fixture_modules_path, 'tomcat')
+  end
+
+  let(:opts) do
+    { :module_path => path, :enable_beaker_tests => false, :name => 'name-test123',
+      :enable_user_templates => false, :template_dir => '/tmp/.retrospec_templates' }
+  end
+
+  let(:puppet_context) do
+    path = File.join(fixture_modules_path, 'tomcat')
+    opts = { :module_path => path, :enable_beaker_tests => false, :name => 'name-test123',
+             :enable_user_templates => false, :template_dir => '/tmp/.retrospec_templates' }
+    mod = Retrospec::Plugins::V1::Puppet.new(opts[:module_path], opts)
+    mod.post_init
+    mod.context
+  end
+
+  it 'should get all hiera data' do
+    expect(puppet_context.class_hiera_data('tomcat')).to eq({"tomcat::catalina_home" => nil,
+                                                             "tomcat::group" => nil,
+                                                             "tomcat::install_from_source" => nil,
+                                                             "tomcat::manage_group" => nil,
+                                                             "tomcat::manage_user" => nil,
+                                                             "tomcat::purge_connectors" => nil,
+                                                             "tomcat::purge_realms" => nil,
+                                                             "tomcat::user" => nil,
+                                                            })
+  end
+
+  it 'should get all hiera data' do
+    expect(puppet_context.all_hiera_data).to eq({"tomcat::catalina_home" => nil,
+                                                             "tomcat::group" => nil,
+                                                             "tomcat::install_from_source" => nil,
+                                                             "tomcat::manage_group" => nil,
+                                                             "tomcat::manage_user" => nil,
+                                                             "tomcat::purge_connectors" => nil,
+                                                             "tomcat::purge_realms" => nil,
+                                                             "tomcat::user" => nil,
+                                                            })
+  end
+end