puppet-retrospec 0.11.0 → 0.12.0

data/spec/unit/generators/function_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe 'function' do
+
+  describe 'v3 function' do
+    let(:function_file) do
+      File.join(sample_module_path, 'lib', 'puppet', 'parser', 'functions', 'sha1.rb')
+    end
+
+    let(:models) do
+      Retrospec::Puppet::Parser::Functions.load_function(function_file)
+    end
+
+    it 'can eval' do
+      expect(models.name).to eq(:sha1)
+      expect(models.doc).to eq('Returns a SHA1 hash value from a provided string.')
+      expect(models.type).to eq(:rvalue)
+      expect(models.arity).to eq(1)
+    end
+
+    describe 'bad function' do
+      let(:function_file) do
+        File.join(sample_module_path, 'lib', 'puppet', 'parser', 'functions', 'bad_sha1.rb')
+      end
+      it 'should raise error' do
+        expect{models.name}.to raise_error SyntaxError
+      end
+    end
+  end
+
+  describe 'v4 function' do
+    let(:function_file) do
+      File.join(sample_module_path, 'lib', 'puppet', 'functions', 'reduce.rb')
+    end
+
+    let(:models) do
+      Retrospec::Puppet::Functions.load_function(function_file)
+    end
+
+    it 'can eval' do
+      expect(models.name).to eq(:reduce)
+    end
+
+    it 'returns array of dispatched methods hashes' do
+      expect(models.dispatched_methods).to be_instance_of(Hash)
+    end
+
+    it 'returns correct number of dispached methods' do
+      expect(models.dispatched_methods.keys).to eq([:reduce_without_memo, :reduce_with_memo])
+    end
+
+    it 'returns params of dispatched method' do
+      expect(models.dispatched_methods[:reduce_without_memo][:args].count).to eq(2)
+      expect(models.dispatched_methods[:reduce_without_memo][:args].first[:name]).to eq(:param)
+      expect(models.dispatched_methods[:reduce_without_memo][:args].last[:name]).to eq(:block_param)
+    end
+
+    it 'returns required methods' do
+      expect(Retrospec::Puppet::Functions.find_required_methods(:reduce, [:reduce_without_memo, :reduce_with_memo])).to eq([:reduce_without_memo, :reduce_with_memo])
+    end
+
+    it 'returns required methods' do
+      expect(Retrospec::Puppet::Functions.find_required_methods(:reduce)).to eq([:reduce])
+    end
+
+  end
+end

data/spec/unit/generators/parsers/fact_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe "facter" do
+  let(:model) do
+    Retrospec::Puppet::Generators::Facter.load_fact(file)
+  end
+
+  describe 'node_role' do
+    let(:file) do
+      File.join(fixtures_facts_path , 'node_role.rb')
+    end
+    it 'can eval code' do
+      fact_name = model.facts.keys.first
+      expect(fact_name).to eq(:node_role)
+      fact_data = model.facts[fact_name]
+      confines = fact_data.confines
+      model_facts = model.facts[fact_name].used_facts
+      global_used_facts = model.global_used_facts
+      expect(confines).to eq({:kernel=>"Windows", :is_virtual=>true})
+      expect(model_facts).to eq({})
+      expect(global_used_facts).to eq({})
+    end
+  end
+
+
+  describe 'multiple facts' do
+    let(:file) do
+      File.join(fixtures_facts_path , 'datacenter_facts.rb')
+    end
+
+    it 'can eval code with multiple facts' do
+      global_used_facts = model[:global_used_facts]
+      fact_name = model.facts.keys.first
+      fact_data = model.facts[fact_name]
+      confines = fact_data.confines
+      model_facts = fact_data.used_facts
+      expect(fact_name).to eq(:fact1)
+      expect(confines).to eq({:kernel=>"Linux"})
+      expect(model_facts).to eq({})
+      expect(global_used_facts).to eq({})
+      fact_name = model.facts.keys.last
+      fact_data = model.facts[fact_name]
+      confines = fact_data.confines
+      model_facts = fact_data.used_facts
+      expect(fact_name).to eq(:fact2)
+      expect(confines).to eq({:kernel=>"Windows"})
+      expect(model_facts).to eq({})
+      expect(global_used_facts).to eq({})
+    end
+  end
+
+  describe 'fact value' do
+    let(:file) do
+      File.join(fixtures_facts_path , 'facts_with_methods.rb')
+    end
+    it 'can be processed' do
+      expect(model).to_not eq(nil)
+    end
+
+  end
+
+end

data/spec/unit/generators/parsers/provider_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe 'provider' do
+  let(:provider_file) do
+    File.join(fixtures_provider_path, 'bmc', 'ipmitool.rb')
+  end
+
+  let(:type_file) do
+    File.join(fixtures_type_path, 'bmc.rb')
+  end
+
+  let(:models) do
+    Retrospec::Puppet::Type.load_type(type_file, provider_file)
+  end
+
+  it 'can eval code' do
+    expect(models.name).to eq(:ipmitool)
+  end
+
+  it 'contains class methods' do
+    expect(models.class_methods).to eq([:ipmitoolcmd, :instances, :prefetch, :laninfo,
+                                        :convert_vlanid, :convert_ip_source])
+  end
+
+  it 'contains a file' do
+    expect(models.file).to eq(provider_file)
+  end
+
+  it 'contains instance methods' do
+    expect(models.instance_methods).to eq([:ipmitoolcmd, :ensure, :ensure=, :ipsource,
+                                           :ipsource=, :ip, :ip=, :netmask, :netmask=,
+                                           :gateway, :gateway=, :vlanid, :vlanid=,
+                                           :provider, :provider=, :flush, :install,
+                                           :remove, :exists?])
+  end
+
+  it 'contains properties' do
+    expect(models.properties).to eq([:ensure, :ipsource, :ip, :netmask, :gateway, :vlanid])
+  end
+
+  it 'contains parameters' do
+    expect(models.parameters).to eq([:name, :provider])
+  end
+end

data/spec/unit/generators/parsers/type_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+describe 'type' do
+  describe 'bmc' do
+    let(:file) do
+      File.join(fixtures_type_path, 'bmc.rb')
+    end
+
+    let(:models) do
+      Retrospec::Puppet::Type.load_type(file)
+    end
+
+    it 'can eval code' do
+      models = Retrospec::Puppet::Type.load_type(file)
+      expect(models.name).to eq(:bmc)
+    end
+
+    it 'has correct amount of properties' do
+      expect(models.properties).to eq([:ensure, :ipsource, :ip, :netmask, :gateway, :vlanid])
+    end
+
+    it 'has correct amount of parameters' do
+      expect(models.parameters).to eq([:name, :provider])
+    end
+
+    it 'has the correct number of instance methods' do
+      expect(models.instance_methods).to eq([:validaddr?])
+    end
+  end
+
+  describe 'bmcuser' do
+    let(:file) do
+      File.join(fixtures_type_path, 'bmcuser.rb')
+    end
+
+    let(:models) do
+      Retrospec::Puppet::Type.load_type(file)
+    end
+
+    it 'can eval code' do
+      models = Retrospec::Puppet::Type.load_type(file)
+      expect(models.name).to eq(:bmcuser)
+    end
+
+    it 'has correct amount of properties' do
+      expect(models.properties).to eq([:ensure, :id, :username, :userpass, :privlevel])
+    end
+
+    it 'has correct amount of parameters' do
+      expect(models.parameters).to eq([:name, :force])
+    end
+
+    it 'has the correct number of instance methods' do
+      expect(models.instance_methods).to eq([])
+    end
+  end
+
+  describe 'opatch' do
+    let(:file) do
+      File.join(fixtures_type_path, 'db_opatch.rb')
+    end
+
+    let(:models) do
+      Retrospec::Puppet::Type.load_type(file)
+    end
+
+    it 'can eval code' do
+      models = Retrospec::Puppet::Type.load_type(file)
+      expect(models.name).to eq(:db_opatch)
+    end
+
+    it 'has correct amount of properties' do
+      expect(models.properties).to eq([:ensure, :test_boolean])
+    end
+
+    it 'has correct amount of parameters' do
+      expect(models.parameters).to eq([:name,
+                                        :patch_id,
+                                        :os_user,
+                                        :oracle_product_home_dir,
+                                        :orainst_dir,
+                                        :extracted_patch_dir,
+                                        :ocmrf_file,
+                                        :opatch_auto,
+                                        :bundle_sub_patch_id])
+    end
+
+    it 'has the correct number of instance methods' do
+      expect(models.instance_methods).to eq([])
+    end
+
+  end
+end

data/spec/unit/generators/provider_generator_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+describe 'provider_generator' do
+  before :each do
+    FileUtils.rm_rf(provider_spec_dir)
+    FileUtils.rm_rf(provider_dir)
+  end
+
+  let(:type_name) do
+    'test_type'
+  end
+
+  after :each do
+    FileUtils.rm_f(generator.provider_name_path) # ensure the file does not exist
+  end
+
+  let(:provider_name) do
+    'default'
+  end
+
+  let(:provider_spec_dir) do
+    File.join(module_path, 'spec', 'unit', 'puppet', 'provider')
+  end
+
+  let(:provider_dir) do
+    File.join(module_path, 'lib', 'puppet', 'provider', type_name)
+  end
+
+  let(:module_path) do
+    File.join(fixture_modules_path, 'tomcat')
+  end
+
+  let(:opts) do
+    ['-n', provider_name, '-t', type_name]
+  end
+
+  let(:cli_opts) do
+    cli_opts = Retrospec::Puppet::Generators::ProviderGenerator.run_cli(context, opts)
+  end
+
+  let(:context) do
+    { :module_path => module_path,
+      :template_dir => retrospec_templates_path }
+  end
+
+  let(:generator) do
+    Retrospec::Puppet::Generators::ProviderGenerator.new(module_path, cli_opts)
+  end
+
+  it 'returns provider dir' do
+    expect(generator.provider_dir).to eq(File.join(module_path, 'lib', 'puppet', 'provider'))
+  end
+
+  it 'returns spec directory' do
+    expect(generator.provider_spec_dir).to eq(provider_spec_dir)
+  end
+
+  it 'can return provider name' do
+    expect(generator.provider_name).to eq(provider_name)
+  end
+
+  it 'can generate a provider file' do
+    expect(generator.generate_provider_files).to eq(File.join(provider_dir, "#{provider_name}.rb"))
+    expect(File.exist?(File.join(provider_dir, "#{provider_name}.rb")))
+  end
+
+  # because these tests were initially designed to only work with a single type name we will have to go
+  # back and rethink how all the names are derived, or possibly structure the fixtures as modules
+  it 'can generate a spec file' do
+    allow(generator).to receive(:provider_dir).and_return(fixtures_provider_path)
+    allow(generator).to receive(:type_dir).and_return(fixtures_type_path)
+    files = [File.join(provider_spec_dir, 'bmc', 'ipmitool_spec.rb'), File.join(provider_spec_dir, 'bmcuser', 'ipmitool_spec.rb')]
+    expect(generator.generate_provider_spec_files).to eq(files)
+  end
+
+  describe 'type_file' do
+    before :each do
+      allow(generator).to receive(:provider_dir).and_return(fixtures_provider_path)
+      allow(generator).to receive(:type_dir).and_return(fixtures_type_path)
+    end
+
+    it 'return path of custom type' do
+      expect(generator.type_file('bmc')).to eq("#{fixtures_type_path}/bmc.rb")
+    end
+
+    it 'return path of core type' do
+      expect(generator.type_file('package')).to eq('puppet/type/package.rb')
+    end
+
+  end
+  describe 'cli' do
+    it 'can run the cli options' do
+      # specify the parameters
+      expect(cli_opts).to be_an_instance_of Hash
+      expect(cli_opts[:name]).to eq(provider_name)
+      expect(cli_opts[:type]).to eq(type_name)
+    end
+  end
+  describe 'existing type' do
+    describe 'package' do
+      let(:type_name) do
+        'package'
+      end
+      let(:provider_name) do
+        'ibm_pkg'
+      end
+
+      it 'can generate a spec file' do
+        generator.generate_provider_files
+        files = [File.join(provider_spec_dir, "#{type_name}", "#{provider_name}_spec.rb")]
+        expect(generator.generate_provider_spec_files).to eq(files)
+      end
+
+      it 'can generate a provider file' do
+        expect(generator.generate_provider_files).to eq(File.join(provider_dir, "#{provider_name}.rb"))
+        expect(File.exist?(File.join(provider_dir, "#{provider_name}.rb")))
+      end
+    end
+  end
+end

data/spec/unit/generators/schema_generator_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+describe 'schema_generator' do
+
+  before(:each) do
+    FileUtils.rm(schema_file) if File.exists?(schema_file)
+  end
+
+  let(:generator_opts) do
+    {:name => 'test', :puppet_context => puppet_context,  :template_dir => template_dir}
+  end
+
+  let(:module_path) do
+    sample_module_path
+  end
+
+  let(:schema_file) do
+    path = File.join(module_path, 'tomcat_schema.yaml')
+  end
+
+  let(:template_dir) do
+    File.expand_path(File.join(ENV['HOME'], '.retrospec', 'repos', 'retrospec-puppet-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 => template_dir }
+    mod = Retrospec::Plugins::V1::Puppet.new(opts[:module_path], opts)
+    mod.post_init
+    mod.context
+  end
+
+  let(:generator) do
+    Retrospec::Puppet::Generators::SchemaGenerator.new(module_path, generator_opts)
+  end
+
+  let(:hostclass_items) do
+    {
+      "tomcat::catalina_home"=>{"type"=>"any", "required"=>false},
+      "tomcat::user"=>{"type"=>"any", "required"=>false},
+      "tomcat::group"=>{"type"=>"any", "required"=>false},
+      "tomcat::install_from_source"=>{"type"=>"bool", "required"=>false},
+      "tomcat::purge_connectors"=>{"type"=>"bool", "required"=>false},
+      "tomcat::purge_realms"=>{"type"=>"bool", "required"=>false},
+      "tomcat::manage_user"=>{"type"=>"bool", "required"=>false},
+      "tomcat::manage_group"=>{"type"=>"bool", "required"=>false}
+    }
+  end
+  let(:schema_map) do
+    {"type"=>"map",
+     "mapping"=>
+       {
+        "definition" => {
+          "tomcat::war::catalina_base"=>{"type"=>"any", "required"=>false},
+          "tomcat::war::app_base"=>{"type"=>"any", "required"=>false},
+          "tomcat::war::deployment_path"=>{"type"=>"any", "required"=>false},
+          "tomcat::war::war_ensure"=>{"type"=>"str", "required"=>false},
+          "tomcat::war::war_name"=>{"type"=>"any", "required"=>false},
+          "tomcat::war::war_purge"=>{"type"=>"bool", "required"=>false},
+          "tomcat::war::war_source"=>{"type"=>"any", "required"=>false}
+        }
+       }
+    }
+  end
+
+  it 'should create files without error' do
+    expect(generator.generate_schema_file).to eq(schema_file)
+    expect(File.exists?(schema_file)).to eq(true)
+  end
+
+  it 'should contain proper mapping' do
+    schema_file = generator.generate_schema_file
+    sch = YAML.load_file(schema_file)
+    expect(sch.keys).to eq(["type", "mapping"])
+    expect(sch['mapping'].keys).to eq(["hostclass", "definition"])
+    expect(sch['mapping']['hostclass'].keys).to eq(["type", "mapping"])
+    expect(sch['mapping']['definition'].keys).to eq(["type", "mapping"])
+    expect(sch['mapping']['hostclass']['mapping']).to eq(hostclass_items)
+    expect(sch['mapping']['definition']['mapping'].keys.count).to eq(125)
+
+  end
+
+  it 'should produce correct file name' do
+    expect(generator.schema_path).to eq(schema_file)
+  end
+
+  # since the module_spec class is a singleton we can't easily change out the module_path
+  # describe 'required parameter' do
+  #   let(:puppet_context) do
+  #     path = File.join(fake_fixture_modules, 'required_parameters')
+  #     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
+  #
+  #   let(:generator) do
+  #     Retrospec::Puppet::Generators::SchemaGenerator.new(module_path, generator_opts)
+  #   end
+  #
+  #   let(:schema_map) do
+  #     {"type"=>"map",
+  #      "mapping"=>
+  #        {"tomcat::catalina_home"=>{"type"=>"any", "required"=>false},
+  #         "tomcat::user"=>{"type"=>"any", "required"=>false},
+  #         "tomcat::group"=>{"type"=>"any", "required"=>false},
+  #         "tomcat::install_from_source"=>{"type"=>"bool", "required"=>false},
+  #         "tomcat::purge_connectors"=>{"type"=>"bool", "required"=>false},
+  #         "tomcat::purge_realms"=>{"type"=>"bool", "required"=>false},
+  #         "tomcat::manage_user"=>{"type"=>"bool", "required"=>false},
+  #         "tomcat::manage_group"=>{"type"=>"bool", "required"=>false}
+  #        }
+  #     }
+  #   end
+  # end
+  # it 'should detect when a parameter is required' do
+  #   expect(generator.create_map_content).to eq(schema_map)
+  # end
+
+end