puppet-retrospec 0.11.0 → 0.12.0

data/spec/unit/generators/type_generator_spec.rb

@@ -0,0 +1,173 @@
+require 'spec_helper'
+
+describe 'type generator' do
+  before :each do
+    FileUtils.rm_rf(type_spec_dir)
+  end
+
+  after :each do
+    FileUtils.rm_rf(File.dirname(File.dirname(generator.type_name_path))) # ensure the file does not exist
+    FileUtils.rm_rf(File.dirname(generator.type_spec_dir))
+  end
+
+  let(:type_name) do
+    'vhost'
+  end
+
+  let(:type_spec_dir) do
+    File.join(module_path, 'spec', 'unit', 'puppet', 'type')
+  end
+
+  let(:provider_dir) do
+    File.join(module_path, 'lib', 'puppet', 'provider')
+  end
+
+  let(:type_dir) do
+    File.join(module_path, 'lib', 'puppet', 'type')
+  end
+
+  let(:provider_spec_dir) do
+    File.join(module_path, 'spec', 'unit', 'puppet', 'provider')
+  end
+
+  let(:module_path) do
+    File.join(fixture_modules_path, 'tomcat')
+  end
+
+  let(:context) do
+    { :module_path => module_path, :template_dir => retrospec_templates_path}
+  end
+
+  let(:args) do
+    ['-p', 'param_one', 'param_two','-a', 'config1',
+      'config2', '-n', type_name]
+    end
+
+    let(:cli_opts) do
+      Retrospec::Puppet::Generators::TypeGenerator.run_cli(context, args)
+    end
+
+    let(:generator) do
+      Retrospec::Puppet::Generators::TypeGenerator.new(module_path, cli_opts)
+    end
+
+    it 'returns type dir' do
+      expect(generator.type_dir).to eq(type_dir)
+    end
+
+    it 'returns module path' do
+      expect(generator.type_spec_dir).to eq(type_spec_dir)
+    end
+
+    it 'can return type name' do
+      expect(generator.type_name).to eq('vhost')
+    end
+
+    it 'can generate a type file' do
+      expect(generator.generate_type_files).to eq('/Users/cosman/github/puppet-retrospec/spec/fixtures/modules/tomcat/lib/puppet/type/vhost.rb')
+      expect(File.exist?(File.join(generator.type_dir, "#{generator.type_name}.rb")))
+    end
+
+    it 'can generate a spec file' do
+      allow(generator).to receive(:type_dir).and_return(fixtures_type_path)
+      allow(generator).to receive(:type_name_path).and_return(File.join(type_dir, "#{generator.type_name}.rb"))
+      files = [File.join(type_spec_dir, 'bmc_spec.rb'),
+        File.join(type_spec_dir, 'bmcuser_spec.rb'),
+        File.join(type_spec_dir, 'db_opatch_spec.rb')]
+        expect(generator.generate_type_spec_files).to eq(files)
+      end
+
+      describe 'cli' do
+        let(:context) do
+          { :module_path => module_path, :template_dir => File.expand_path(File.join(ENV['HOME'], '.retrospec', 'repos', 'retrospec-puppet-templates')) }
+        end
+
+        let(:type_name) do
+          'vhost'
+        end
+
+        let(:args) do
+          ['-p', 'param_one', 'param_two','-a', 'prop_one',
+            'prop_two', '-n', type_name]
+          end
+
+          let(:cli_opts) do
+            cli_opts = Retrospec::Puppet::Generators::TypeGenerator.run_cli(context, args)
+          end
+
+          let(:generator) do
+            Retrospec::Puppet::Generators::TypeGenerator.new(cli_opts[:module_path], cli_opts)
+          end
+
+          after :each do
+            FileUtils.rm_rf(File.dirname(File.dirname(generator.type_name_path))) # ensure the file does not exist
+            FileUtils.rm_rf(File.dirname(generator.type_spec_dir))
+          end
+
+          it 'can run the cli options' do
+            # specify the parameters
+            expect(cli_opts).to be_an_instance_of Hash
+            expect(cli_opts[:properties]).to eq(%w(prop_one prop_two))
+            expect(cli_opts[:parameters]).to eq(%w(param_one param_two))
+            expect(cli_opts[:name]).to eq('vhost')
+          end
+
+          it 'generate type file with correct number of properties' do
+            file = generator.generate_type_files
+            require file
+            t = Puppet::Type.type(:vhost)
+            expect(t.properties.count). to eq(3)
+          end
+
+          context 'parameters' do
+            let(:args) do
+              ['-p', 'param_one', 'param_two','-a', 'prop_one',
+                'prop_two', '-n', 'vhost']
+              end
+              it 'generate type file with correct number of parameters' do
+                file = generator.generate_type_files
+                require file
+                t = Puppet::Type.type(:vhost)
+                expect(t.parameters.count). to eq(2)
+              end
+            end
+
+            context 'providers' do
+              let(:args) do
+                ['-p', 'param_one', 'param_two','-a', 'prop_one',
+                  'prop_two', '-n', type_name, '--providers', 'default1', 'default2']
+                end
+
+                it 'generate type' do
+                  file = generator.generate_type_files
+                  require file
+                  t = Puppet::Type.type(:vhost)
+                  expect(File.exist?(file)).to eq(true)
+                end
+
+                it 'generate providers' do
+                  file = generator.generate_type_files
+                  p_vhost = File.join(provider_dir, 'vhost')
+                  expect(File.exist?(File.join(p_vhost, 'default1.rb'))).to eq(true)
+                  expect(File.exist?(File.join(p_vhost, 'default2.rb'))).to eq(true)
+                  expect(generator.context.providers).to eq(%w(default1 default2))
+                end
+              end
+
+              describe 'existing type' do
+                let(:type_name) do
+                  'package'
+                end
+
+                before :each do
+                  FileUtils.rm_rf(type_spec_dir)
+                  FileUtils.rm_rf(type_dir)
+                end
+
+                # it 'raise error' do
+                #   expect{Retrospec::Puppet::Generators::TypeGenerator.new(module_path,
+                #      cli_opts)}.to raise_exception Retrospec::Puppet::Generators::CoreTypeException
+                # end
+              end
+            end
+          end

data/spec/unit/module_spec.rb

@@ -1,14 +1,12 @@
 require 'spec_helper'
 
 describe 'Utilities::Module' do
-
   before :each do
     clean_up_spec_dir(@path)
-    @opts = {:module_path => @path, :enable_beaker_tests => false,
-             :enable_user_templates => false, :template_dir => nil }
+    @opts = { :module_path => @path, :enable_beaker_tests => false,
+              :enable_user_templates => false, :template_dir => nil }
     @module = Utilities::PuppetModule.instance
     @module.module_path = @opts[:module_path]
-
   end
 
   before :all do
@@ -23,7 +21,7 @@ describe 'Utilities::Module' do
   end
 
   it 'should create tmp module path' do
-    expect(File.exists?(@module.tmp_modules_dir)).to be true
+    expect(File.exist?(@module.tmp_modules_dir)).to be true
   end
 
   it 'should create a temp modules dir' do
@@ -34,7 +32,7 @@ describe 'Utilities::Module' do
   it 'should create a temp modules dir' do
     tomcat_path = @module.create_tmp_module_path(@opts[:module_path])
     expect(tomcat_path).to match(/modules/)
-    expect(File.exists?(tomcat_path)).to be true
+    expect(File.exist?(tomcat_path)).to be true
   end
 
   it 'should set the module path' do
@@ -43,13 +41,12 @@ describe 'Utilities::Module' do
 
   it 'should create a link in the temp modules directory' do
     tmp_path = @module.create_tmp_module_path(@opts[:module_path])
-    expect(File.exists?(tmp_path)).to eq(true)
+    expect(File.exist?(tmp_path)).to eq(true)
     expect(tmp_path).to eq(File.join(@module.tmp_modules_dir, @module.module_name))
   end
 
   it 'should find types' do
     expect(@module.types).to be_instance_of(Array)
-    expect(@module.types.map {|t| t.name}.length).to eq(18)
+    expect(@module.types.map(&:name).length).to eq(18)
   end
-
-end
+end

data/spec/unit/plugin_spec.rb

@@ -1,30 +1,228 @@
 require 'spec_helper'
 require 'retrospec'
 
-describe "puppet" do
-  let(:plugin) do
-    Retrospec::Plugins::V1::Puppet.new('/tmp/testplugin_dir', {:name => 'testplugin', :config1 => 'test'})
-  end
+describe 'puppet' do
 
+  it 'can show the version' do
+    expect(Retrospec::Puppet::VERSION).to be_instance_of(String)
+  end
   let(:global_opts) do
-    {:module_path => '/tmp/testplugin_dir'}
+    {}
   end
 
-  before :each do
-    FileUtils.rm_rf('/tmp/testplugin_dir')
+  let(:plugin_config) do
+    {}
   end
 
-  it 'can show the version' do
-    expect(Retrospec::Puppet::VERSION).to eq('0.10.0')
+  let(:args) do
+    []
+  end
+
+  let(:global_config) do
+    {}
   end
 
-  # disabling for now until we can stub gets
-  xit 'can run cli and create new module' do
-    expect(Retrospec::Plugins::V1::Puppet.run_cli(global_opts, {},{}, ['new_module'])).to eq(nil)
+  let(:retrospec) do
+    Retrospec::Plugins::V1::Puppet.run_cli(global_opts, global_config, plugin_config, args)
+  end
+
+  describe 'new_module' do
+
+    let(:module_path) do
+      '/tmp/testabc123'
+    end
+
+    before(:all) do
+      ENV['RETROSPEC_PUPPET_AUTO_GENERATE'] = 'true'
+    end
+
+    let(:plugin_config) do
+      {
+        'plugins::puppet::template_dir' => retrospec_templates_path,
+        'plugins::puppet::author' => 'test_name',
+        'plugins::puppet::default_license' => 'Apache-3.0'
+      }
+    end
+
+
+    describe 'without module path' do
+      before(:each) do
+        FileUtils.rm_rf('/tmp/testabc123')
+      end
+
+      let(:module_path) do
+        '/tmp'
+      end
+
+      let(:global_opts) do
+        {:module_path => module_path }
+      end
+
+      let(:args) do
+        ['new_module', '-n', 'testabc123']
+      end
+
+      it 'should create a module when it does not exist' do
+        retrospec
+        expect(File.exist?(File.join(module_path, 'testabc123', 'manifests', 'init.pp'))).to eq(true)
+        expect(File.exist?(File.join(module_path, 'testabc123', 'metadata.json'))).to eq(true)
+        expect(File.exist?(File.join(module_path, 'testabc123', 'testabc123_schema.yaml'))).to eq(true)
+        metadata = JSON.parse(File.read(File.join(module_path, 'testabc123', 'metadata.json')))
+        expect(metadata['author']).to eq('test_name')
+        expect(metadata['license']).to eq('Apache-3.0')
+      end
+    end
+
+    describe 'with path' do
+      let(:module_path) do
+        '/tmp/testabc124'
+      end
+
+      let(:global_opts) do
+        {:module_path => module_path }
+      end
+
+      before(:all) do
+        FileUtils.rm_rf('/tmp/testabc124')
+      end
+
+      let(:args) do
+        ['new_module', '-n', 'testabc124']
+      end
+
+      it 'should create a module when it does not exist' do
+        retrospec
+        expect(File.exist?(File.join(module_path, 'manifests', 'init.pp'))).to eq(true)
+        expect(File.exist?(File.join(module_path, 'metadata.json'))).to eq(true)
+        expect(File.exist?(File.join(module_path, 'testabc124_schema.yaml'))).to eq(true)
+        metadata = JSON.parse(File.read(File.join(module_path, 'metadata.json')))
+        expect(metadata['author']).to eq('test_name')
+        expect(metadata['license']).to eq('Apache-3.0')
+      end
+    end
   end
 
-  xit 'can run cli' do
-    Retrospec::Plugins::V1::Puppet.run_cli(global_opts, {},{}, ['new_module'])
-    expect(Retrospec::Plugins::V1::Puppet.run_cli(global_opts, {},{}, [])).to eq(nil)
+  describe 'generator functions' do
+    let(:module_path) do
+      '/tmp/testabc123'
+    end
+
+    before(:all) do
+      ENV['RETROSPEC_PUPPET_AUTO_GENERATE'] = 'true'
+    end
+
+    let(:plugin_config) do
+      {
+        'plugins::puppet::template_dir' => retrospec_templates_path,
+        'plugins::puppet::author' => 'test_name'
+      }
+    end
+
+    let(:global_opts) do
+      {:module_path => module_path }
+    end
+
+    before(:each) do
+      FileUtils.rm_rf(module_path)
+      # ensure the module exists
+      Retrospec::Plugins::V1::Puppet.run_cli(global_opts,
+       global_config, plugin_config,
+        ['new_module', '-n', 'testabc123'])
+    end
+
+    describe 'new_fact' do
+
+      let(:args) do
+        ['new_fact', '-n', 'test_fact']
+      end
+
+      it 'should create spec and rb file' do
+        retrospec
+        expect(File.exist?(File.join(module_path,'lib', 'facter', 'test_fact.rb'))).to eq(true)
+        expect(File.exist?(File.join(module_path, 'spec', 'unit', 'facter', 'test_fact_spec.rb'))).to eq(true)
+      end
+    end
+
+    describe 'new_type' do
+      let(:type_name) do
+        'type_a'
+      end
+      let(:type_dir) do
+        File.join(module_path,'lib', 'puppet', 'type')
+      end
+
+      let(:type_spec_dir) do
+        File.join(module_path, 'spec', 'unit', 'puppet', 'type')
+      end
+
+      let(:args) do
+        ['new_type', '-n', type_name]
+      end
+
+      it 'should create spec and rb file' do
+        retrospec
+        expect(File.exist?(File.join(type_dir, "#{type_name}.rb"))).to eq(true)
+        expect(File.exist?(File.join(type_spec_dir, "#{type_name}_spec.rb"))).to eq(true)
+      end
+
+      describe 'core type' do
+        let(:type_name) do
+          'package'
+        end
+
+        it 'should raise error' do
+          retrospec
+          expect(File.exist?(File.join(type_dir, "#{type_name}.rb"))).to eq(false)
+          expect(File.exist?(File.join(type_spec_dir, "#{type_name}_spec.rb"))).to eq(false)
+        end
+      end
+    end
+    describe 'new_provider' do
+
+      let(:args) do
+        ['new_provider', '-n', 'pname', '--type', 'type_a']
+      end
+
+      it 'should create spec and rb file' do
+        retrospec
+        expect(File.exist?(File.join(module_path,'lib', 'puppet', 'provider', 'type_a', 'pname.rb'))).to eq(true)
+        expect(File.exist?(File.join(module_path, 'spec', 'unit', 'puppet', 'provider', 'type_a', 'pname_spec.rb'))).to eq(true)
+      end
+    end
+
+    describe 'new_function' do
+
+      describe 'v3' do
+        let(:args) do
+          ['new_function', '-n', 'test_func_v3', '--type', 'v3']
+        end
+
+        it 'should create v3 function' do
+          retrospec
+          expect(File.exist?(File.join(module_path,'lib', 'puppet','parser', 'functions', 'test_func_v3.rb'))).to eq(true)
+        end
+
+        it 'should create v3 function spec file' do
+          retrospec
+          expect(File.exist?(File.join(module_path, 'spec', 'functions', 'test_func_v3_spec.rb'))).to eq(true)
+        end
+
+      end
+      describe 'v4' do
+        let(:args) do
+          ['new_function', '-n', 'test_func_v4', '--type', 'v4']
+        end
+
+        it 'should create v4 function' do
+          retrospec
+          expect(File.exist?(File.join(module_path,'lib', 'puppet', 'functions', 'test_func_v4.rb'))).to eq(true)
+        end
+
+        it 'should create v4 function spec file' do
+          retrospec
+          expect(File.exist?(File.join(module_path, 'spec', 'functions', 'test_func_v4_spec.rb'))).to eq(true)
+        end
+      end
+    end
   end
 end