From fdc8c3509b5ac5bc170c54d72b2c2bafb58409f2 Mon Sep 17 00:00:00 2001 From: Markus Roberts Date: Mon, 28 Jun 2010 17:10:20 -0700 Subject: [#3994-part 3] rename spec tests from *_spec_spec to *_spec.rb Part 2 re-did the change on the spec files, which it shouldn't have. --- spec/unit/node/environment_spec.rb | 248 ++++++++++++++++++++++++++++++++ spec/unit/node/environment_spec_spec.rb | 248 -------------------------------- spec/unit/node/facts_spec.rb | 102 +++++++++++++ spec/unit/node/facts_spec_spec.rb | 102 ------------- 4 files changed, 350 insertions(+), 350 deletions(-) create mode 100755 spec/unit/node/environment_spec.rb delete mode 100755 spec/unit/node/environment_spec_spec.rb create mode 100755 spec/unit/node/facts_spec.rb delete mode 100755 spec/unit/node/facts_spec_spec.rb (limited to 'spec/unit/node') diff --git a/spec/unit/node/environment_spec.rb b/spec/unit/node/environment_spec.rb new file mode 100755 index 000000000..d0db2504c --- /dev/null +++ b/spec/unit/node/environment_spec.rb @@ -0,0 +1,248 @@ +#!/usr/bin/env ruby + +require File.dirname(__FILE__) + '/../../spec_helper' + +require 'puppet/node/environment' +require 'puppet/util/execution' + +describe Puppet::Node::Environment do + after do + Puppet::Node::Environment.clear + end + + it "should include the Cacher module" do + Puppet::Node::Environment.ancestors.should be_include(Puppet::Util::Cacher) + end + + it "should use the filetimeout for the ttl for the modulepath" do + Puppet::Node::Environment.attr_ttl(:modulepath).should == Integer(Puppet[:filetimeout]) + end + + it "should use the filetimeout for the ttl for the module list" do + Puppet::Node::Environment.attr_ttl(:modules).should == Integer(Puppet[:filetimeout]) + end + + it "should use the filetimeout for the ttl for the manifestdir" do + Puppet::Node::Environment.attr_ttl(:manifestdir).should == Integer(Puppet[:filetimeout]) + end + + it "should use the default environment if no name is provided while initializing an environment" do + Puppet.settings.expects(:value).with(:environment).returns("one") + Puppet::Node::Environment.new().name.should == :one + end + + it "should treat environment instances as singletons" do + Puppet::Node::Environment.new("one").should equal(Puppet::Node::Environment.new("one")) + end + + it "should treat an environment specified as names or strings as equivalent" do + Puppet::Node::Environment.new(:one).should equal(Puppet::Node::Environment.new("one")) + end + + it "should return its name when converted to a string" do + Puppet::Node::Environment.new(:one).to_s.should == "one" + end + + it "should just return any provided environment if an environment is provided as the name" do + one = Puppet::Node::Environment.new(:one) + Puppet::Node::Environment.new(one).should equal(one) + end + + describe "when managing known resource types" do + before do + @env = Puppet::Node::Environment.new("dev") + @collection = Puppet::Resource::TypeCollection.new(@env) + @collection.stubs(:perform_initial_import) + end + + it "should create a resource type collection if none exists" do + Puppet::Resource::TypeCollection.expects(:new).with(@env).returns @collection + @env.known_resource_types.should equal(@collection) + end + + it "should reuse any existing resource type collection" do + @env.known_resource_types.should equal(@env.known_resource_types) + end + + it "should perform the initial import when creating a new collection" do + @collection.expects(:perform_initial_import) + Puppet::Resource::TypeCollection.expects(:new).returns @collection + + @env.known_resource_types + end + + it "should create and return a new collection rather than returning a stale collection" do + @env.known_resource_types.expects(:stale?).returns true + + Puppet::Resource::TypeCollection.expects(:new).returns @collection + + @env.known_resource_types.should equal(@collection) + end + end + + [:modulepath, :manifestdir].each do |setting| + it "should validate the #{setting} directories" do + path = %w{/one /two}.join(File::PATH_SEPARATOR) + + env = Puppet::Node::Environment.new("testing") + env.stubs(:[]).with(setting).returns path + + env.expects(:validate_dirs).with(%w{/one /two}) + + env.send(setting) + end + + it "should return the validated dirs for #{setting}" do + path = %w{/one /two}.join(File::PATH_SEPARATOR) + + env = Puppet::Node::Environment.new("testing") + env.stubs(:[]).with(setting).returns path + env.stubs(:validate_dirs).returns %w{/one /two} + + env.send(setting).should == %w{/one /two} + end + end + + it "should prefix the value of the 'PUPPETLIB' environment variable to the module path if present" do + Puppet::Util::Execution.withenv("PUPPETLIB" => %w{/l1 /l2}.join(File::PATH_SEPARATOR)) do + env = Puppet::Node::Environment.new("testing") + module_path = %w{/one /two}.join(File::PATH_SEPARATOR) + env.expects(:validate_dirs).with(%w{/l1 /l2 /one /two}).returns %w{/l1 /l2 /one /two} + env.expects(:[]).with(:modulepath).returns module_path + + env.modulepath.should == %w{/l1 /l2 /one /two} + end + end + + describe "when validating modulepath or manifestdir directories" do + it "should not return non-directories" do + env = Puppet::Node::Environment.new("testing") + + FileTest.expects(:directory?).with("/one").returns true + FileTest.expects(:directory?).with("/two").returns false + + env.validate_dirs(%w{/one /two}).should == %w{/one} + end + + it "should use the current working directory to fully-qualify unqualified paths" do + FileTest.stubs(:directory?).returns true + env = Puppet::Node::Environment.new("testing") + + two = File.join(Dir.getwd, "two") + env.validate_dirs(%w{/one two}).should == ["/one", two] + end + end + + describe "when modeling a specific environment" do + it "should have a method for returning the environment name" do + Puppet::Node::Environment.new("testing").name.should == :testing + end + + it "should provide an array-like accessor method for returning any environment-specific setting" do + env = Puppet::Node::Environment.new("testing") + env.should respond_to(:[]) + end + + it "should ask the Puppet settings instance for the setting qualified with the environment name" do + Puppet.settings.expects(:value).with("myvar", :testing).returns("myval") + env = Puppet::Node::Environment.new("testing") + env["myvar"].should == "myval" + end + + it "should be able to return an individual module that exists in its module path" do + env = Puppet::Node::Environment.new("testing") + + mod = mock 'module' + Puppet::Module.expects(:new).with("one", env).returns mod + mod.expects(:exist?).returns true + + env.module("one").should equal(mod) + end + + it "should return nil if asked for a module that does not exist in its path" do + env = Puppet::Node::Environment.new("testing") + + mod = mock 'module' + Puppet::Module.expects(:new).with("one", env).returns mod + mod.expects(:exist?).returns false + + env.module("one").should be_nil + end + + it "should be able to return its modules" do + Puppet::Node::Environment.new("testing").should respond_to(:modules) + end + + describe ".modules" do + it "should return a module named for every directory in each module path" do + env = Puppet::Node::Environment.new("testing") + env.expects(:modulepath).at_least_once.returns %w{/a /b} + Dir.expects(:entries).with("/a").returns %w{foo bar} + Dir.expects(:entries).with("/b").returns %w{bee baz} + + env.modules.collect{|mod| mod.name}.sort.should == %w{foo bar bee baz}.sort + end + + it "should remove duplicates" do + env = Puppet::Node::Environment.new("testing") + env.expects(:modulepath).returns( %w{/a /b} ).at_least_once + Dir.expects(:entries).with("/a").returns %w{foo} + Dir.expects(:entries).with("/b").returns %w{foo} + + env.modules.collect{|mod| mod.name}.sort.should == %w{foo} + end + + it "should ignore invalid modules" do + env = Puppet::Node::Environment.new("testing") + env.stubs(:modulepath).returns %w{/a} + Dir.expects(:entries).with("/a").returns %w{foo bar} + + Puppet::Module.expects(:new).with { |name, env| name == "foo" }.returns mock("foomod", :name => "foo") + Puppet::Module.expects(:new).with { |name, env| name == "bar" }.raises( Puppet::Module::InvalidName, "name is invalid" ) + + env.modules.collect{|mod| mod.name}.sort.should == %w{foo} + end + + it "should create modules with the correct environment" do + env = Puppet::Node::Environment.new("testing") + env.expects(:modulepath).at_least_once.returns %w{/a} + Dir.expects(:entries).with("/a").returns %w{foo} + + env.modules.each {|mod| mod.environment.should == env } + end + + it "should cache the module list" do + env = Puppet::Node::Environment.new("testing") + env.expects(:modulepath).at_least_once.returns %w{/a} + Dir.expects(:entries).once.with("/a").returns %w{foo} + + env.modules + env.modules + end + end + end + + describe Puppet::Node::Environment::Helper do + before do + @helper = Object.new + @helper.extend(Puppet::Node::Environment::Helper) + end + + it "should be able to set and retrieve the environment" do + @helper.environment = :foo + @helper.environment.name.should == :foo + end + + it "should accept an environment directly" do + env = Puppet::Node::Environment.new :foo + @helper.environment = env + @helper.environment.name.should == :foo + end + + it "should accept an environment as a string" do + env = Puppet::Node::Environment.new "foo" + @helper.environment = env + @helper.environment.name.should == :foo + end + end +end diff --git a/spec/unit/node/environment_spec_spec.rb b/spec/unit/node/environment_spec_spec.rb deleted file mode 100755 index d0db2504c..000000000 --- a/spec/unit/node/environment_spec_spec.rb +++ /dev/null @@ -1,248 +0,0 @@ -#!/usr/bin/env ruby - -require File.dirname(__FILE__) + '/../../spec_helper' - -require 'puppet/node/environment' -require 'puppet/util/execution' - -describe Puppet::Node::Environment do - after do - Puppet::Node::Environment.clear - end - - it "should include the Cacher module" do - Puppet::Node::Environment.ancestors.should be_include(Puppet::Util::Cacher) - end - - it "should use the filetimeout for the ttl for the modulepath" do - Puppet::Node::Environment.attr_ttl(:modulepath).should == Integer(Puppet[:filetimeout]) - end - - it "should use the filetimeout for the ttl for the module list" do - Puppet::Node::Environment.attr_ttl(:modules).should == Integer(Puppet[:filetimeout]) - end - - it "should use the filetimeout for the ttl for the manifestdir" do - Puppet::Node::Environment.attr_ttl(:manifestdir).should == Integer(Puppet[:filetimeout]) - end - - it "should use the default environment if no name is provided while initializing an environment" do - Puppet.settings.expects(:value).with(:environment).returns("one") - Puppet::Node::Environment.new().name.should == :one - end - - it "should treat environment instances as singletons" do - Puppet::Node::Environment.new("one").should equal(Puppet::Node::Environment.new("one")) - end - - it "should treat an environment specified as names or strings as equivalent" do - Puppet::Node::Environment.new(:one).should equal(Puppet::Node::Environment.new("one")) - end - - it "should return its name when converted to a string" do - Puppet::Node::Environment.new(:one).to_s.should == "one" - end - - it "should just return any provided environment if an environment is provided as the name" do - one = Puppet::Node::Environment.new(:one) - Puppet::Node::Environment.new(one).should equal(one) - end - - describe "when managing known resource types" do - before do - @env = Puppet::Node::Environment.new("dev") - @collection = Puppet::Resource::TypeCollection.new(@env) - @collection.stubs(:perform_initial_import) - end - - it "should create a resource type collection if none exists" do - Puppet::Resource::TypeCollection.expects(:new).with(@env).returns @collection - @env.known_resource_types.should equal(@collection) - end - - it "should reuse any existing resource type collection" do - @env.known_resource_types.should equal(@env.known_resource_types) - end - - it "should perform the initial import when creating a new collection" do - @collection.expects(:perform_initial_import) - Puppet::Resource::TypeCollection.expects(:new).returns @collection - - @env.known_resource_types - end - - it "should create and return a new collection rather than returning a stale collection" do - @env.known_resource_types.expects(:stale?).returns true - - Puppet::Resource::TypeCollection.expects(:new).returns @collection - - @env.known_resource_types.should equal(@collection) - end - end - - [:modulepath, :manifestdir].each do |setting| - it "should validate the #{setting} directories" do - path = %w{/one /two}.join(File::PATH_SEPARATOR) - - env = Puppet::Node::Environment.new("testing") - env.stubs(:[]).with(setting).returns path - - env.expects(:validate_dirs).with(%w{/one /two}) - - env.send(setting) - end - - it "should return the validated dirs for #{setting}" do - path = %w{/one /two}.join(File::PATH_SEPARATOR) - - env = Puppet::Node::Environment.new("testing") - env.stubs(:[]).with(setting).returns path - env.stubs(:validate_dirs).returns %w{/one /two} - - env.send(setting).should == %w{/one /two} - end - end - - it "should prefix the value of the 'PUPPETLIB' environment variable to the module path if present" do - Puppet::Util::Execution.withenv("PUPPETLIB" => %w{/l1 /l2}.join(File::PATH_SEPARATOR)) do - env = Puppet::Node::Environment.new("testing") - module_path = %w{/one /two}.join(File::PATH_SEPARATOR) - env.expects(:validate_dirs).with(%w{/l1 /l2 /one /two}).returns %w{/l1 /l2 /one /two} - env.expects(:[]).with(:modulepath).returns module_path - - env.modulepath.should == %w{/l1 /l2 /one /two} - end - end - - describe "when validating modulepath or manifestdir directories" do - it "should not return non-directories" do - env = Puppet::Node::Environment.new("testing") - - FileTest.expects(:directory?).with("/one").returns true - FileTest.expects(:directory?).with("/two").returns false - - env.validate_dirs(%w{/one /two}).should == %w{/one} - end - - it "should use the current working directory to fully-qualify unqualified paths" do - FileTest.stubs(:directory?).returns true - env = Puppet::Node::Environment.new("testing") - - two = File.join(Dir.getwd, "two") - env.validate_dirs(%w{/one two}).should == ["/one", two] - end - end - - describe "when modeling a specific environment" do - it "should have a method for returning the environment name" do - Puppet::Node::Environment.new("testing").name.should == :testing - end - - it "should provide an array-like accessor method for returning any environment-specific setting" do - env = Puppet::Node::Environment.new("testing") - env.should respond_to(:[]) - end - - it "should ask the Puppet settings instance for the setting qualified with the environment name" do - Puppet.settings.expects(:value).with("myvar", :testing).returns("myval") - env = Puppet::Node::Environment.new("testing") - env["myvar"].should == "myval" - end - - it "should be able to return an individual module that exists in its module path" do - env = Puppet::Node::Environment.new("testing") - - mod = mock 'module' - Puppet::Module.expects(:new).with("one", env).returns mod - mod.expects(:exist?).returns true - - env.module("one").should equal(mod) - end - - it "should return nil if asked for a module that does not exist in its path" do - env = Puppet::Node::Environment.new("testing") - - mod = mock 'module' - Puppet::Module.expects(:new).with("one", env).returns mod - mod.expects(:exist?).returns false - - env.module("one").should be_nil - end - - it "should be able to return its modules" do - Puppet::Node::Environment.new("testing").should respond_to(:modules) - end - - describe ".modules" do - it "should return a module named for every directory in each module path" do - env = Puppet::Node::Environment.new("testing") - env.expects(:modulepath).at_least_once.returns %w{/a /b} - Dir.expects(:entries).with("/a").returns %w{foo bar} - Dir.expects(:entries).with("/b").returns %w{bee baz} - - env.modules.collect{|mod| mod.name}.sort.should == %w{foo bar bee baz}.sort - end - - it "should remove duplicates" do - env = Puppet::Node::Environment.new("testing") - env.expects(:modulepath).returns( %w{/a /b} ).at_least_once - Dir.expects(:entries).with("/a").returns %w{foo} - Dir.expects(:entries).with("/b").returns %w{foo} - - env.modules.collect{|mod| mod.name}.sort.should == %w{foo} - end - - it "should ignore invalid modules" do - env = Puppet::Node::Environment.new("testing") - env.stubs(:modulepath).returns %w{/a} - Dir.expects(:entries).with("/a").returns %w{foo bar} - - Puppet::Module.expects(:new).with { |name, env| name == "foo" }.returns mock("foomod", :name => "foo") - Puppet::Module.expects(:new).with { |name, env| name == "bar" }.raises( Puppet::Module::InvalidName, "name is invalid" ) - - env.modules.collect{|mod| mod.name}.sort.should == %w{foo} - end - - it "should create modules with the correct environment" do - env = Puppet::Node::Environment.new("testing") - env.expects(:modulepath).at_least_once.returns %w{/a} - Dir.expects(:entries).with("/a").returns %w{foo} - - env.modules.each {|mod| mod.environment.should == env } - end - - it "should cache the module list" do - env = Puppet::Node::Environment.new("testing") - env.expects(:modulepath).at_least_once.returns %w{/a} - Dir.expects(:entries).once.with("/a").returns %w{foo} - - env.modules - env.modules - end - end - end - - describe Puppet::Node::Environment::Helper do - before do - @helper = Object.new - @helper.extend(Puppet::Node::Environment::Helper) - end - - it "should be able to set and retrieve the environment" do - @helper.environment = :foo - @helper.environment.name.should == :foo - end - - it "should accept an environment directly" do - env = Puppet::Node::Environment.new :foo - @helper.environment = env - @helper.environment.name.should == :foo - end - - it "should accept an environment as a string" do - env = Puppet::Node::Environment.new "foo" - @helper.environment = env - @helper.environment.name.should == :foo - end - end -end diff --git a/spec/unit/node/facts_spec.rb b/spec/unit/node/facts_spec.rb new file mode 100755 index 000000000..43532cc53 --- /dev/null +++ b/spec/unit/node/facts_spec.rb @@ -0,0 +1,102 @@ +#!/usr/bin/env ruby + +require File.dirname(__FILE__) + '/../../spec_helper' + +require 'puppet/node/facts' + +describe Puppet::Node::Facts, "when indirecting" do + before do + @facts = Puppet::Node::Facts.new("me") + end + + it "should be able to convert all fact values to strings" do + @facts.values["one"] = 1 + @facts.stringify + @facts.values["one"].should == "1" + end + + it "should add the node's certificate name as the 'clientcert' fact when adding local facts" do + @facts.add_local_facts + @facts.values["clientcert"].should == Puppet.settings[:certname] + end + + it "should add the Puppet version as a 'clientversion' fact when adding local facts" do + @facts.add_local_facts + @facts.values["clientversion"].should == Puppet.version.to_s + end + + it "should add the current environment as a fact if one is not set when adding local facts" do + @facts.add_local_facts + @facts.values["environment"].should == Puppet[:environment] + end + + it "should not replace any existing environment fact when adding local facts" do + @facts.values["environment"] = "foo" + @facts.add_local_facts + @facts.values["environment"].should == "foo" + end + + it "should be able to downcase fact values" do + Puppet.settings.stubs(:value).returns "eh" + Puppet.settings.expects(:value).with(:downcasefacts).returns true + + @facts.values["one"] = "Two" + + @facts.downcase_if_necessary + @facts.values["one"].should == "two" + end + + it "should only try to downcase strings" do + Puppet.settings.stubs(:value).returns "eh" + Puppet.settings.expects(:value).with(:downcasefacts).returns true + + @facts.values["now"] = Time.now + + @facts.downcase_if_necessary + @facts.values["now"].should be_instance_of(Time) + end + + it "should not downcase facts if not configured to do so" do + Puppet.settings.stubs(:value).returns "eh" + Puppet.settings.expects(:value).with(:downcasefacts).returns false + + @facts.values["one"] = "Two" + @facts.downcase_if_necessary + @facts.values["one"].should == "Two" + end + + describe "when indirecting" do + before do + @indirection = stub 'indirection', :request => mock('request'), :name => :facts + + # We have to clear the cache so that the facts ask for our indirection stub, + # instead of anything that might be cached. + Puppet::Util::Cacher.expire + + @facts = Puppet::Node::Facts.new("me", "one" => "two") + end + + it "should redirect to the specified fact store for retrieval" do + Puppet::Node::Facts.stubs(:indirection).returns(@indirection) + @indirection.expects(:find) + Puppet::Node::Facts.find(:my_facts) + end + + it "should redirect to the specified fact store for storage" do + Puppet::Node::Facts.stubs(:indirection).returns(@indirection) + @indirection.expects(:save) + @facts.save + end + + it "should default to the 'facter' terminus" do + Puppet::Node::Facts.indirection.terminus_class.should == :facter + end + end + + describe "when storing and retrieving" do + it "should add metadata to the facts" do + facts = Puppet::Node::Facts.new("me", "one" => "two", "three" => "four") + facts.values[:_timestamp].should be_instance_of(Time) + end + end +end diff --git a/spec/unit/node/facts_spec_spec.rb b/spec/unit/node/facts_spec_spec.rb deleted file mode 100755 index 43532cc53..000000000 --- a/spec/unit/node/facts_spec_spec.rb +++ /dev/null @@ -1,102 +0,0 @@ -#!/usr/bin/env ruby - -require File.dirname(__FILE__) + '/../../spec_helper' - -require 'puppet/node/facts' - -describe Puppet::Node::Facts, "when indirecting" do - before do - @facts = Puppet::Node::Facts.new("me") - end - - it "should be able to convert all fact values to strings" do - @facts.values["one"] = 1 - @facts.stringify - @facts.values["one"].should == "1" - end - - it "should add the node's certificate name as the 'clientcert' fact when adding local facts" do - @facts.add_local_facts - @facts.values["clientcert"].should == Puppet.settings[:certname] - end - - it "should add the Puppet version as a 'clientversion' fact when adding local facts" do - @facts.add_local_facts - @facts.values["clientversion"].should == Puppet.version.to_s - end - - it "should add the current environment as a fact if one is not set when adding local facts" do - @facts.add_local_facts - @facts.values["environment"].should == Puppet[:environment] - end - - it "should not replace any existing environment fact when adding local facts" do - @facts.values["environment"] = "foo" - @facts.add_local_facts - @facts.values["environment"].should == "foo" - end - - it "should be able to downcase fact values" do - Puppet.settings.stubs(:value).returns "eh" - Puppet.settings.expects(:value).with(:downcasefacts).returns true - - @facts.values["one"] = "Two" - - @facts.downcase_if_necessary - @facts.values["one"].should == "two" - end - - it "should only try to downcase strings" do - Puppet.settings.stubs(:value).returns "eh" - Puppet.settings.expects(:value).with(:downcasefacts).returns true - - @facts.values["now"] = Time.now - - @facts.downcase_if_necessary - @facts.values["now"].should be_instance_of(Time) - end - - it "should not downcase facts if not configured to do so" do - Puppet.settings.stubs(:value).returns "eh" - Puppet.settings.expects(:value).with(:downcasefacts).returns false - - @facts.values["one"] = "Two" - @facts.downcase_if_necessary - @facts.values["one"].should == "Two" - end - - describe "when indirecting" do - before do - @indirection = stub 'indirection', :request => mock('request'), :name => :facts - - # We have to clear the cache so that the facts ask for our indirection stub, - # instead of anything that might be cached. - Puppet::Util::Cacher.expire - - @facts = Puppet::Node::Facts.new("me", "one" => "two") - end - - it "should redirect to the specified fact store for retrieval" do - Puppet::Node::Facts.stubs(:indirection).returns(@indirection) - @indirection.expects(:find) - Puppet::Node::Facts.find(:my_facts) - end - - it "should redirect to the specified fact store for storage" do - Puppet::Node::Facts.stubs(:indirection).returns(@indirection) - @indirection.expects(:save) - @facts.save - end - - it "should default to the 'facter' terminus" do - Puppet::Node::Facts.indirection.terminus_class.should == :facter - end - end - - describe "when storing and retrieving" do - it "should add metadata to the facts" do - facts = Puppet::Node::Facts.new("me", "one" => "two", "three" => "four") - facts.values[:_timestamp].should be_instance_of(Time) - end - end -end -- cgit