puppet-retrospec 0.5.1 → 0.6.0

data/spec/unit/module_spec.rb

@@ -0,0 +1,55 @@
+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 }
+    @module = Utilities::PuppetModule.instance
+    @module.module_path = @opts[:module_path]
+
+  end
+
+  before :all do
+    # 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')
+  end
+
+  it 'should create an instance' do
+    expect(@module).to be_instance_of(Utilities::PuppetModule)
+  end
+
+  it 'should create tmp module path' do
+    expect(File.exists?(@module.tmp_modules_dir)).to be true
+  end
+
+  it 'should create a temp modules dir' do
+    tomcat_path = Utilities::PuppetModule.create_tmp_module_path
+    expect(tomcat_path).to match(/modules/)
+  end
+
+  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
+  end
+
+  it 'should set the module path' do
+    expect(@module.module_path).to eq(@opts[:module_path])
+  end
+
+  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(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(14)
+  end
+
+end

data/spec/unit/puppet-retrospec_spec.rb

@@ -10,7 +10,7 @@ describe "puppet-retrospec" 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')
@@ -18,15 +18,22 @@ describe "puppet-retrospec" do
   end
 
   before :each do
-    #clean_up_spec_dir(@path)
+    clean_up_spec_dir(@path)
     @opts = {:module_path => @path, :enable_beaker_tests => false,
              :enable_user_templates => false, :template_dir => nil }
   end
 
   it 'should run without errors using new' do
+    tomcat = Retrospec.new(@opts[:module_path], @opts)
+    expect(tomcat).to be_instance_of(Retrospec)
+  end
+
+  it 'should create files without error' do
     tomcat = Retrospec.new(@opts[:module_path], @opts)
     expect(tomcat.create_files).to eq(true)
     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', '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)
   end
@@ -116,7 +123,7 @@ describe "puppet-retrospec" do
   it 'should create proper spec helper file' do
     tomcat = Retrospec.new(@opts[:module_path], @opts)
     filepath = File.expand_path(File.join(@path, 'spec', 'spec_helper.rb'))
-    path = tomcat.create_tmp_module_path(@opts[:module_path])
+    path = tomcat.module_path
     tomcat.safe_create_spec_helper
     expect(File.exists?(filepath)).to eq(true)
   end
@@ -124,7 +131,7 @@ describe "puppet-retrospec" do
   it 'should create proper shared context file' do
     tomcat = Retrospec.new(@opts[:module_path], @opts)
     filepath = File.expand_path(File.join(@path, 'spec', 'shared_contexts.rb'))
-    path = tomcat.create_tmp_module_path(@opts[:module_path])
+    path = tomcat.module_path
     tomcat.safe_make_shared_context
     expect(File.exists?(filepath)).to eq(true)
   end
@@ -172,20 +179,6 @@ describe "puppet-retrospec" do
     Helpers.should_not_receive(:safe_create_file).with(anything,'resource_spec_file.erb')
   end
 
-  it 'should create a temp modules dir' do
-    tomcat = Retrospec.new(@opts[:module_path], @opts)
-    path = tomcat.tmp_modules_dir
-    path.should =~ /modules/
-  end
-
-  it 'should create a link in the temp modules directory' do
-    tomcat = Retrospec.new(@opts[:module_path], @opts)
-    path = tomcat.tmp_modules_dir
-    tmp_path = tomcat.create_tmp_module_path(@opts[:module_path])
-    expect(File.exists?(tmp_path)).to eq(true)
-    expect(tmp_path).to eq(File.join(path, tomcat.module_name))
-  end
-
   it 'should create a file from a template' do
     tomcat = Retrospec.new(@opts[:module_path], @opts)
     tomcat.safe_create_template_file('.fixtures.yml', 'fixtures_file.erb')
@@ -201,14 +194,14 @@ describe "puppet-retrospec" do
         allow(type).to receive(:type).and_return(:hostclass)
         allow(type).to receive(:name).and_return('tomcat::config::server::connector')
         tomcat = Retrospec.new(@opts[:module_path], @opts)
-        expect(tomcat.generate_file_path(type, true)).to eq("spec/acceptance/classes/config/server/connector/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")
         allow(type).to receive(:type).and_return(:hostclass)
         allow(type).to receive(:name).and_return('tomcat::config::server::connector')
         tomcat = Retrospec.new(@opts[:module_path], @opts)
-        expect(tomcat.generate_file_path(type, false)).to eq("spec/classes/config/server/connector/connector_spec.rb")
+        expect(tomcat.generate_file_path(type, false)).to eq("spec/classes/config/server/connector_spec.rb")
       end
     end
 
@@ -218,7 +211,7 @@ describe "puppet-retrospec" do
         allow(type).to receive(:type).and_return(:definition)
         allow(type).to receive(:name).and_return('tomcat::config::server::connector')
         tomcat = Retrospec.new(@opts[:module_path], @opts)
-        expect(tomcat.generate_file_path(type, true)).to eq("spec/acceptance/defines/config/server/connector/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
@@ -226,7 +219,7 @@ describe "puppet-retrospec" do
         allow(type).to receive(:type).and_return(:definition)
         allow(type).to receive(:name).and_return('tomcat::config::server::connector')
         tomcat = Retrospec.new(@opts[:module_path], @opts)
-        expect(tomcat.generate_file_path(type, false)).to eq("spec/defines/config/server/connector/connector_spec.rb")
+        expect(tomcat.generate_file_path(type, false)).to eq("spec/defines/config/server/connector_spec.rb")
       end
     end
   end

data/spec/unit/resource_spec.rb

@@ -11,52 +11,60 @@ describe "resource" do
     # 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/
     @path = File.join(fixture_modules_path, 'tomcat')
-
-
   end
 
   before :each do
     clean_up_spec_dir(@path)
-    @opts = {:module_path => @path, :enable_beaker_tests => false,
-             :enable_user_templates => false, :template_dir => nil }
-
   end
 
-  it 'should initialize with one resource' do
-    my_path = File.expand_path(File.join('spec', 'fixtures', 'fixture_modules', 'one_resource_module'))
-    my_retro = Retrospec.new(my_path)
-    r = Resource.all(my_retro.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")
-  end
+  describe 'one resource module' do
+    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
+      @m.module_path = my_path
+      @m.create_tmp_module_path(my_path)
+    end
+
+    it 'should initialize with one resource' do
+      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")
+    end
+
+    it 'should initialize with two resources' do
+      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")
+    end
 
-  it 'should initialize with two resources' do
-    my_path = File.expand_path(File.join('spec', 'fixtures', 'fixture_modules', 'one_resource_module'))
-    my_retro = Retrospec.new(my_path)
-    test_type = my_retro.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")
-  end
 
-  it 'should return resources' do
-    test_module = Retrospec.new(@opts[:module_path], @opts)
-    test_type = test_module.types[0]
-    expect(Resource.all(test_type.code)).to eq([])
-  end
 
-  it 'can process an empty class' do
-    my_path = File.expand_path(File.join('spec', 'fixtures', 'fixture_modules', 'zero_resource_module'))
-    my_retro = Retrospec.new(my_path)
-    r = Resource.all(my_retro.types.find {|x| x.name == 'empty_class'})
-    expect(r.size).to eq(0)
+    it 'should return resources' do
+      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}
+    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'}
+      r = Resource.all(test_type)
+      expect(r.size).to eq(0)
+    end
   end
 end

data/spec/unit/type_code_spec.rb

@@ -10,30 +10,48 @@ describe "type_code" do
   before :all do
     # 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/
-    @path = File.join(fixture_modules_path, 'tomcat')
-
-
   end
 
-  before :each do
-    my_path = File.expand_path(File.join('spec', 'fixtures', 'fixture_modules', 'one_resource_module'))
-    @my_retro = Retrospec.new(my_path)
-    @test_type = @my_retro.types.find {|x| x.name == 'one_resource::another_resource'}
 
-  end
-  it 'should initialize correctly scope name' do
-    expect(TypeCode.new(@test_type).scope_name).to eq('one_resource::another_resource')
-    expect(TypeCode.new(@test_type).type).to eq(@test_type)
+  describe 'one resource module' do
+    before :all do
+      @path = File.expand_path(File.join('spec', 'fixtures', 'fixture_modules', 'one_resource_module'))
+    end
+
+    before :each do
+      @opts = {:module_path => @path, :enable_beaker_tests => false,
+               :enable_user_templates => false, :template_dir => nil }
+    end
+    let(:instance) {Utilities::PuppetModule.send :new}
+
+    it 'should initialize correctly scope name' do
+      m = instance
+      m.module_path = @opts[:module_path]
+      m.create_tmp_module_path(@opts[:module_path])
+      test_type = m.types.find {|x| x.name == 'one_resource::another_resource'}
+      expect(TypeCode.new(test_type).scope_name).to eq('one_resource::another_resource')
+      expect(TypeCode.new(test_type).type).to eq(test_type)
+    end
+
+    it 'should find all the variables' do
+      m = instance
+      m.module_path = @opts[:module_path]
+      m.create_tmp_module_path(@opts[:module_path])
+      test_type = m.types.find {|x| x.name == 'one_resource::another_resource'}
+      expect(TypeCode.new(test_type).variables.size).to eq(4)
+    end
   end
 
-  it 'should find all the variables' do
-    expect(TypeCode.new(@test_type).variables.size).to eq(3)
+  describe 'zero module' do
+    let(:instance) {Utilities::PuppetModule.send :new}
+    it 'should respond correctly when class is empty' 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'}
+      expect{TypeCode.new(test_type).variables}.to_not raise_error
+    end
   end
 
-  it 'should respond correctly when class is empty' do
-    my_path = File.expand_path(File.join('spec', 'fixtures', 'fixture_modules', 'zero_resource_module'))
-    my_retro = Retrospec.new(my_path)
-    test_type = my_retro.types.find {|x| x.name == 'empty_class'}
-    expect{TypeCode.new(test_type).variables}.to_not raise_error
-  end
 end

data/spec/unit/variable_store_spec.rb

@@ -1,18 +1,25 @@
 require 'spec_helper'
 
 describe "variable_store" do
+  let(:instance) {Utilities::PuppetModule.send :new}
+
   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
 
   before :all do
+    @path = File.expand_path(File.join('spec', 'fixtures', 'fixture_modules', 'one_resource_module'))
     # 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/
   end
 
   before :each do
-    @my_path = File.expand_path(File.join('spec', 'fixtures', 'fixture_modules', 'one_resource_module'))
+    @opts = {:module_path => @path, :enable_beaker_tests => false,
+             :enable_user_templates => false, :template_dir => nil }
+    @module = instance
+    @module.module_path = @opts[:module_path]
+    @module.create_tmp_module_path(@opts[:module_path])
   end
 
   it 'should initialize' do
@@ -20,40 +27,36 @@ describe "variable_store" do
   end
 
   it 'should resolve a string' do
-    my_retro = Retrospec.new(@my_path)
-    test_type = my_retro.types.find {|x| x.name == 'one_resource::another_resource'}
+    test_type = @module.types.find {|x| x.name == 'one_resource::another_resource'}
     r = Resource.all(test_type).first
     string1 = ObjectSpace.each_object(Puppet::Parser::AST::String).find {|x| x.to_s == "\"value1\"" }
     expect(VariableStore.resolve(string1)).to eq("\"value1\"")
   end
 
   it 'should resolve a variable' do
-    my_retro = Retrospec.new(@my_path)
-    test_type = my_retro.types.find {|x| x.name == 'one_resource::another_resource'}
+    test_type = @module.types.find {|x| x.name == 'one_resource::another_resource'}
     r = Resource.all(test_type).first
     var1 = ObjectSpace.each_object(Puppet::Parser::AST::Variable).find {|x| x.to_s == '$file_name' }
+    VariableStore.add(var1,'/tmp/test3')
     expect(VariableStore.resolve(var1)).to eq("/tmp/test3")
   end
 
   it 'should resolve a basic vardef type' do
-    my_retro = Retrospec.new(@my_path)
-    test_type = my_retro.types.find {|x| x.name == 'one_resource::another_resource'}
+    test_type = @module.types.find {|x| x.name == 'one_resource::another_resource'}
     VariableStore.populate(test_type)
-    vardef1 =  ObjectSpace.each_object(Puppet::Parser::AST::VarDef).find {|x| x.name.value == 'some_var'}
+    vardef1 = ObjectSpace.each_object(Puppet::Parser::AST::VarDef).find {|x| x.name.value == 'some_var'}
     expect(VariableStore.resolve(vardef1)).to eq("oohhhh")
   end
 
   it 'should resolve a concat vardef type' do
-    my_retro = Retrospec.new(@my_path)
-    test_type = my_retro.types.find {|x| x.name == 'one_resource::another_resource'}
+    test_type = @module.types.find {|x| x.name == 'one_resource::another_resource'}
     VariableStore.populate(test_type)
     vardef2 =  ObjectSpace.each_object(Puppet::Parser::AST::VarDef).find {|x| x.name.value == 'concat_var'}
     expect(VariableStore.resolve(vardef2)).to eq("/tmp/test3/test3183/oohhhh")
   end
 
   it 'should resolve vardef/concat with parameter value' do
-    my_retro = Retrospec.new(@my_path)
-    test_type = my_retro.types.find {|x| x.name == 'one_resource::another_resource'}
+    test_type = @module.types.find {|x| x.name == 'one_resource::another_resource'}
     VariableStore.populate(test_type)
     vardef3 =  ObjectSpace.each_object(Puppet::Parser::AST::VarDef).find {|x| x.name.value == 'cli_modules'}
     expect(VariableStore.resolve(vardef3)).to eq("/etc/hammer/cli.modules.d")
@@ -61,8 +64,7 @@ describe "variable_store" do
 
   describe '#add' do
     it 'should store the value correctly' do
-      my_retro = Retrospec.new(@my_path)
-      test_type = my_retro.types.find {|x| x.name == 'one_resource::another_resource'}
+      test_type = @module.types.find {|x| x.name == 'one_resource::another_resource'}
       string1 = ObjectSpace.each_object(Puppet::Parser::AST::String).find {|x| x.to_s == "\"value1\"" }
       expect(VariableStore.add(string1, 'blah')).to eq("blah")
       expect(VariableStore.lookup(string1)).to eq('blah')
@@ -74,9 +76,63 @@ describe "variable_store" do
     end
 
     it 'should store vardef as is' do
-      my_retro = Retrospec.new(@my_path)
-      test_type = my_retro.types.find {|x| x.name == 'one_resource::another_resource'}
+      test_type = @module.types.find {|x| x.name == 'one_resource::another_resource'}
+      VariableStore.populate(test_type)
+    end
+  end
+
+  describe 'populate' do
+    let(:instance) {Utilities::PuppetModule.send :new}
+
+    before :each do
+
+    end
+    it 'should load an resolve vars from the parent type' do
+      m = instance
+      m.module_path = @opts[:module_path]
+      m.create_tmp_module_path(@opts[:module_path])
+      test_type = m.types.find {|x| x.name == 'one_resource::another_resource'}
+      VariableStore.populate(test_type)
+      vars = {"$var1"=>"value1",
+       "$var2"=>"value2",
+       "$file_name"=>"/tmp/test3",
+       "$config_base_path"=>"/etc/hammer",
+       "$config_set"=>"param1_value",
+       "$concat_var"=>"/tmp/test3/test3183/oohhhh",
+       "$one_resource::params::param1_var1"=>"param1_value",
+       "$one_resource::params::var1"=>"params_class_value1",
+       "$one_resource::params::var2"=>"value2",
+       "$some_var"=>"oohhhh",
+       "$cli_modules"=>"/etc/hammer/cli.modules.d",
+       "$inherited_variable"=>"params_class_value1",
+      }
+      vars.each do |k,v|
+        expect(VariableStore.instance.store.keys.include?(k)).to be true
+        expect(VariableStore.instance.store[k]).to eq(v)
+      end
+    end
+
+    xit 'should resolve a fact' do
+      #test_type = @module.types.find {|x| x.name == 'one_resource::inherits_params'}
+    end
+
+    it 'should resolve a parent parameter' do
+      m = instance
+      m.module_path = @opts[:module_path]
+      m.create_tmp_module_path(@opts[:module_path])
+      test_type = m.types.find {|x| x.name == 'one_resource::another_resource'}
+      VariableStore.populate(test_type)
+      expect(VariableStore.instance.store['$config_set']).to eq('param1_value')
+
+    end
+
+    it 'should resolve a parent variable' do
+      m = instance
+      m.module_path = @opts[:module_path]
+      m.create_tmp_module_path(@opts[:module_path])
+      test_type = m.types.find {|x| x.name == 'one_resource::another_resource'}
       VariableStore.populate(test_type)
+      expect(VariableStore.instance.store['$inherited_variable']).to eq('params_class_value1')
     end
   end
 end