diff options
| -rwxr-xr-x | bin/puppet | 5 | ||||
| -rwxr-xr-x | bin/puppetca | 5 | ||||
| -rwxr-xr-x | bin/puppetd | 5 | ||||
| -rwxr-xr-x | bin/puppetmasterd | 5 | ||||
| -rw-r--r-- | lib/puppet.rb | 43 | ||||
| -rw-r--r-- | lib/puppet/util/settings.rb | 58 | ||||
| -rwxr-xr-x | spec/unit/util/settings.rb | 1286 |
7 files changed, 771 insertions, 636 deletions
diff --git a/bin/puppet b/bin/puppet index bb7308997..23b175087 100755 --- a/bin/puppet +++ b/bin/puppet @@ -141,8 +141,9 @@ if Puppet[:config] and File.exists? Puppet[:config] Puppet.settings.parse(Puppet[:config]) end -Puppet.genconfig -Puppet.genmanifest +if Puppet.settings.print_configs? + exit(Puppet.settings.print_configs ? 0 : 1) +end # If noop is set, then also enable diffs if Puppet[:noop] diff --git a/bin/puppetca b/bin/puppetca index 759b602ac..9d88a564e 100755 --- a/bin/puppetca +++ b/bin/puppetca @@ -171,8 +171,9 @@ end # Now parse the config Puppet.parse_config -Puppet.genconfig -Puppet.genmanifest +if Puppet.settings.print_configs? + exit(Puppet.settings.print_configs ? 0 : 1) +end begin ca = Puppet::SSLCertificates::CA.new() diff --git a/bin/puppetd b/bin/puppetd index 2a71c3a8d..0813745cc 100755 --- a/bin/puppetd +++ b/bin/puppetd @@ -299,8 +299,9 @@ unless options[:setdest] Puppet::Util::Log.newdestination(:syslog) end -Puppet.genconfig -Puppet.genmanifest +if Puppet.settings.print_configs? + exit(Puppet.settings.print_configs ? 0 : 1) +end # If noop is set, then also enable diffs if Puppet[:noop] diff --git a/bin/puppetmasterd b/bin/puppetmasterd index b4733e604..03bd78455 100755 --- a/bin/puppetmasterd +++ b/bin/puppetmasterd @@ -182,8 +182,9 @@ unless options[:setdest] Puppet::Util::Log.newdestination(:syslog) end -Puppet.genconfig -Puppet.genmanifest +if Puppet.settings.print_configs? + exit(Puppet.settings.print_configs ? 0 : 1) +end # A temporary solution, to at least make the master work for now. Puppet::Node::Facts.terminus_class = :yaml diff --git a/lib/puppet.rb b/lib/puppet.rb index 66a52f9e3..83e5da68f 100644 --- a/lib/puppet.rb +++ b/lib/puppet.rb @@ -117,49 +117,6 @@ module Puppet # Load all of the configuration parameters. require 'puppet/defaults' - # Prints the contents of a config file with the available config elements, or it - # prints a single value of a config element. - def self.genconfig - if Puppet[:configprint] != "" - val = Puppet[:configprint] - if val == "all" - hash = {} - Puppet.settings.each do |name, obj| - val = obj.value - case val - when true, false, "": val = val.inspect - end - hash[name] = val - end - hash.sort { |a,b| a[0].to_s <=> b[0].to_s }.each do |name, val| - puts "%s = %s" % [name, val] - end - elsif val =~ /,/ - val.split(/\s*,\s*/).sort.each do |v| - if Puppet.settings.include?(v) - puts "%s = %s" % [v, Puppet[v]] - else - puts "invalid parameter: %s" % v - exit(1) - end - end - else - val.split(/\s*,\s*/).sort.each do |v| - if Puppet.settings.include?(v) - puts Puppet[val] - else - puts "invalid parameter: %s" % v - exit(1) - end - end - end - exit(0) - end - if Puppet[:genconfig] - puts Puppet.settings.to_config - exit(0) - end - end def self.genmanifest if Puppet[:genmanifest] diff --git a/lib/puppet/util/settings.rb b/lib/puppet/util/settings.rb index 0e6f91e48..d8197f743 100644 --- a/lib/puppet/util/settings.rb +++ b/lib/puppet/util/settings.rb @@ -217,6 +217,64 @@ class Puppet::Util::Settings @used = [] end + # NOTE: ACS ahh the util classes. . .sigh + # as part of a fix for 1183, I pulled the logic for the following 5 methods out of the executables and puppet.rb + # They probably deserve their own class, but I don't want to do that until I can refactor environments + # its a little better than where they were + + # Prints the contents of a config file with the available config elements, or it + # prints a single value of a config element. + def print_config_options + env = value(:environment) + val = value(:configprint) + if val == "all" + hash = {} + each do |name, obj| + val = value(name,env) + val = val.inspect if val == "" + hash[name] = val + end + hash.sort { |a,b| a[0].to_s <=> b[0].to_s }.each do |name, val| + puts "%s = %s" % [name, val] + end + else + val.split(/\s*,\s*/).sort.each do |v| + if include?(v) + #if there is only one value, just print it for back compatibility + if v == val + puts value(val,env) + break + end + puts "%s = %s" % [v, value(v,env)] + else + puts "invalid parameter: %s" % v + return false + end + end + end + true + end + + def generate_config + puts to_config + true + end + + def generate_manifest + puts to_manifest + true + end + + def print_configs + return print_config_options if value(:configprint) != "" + return generate_config if value(:genconfig) + return generate_manifest if value(:genmanifest) + end + + def print_configs? + return (value(:configprint) != "" || value(:genconfig) || value(:genmanifest)) && true + end + # Return a given object's file metadata. def metadata(param) if obj = @config[symbolize(param)] and obj.is_a?(CFile) diff --git a/spec/unit/util/settings.rb b/spec/unit/util/settings.rb index a6b358462..de6d6457c 100755 --- a/spec/unit/util/settings.rb +++ b/spec/unit/util/settings.rb @@ -2,705 +2,821 @@ require File.dirname(__FILE__) + '/../../spec_helper' -describe Puppet::Util::Settings, " when specifying defaults" do - before do - @settings = Puppet::Util::Settings.new - end +describe Puppet::Util::Settings do + describe "when specifying defaults" do + before do + @settings = Puppet::Util::Settings.new + end - it "should start with no defined parameters" do - @settings.params.length.should == 0 - end + it "should start with no defined parameters" do + @settings.params.length.should == 0 + end - it "should allow specification of default values associated with a section as an array" do - @settings.setdefaults(:section, :myvalue => ["defaultval", "my description"]) - end + it "should allow specification of default values associated with a section as an array" do + @settings.setdefaults(:section, :myvalue => ["defaultval", "my description"]) + end - it "should not allow duplicate parameter specifications" do - @settings.setdefaults(:section, :myvalue => ["a", "b"]) - lambda { @settings.setdefaults(:section, :myvalue => ["c", "d"]) }.should raise_error(ArgumentError) - end + it "should not allow duplicate parameter specifications" do + @settings.setdefaults(:section, :myvalue => ["a", "b"]) + lambda { @settings.setdefaults(:section, :myvalue => ["c", "d"]) }.should raise_error(ArgumentError) + end - it "should allow specification of default values associated with a section as a hash" do - @settings.setdefaults(:section, :myvalue => {:default => "defaultval", :desc => "my description"}) - end + it "should allow specification of default values associated with a section as a hash" do + @settings.setdefaults(:section, :myvalue => {:default => "defaultval", :desc => "my description"}) + end - it "should consider defined parameters to be valid" do - @settings.setdefaults(:section, :myvalue => ["defaultval", "my description"]) - @settings.valid?(:myvalue).should be_true - end + it "should consider defined parameters to be valid" do + @settings.setdefaults(:section, :myvalue => ["defaultval", "my description"]) + @settings.valid?(:myvalue).should be_true + end - it "should require a description when defaults are specified with an array" do - lambda { @settings.setdefaults(:section, :myvalue => ["a value"]) }.should raise_error(ArgumentError) - end + it "should require a description when defaults are specified with an array" do + lambda { @settings.setdefaults(:section, :myvalue => ["a value"]) }.should raise_error(ArgumentError) + end - it "should require a description when defaults are specified with a hash" do - lambda { @settings.setdefaults(:section, :myvalue => {:default => "a value"}) }.should raise_error(ArgumentError) - end + it "should require a description when defaults are specified with a hash" do + lambda { @settings.setdefaults(:section, :myvalue => {:default => "a value"}) }.should raise_error(ArgumentError) + end - it "should support specifying owner, group, and mode when specifying files" do - @settings.setdefaults(:section, :myvalue => {:default => "/some/file", :owner => "blah", :mode => "boo", :group => "yay", :desc => "whatever"}) - end + it "should support specifying owner, group, and mode when specifying files" do + @settings.setdefaults(:section, :myvalue => {:default => "/some/file", :owner => "blah", :mode => "boo", :group => "yay", :desc => "whatever"}) + end - it "should support specifying a short name" do - @settings.setdefaults(:section, :myvalue => {:default => "w", :desc => "b", :short => "m"}) - end + it "should support specifying a short name" do + @settings.setdefaults(:section, :myvalue => {:default => "w", :desc => "b", :short => "m"}) + end - it "should fail when short names conflict" do - @settings.setdefaults(:section, :myvalue => {:default => "w", :desc => "b", :short => "m"}) - lambda { @settings.setdefaults(:section, :myvalue => {:default => "w", :desc => "b", :short => "m"}) }.should raise_error(ArgumentError) + it "should fail when short names conflict" do + @settings.setdefaults(:section, :myvalue => {:default => "w", :desc => "b", :short => "m"}) + lambda { @settings.setdefaults(:section, :myvalue => {:default => "w", :desc => "b", :short => "m"}) }.should raise_error(ArgumentError) + end end -end -describe Puppet::Util::Settings, " when setting values" do - before do - @settings = Puppet::Util::Settings.new - @settings.setdefaults :main, :myval => ["val", "desc"] - @settings.setdefaults :main, :bool => [true, "desc"] - end + describe "when setting values" do + before do + @settings = Puppet::Util::Settings.new + @settings.setdefaults :main, :myval => ["val", "desc"] + @settings.setdefaults :main, :bool => [true, "desc"] + end - it "should provide a method for setting values from other objects" do - @settings[:myval] = "something else" - @settings[:myval].should == "something else" - end + it "should provide a method for setting values from other objects" do + @settings[:myval] = "something else" + @settings[:myval].should == "something else" + end - it "should support a getopt-specific mechanism for setting values" do - @settings.handlearg("--myval", "newval") - @settings[:myval].should == "newval" - end + it "should support a getopt-specific mechanism for setting values" do + @settings.handlearg("--myval", "newval") + @settings[:myval].should == "newval" + end - it "should support a getopt-specific mechanism for turning booleans off" do - @settings.handlearg("--no-bool") - @settings[:bool].should == false - end + it "should support a getopt-specific mechanism for turning booleans off" do + @settings.handlearg("--no-bool") + @settings[:bool].should == false + end - it "should support a getopt-specific mechanism for turning booleans on" do - # Turn it off first - @settings[:bool] = false - @settings.handlearg("--bool") - @settings[:bool].should == true - end + it "should support a getopt-specific mechanism for turning booleans on" do + # Turn it off first + @settings[:bool] = false + @settings.handlearg("--bool") + @settings[:bool].should == true + end - it "should clear the cache when setting getopt-specific values" do - @settings.setdefaults :mysection, :one => ["whah", "yay"], :two => ["$one yay", "bah"] - @settings[:two].should == "whah yay" - @settings.handlearg("--one", "else") - @settings[:two].should == "else yay" - end + it "should clear the cache when setting getopt-specific values" do + @settings.setdefaults :mysection, :one => ["whah", "yay"], :two => ["$one yay", "bah"] + @settings[:two].should == "whah yay" + @settings.handlearg("--one", "else") + @settings[:two].should == "else yay" + end - it "should not clear other values when setting getopt-specific values" do - @settings[:myval] = "yay" - @settings.handlearg("--no-bool") - @settings[:myval].should == "yay" - end + it "should not clear other values when setting getopt-specific values" do + @settings[:myval] = "yay" + @settings.handlearg("--no-bool") + @settings[:myval].should == "yay" + end - it "should call passed blocks when values are set" do - values = [] - @settings.setdefaults(:section, :hooker => {:default => "yay", :desc => "boo", :hook => lambda { |v| values << v }}) - values.should == [] + it "should call passed blocks when values are set" do + values = [] + @settings.setdefaults(:section, :hooker => {:default => "yay", :desc => "boo", :hook => lambda { |v| values << v }}) + values.should == [] - @settings[:hooker] = "something" - values.should == %w{something} - end + @settings[:hooker] = "something" + values.should == %w{something} + end - it "should provide an option to call passed blocks during definition" do - values = [] - @settings.setdefaults(:section, :hooker => {:default => "yay", :desc => "boo", :call_on_define => true, :hook => lambda { |v| values << v }}) - values.should == %w{yay} - end + it "should provide an option to call passed blocks during definition" do + values = [] + @settings.setdefaults(:section, :hooker => {:default => "yay", :desc => "boo", :call_on_define => true, :hook => lambda { |v| values << v }}) + values.should == %w{yay} + end - it "should pass the fully interpolated value to the hook when called on definition" do - values = [] - @settings.setdefaults(:section, :one => ["test", "a"]) - @settings.setdefaults(:section, :hooker => {:default => "$one/yay", :desc => "boo", :call_on_define => true, :hook => lambda { |v| values << v }}) - values.should == %w{test/yay} - end + it "should pass the fully interpolated value to the hook when called on definition" do + values = [] + @settings.setdefaults(:section, :one => ["test", "a"]) + @settings.setdefaults(:section, :hooker => {:default => "$one/yay", :desc => "boo", :call_on_define => true, :hook => lambda { |v| values << v }}) + values.should == %w{test/yay} + end - it "should munge values using the element-specific methods" do - @settings[:bool] = "false" - @settings[:bool].should == false - end + it "should munge values using the element-specific methods" do + @settings[:bool] = "false" + @settings[:bool].should == false + end - it "should prefer cli values to values set in Ruby code" do - @settings.handlearg("--myval", "cliarg") - @settings[:myval] = "memarg" - @settings[:myval].should == "cliarg" + it "should prefer cli values to values set in Ruby code" do + @settings.handlearg("--myval", "cliarg") + @settings[:myval] = "memarg" + @settings[:myval].should == "cliarg" + end end -end -describe Puppet::Util::Settings, " when returning values" do - before do - @settings = Puppet::Util::Settings.new - @settings.setdefaults :section, :one => ["ONE", "a"], :two => ["$one TWO", "b"], :three => ["$one $two THREE", "c"], :four => ["$two $three FOUR", "d"] - end + describe "when returning values" do + before do + @settings = Puppet::Util::Settings.new + @settings.setdefaults :section, :one => ["ONE", "a"], :two => ["$one TWO", "b"], :three => ["$one $two THREE", "c"], :four => ["$two $three FOUR", "d"] + end - it "should provide a mechanism for returning set values" do - @settings[:one] = "other" - @settings[:one].should == "other" - end + it "should provide a mechanism for returning set values" do + @settings[:one] = "other" + @settings[:one].should == "other" + end - it "should interpolate default values for other parameters into returned parameter values" do - @settings[:one].should == "ONE" - @settings[:two].should == "ONE TWO" - @settings[:three].should == "ONE ONE TWO THREE" - end + it "should interpolate default values for other parameters into returned parameter values" do + @settings[:one].should == "ONE" + @settings[:two].should == "ONE TWO" + @settings[:three].should == "ONE ONE TWO THREE" + end - it "should interpolate default values that themselves need to be interpolated" do - @settings[:four].should == "ONE TWO ONE ONE TWO THREE FOUR" - end + it "should interpolate default values that themselves need to be interpolated" do + @settings[:four].should == "ONE TWO ONE ONE TWO THREE FOUR" + end - it "should interpolate set values for other parameters into returned parameter values" do - @settings[:one] = "on3" - @settings[:two] = "$one tw0" - @settings[:three] = "$one $two thr33" - @settings[:four] = "$one $two $three f0ur" - @settings[:one].should == "on3" - @settings[:two].should == "on3 tw0" - @settings[:three].should == "on3 on3 tw0 thr33" - @settings[:four].should == "on3 on3 tw0 on3 on3 tw0 thr33 f0ur" - end + it "should interpolate set values for other parameters into returned parameter values" do + @settings[:one] = "on3" + @settings[:two] = "$one tw0" + @settings[:three] = "$one $two thr33" + @settings[:four] = "$one $two $three f0ur" + @settings[:one].should == "on3" + @settings[:two].should == "on3 tw0" + @settings[:three].should == "on3 on3 tw0 thr33" + @settings[:four].should == "on3 on3 tw0 on3 on3 tw0 thr33 f0ur" + end - it "should not cache interpolated values such that stale information is returned" do - @settings[:two].should == "ONE TWO" - @settings[:one] = "one" - @settings[:two].should == "one TWO" - end + it "should not cache interpolated values such that stale information is returned" do + @settings[:two].should == "ONE TWO" + @settings[:one] = "one" + @settings[:two].should == "one TWO" + end - it "should not cache values such that information from one environment is returned for another environment" do - text = "[env1]\none = oneval\n[env2]\none = twoval\n" - file = mock 'file' - file.stubs(:changed?).returns(true) - file.stubs(:file).returns("/whatever") - @settings.stubs(:read_file).with(file).returns(text) - @settings.parse(file) + it "should not cache values such that information from one environment is returned for another environment" do + text = "[env1]\none = oneval\n[env2]\none = twoval\n" + file = mock 'file' + file.stubs(:changed?).returns(true) + file.stubs(:file).returns("/whatever") + @settings.stubs(:read_file).with(file).returns(text) + @settings.parse(file) - @settings.value(:one, "env1").should == "oneval" - @settings.value(:one, "env2").should == "twoval" - end + @settings.value(:one, "env1").should == "oneval" + @settings.value(:one, "env2").should == "twoval" + end - it "should have a name determined by the 'name' parameter" do - @settings.setdefaults(:whatever, :name => ["something", "yayness"]) - @settings.name.should == :something - @settings[:name] = :other - @settings.name.should == :other + it "should have a name determined by the 'name' parameter" do + @settings.setdefaults(:whatever, :name => ["something", "yayness"]) + @settings.name.should == :something + @settings[:name] = :other + @settings.name.should == :other + end end -end -describe Puppet::Util::Settings, " when choosing which value to return" do - before do - @settings = Puppet::Util::Settings.new - @settings.setdefaults :section, - :one => ["ONE", "a"], - :name => ["myname", "w"] - end + describe "when choosing which value to return" do + before do + @settings = Puppet::Util::Settings.new + @settings.setdefaults :section, + :one => ["ONE", "a"], + :name => ["myname", "w"] + end - it "should return default values if no values have been set" do - @settings[:one].should == "ONE" - end + it "should return default values if no values have been set" do + @settings[:one].should == "ONE" + end - it "should return values set on the cli before values set in the configuration file" do - text = "[main]\none = fileval\n" - file = mock 'file' - file.stubs(:changed?).returns(true) - file.stubs(:file).returns("/whatever") - @settings.stubs(:parse_file).returns(text) - @settings.handlearg("--one", "clival") - @settings.parse(file) + it "should return values set on the cli before values set in the configuration file" do + text = "[main]\none = fileval\n" + file = mock 'file' + file.stubs(:changed?).returns(true) + file.stubs(:file).returns("/whatever") + @settings.stubs(:parse_file).returns(text) + @settings.handlearg("--one", "clival") + @settings.parse(file) - @settings[:one].should == "clival" - end + @settings[:one].should == "clival" + end - it "should return values set on the cli before values set in Ruby" do - @settings[:one] = "rubyval" - @settings.handlearg("--one", "clival") - @settings[:one].should == "clival" - end + it "should return values set on the cli before values set in Ruby" do + @settings[:one] = "rubyval" + @settings.handlearg("--one", "clival") + @settings[:one].should == "clival" + end - it "should return values set in the executable-specific section before values set in the main section" do - text = "[main]\none = mainval\n[myname]\none = nameval\n" - file = mock 'file' - file.stubs(:changed?).returns(true) - file.stubs(:file).returns("/whatever") - @settings.stubs(:read_file).with(file).returns(text) - @settings.parse(file) + it "should return values set in the executable-specific section before values set in the main section" do + text = "[main]\none = mainval\n[myname]\none = nameval\n" + file = mock 'file' + file.stubs(:changed?).returns(true) + file.stubs(:file).returns("/whatever") + @settings.stubs(:read_file).with(file).returns(text) + @settings.parse(file) - @settings[:one].should == "nameval" - end + @settings[:one].should == "nameval" + end - it "should not return values outside of its search path" do - text = "[other]\none = oval\n" - file = "/some/file" - file = mock 'file' - file.stubs(:changed?).returns(true) - file.stubs(:file).returns("/whatever") - @settings.stubs(:read_file).with(file).returns(text) - @settings.parse(file) - @settings[:one].should == "ONE" - end + it "should not return values outside of its search path" do + text = "[other]\none = oval\n" + file = "/some/file" + file = mock 'file' + file.stubs(:changed?).returns(true) + file.stubs(:file).returns("/whatever") + @settings.stubs(:read_file).with(file).returns(text) + @settings.parse(file) + @settings[:one].should == "ONE" + end - it "should return values in a specified environment" do - text = "[env]\none = envval\n" - file = "/some/file" - file = mock 'file' - file.stubs(:changed?).returns(true) - file.stubs(:file).returns("/whatever") - @settings.stubs(:read_file).with(file).returns(text) - @settings.parse(file) - @settings.value(:one, "env").should == "envval" - end + it "should return values in a specified environment" do + text = "[env]\none = envval\n" + file = "/some/file" + file = mock 'file' + file.stubs(:changed?).returns(true) + file.stubs(:file).returns("/whatever") + @settings.stubs(:read_file).with(file).returns(text) + @settings.parse(file) + @settings.value(:one, "env").should == "envval" + end - it "should return values in a specified environment before values in the main or name sections" do - text = "[env]\none = envval\n[main]\none = mainval\n[myname]\none = nameval\n" - file = "/some/file" - file = mock 'file' - file.stubs(:changed?).returns(true) - file.stubs(:file).returns("/whatever") - @settings.stubs(:read_file).with(file).returns(text) - @settings.parse(file) - @settings.value(:one, "env").should == "envval" + it "should return values in a specified environment before values in the main or name sections" do + text = "[env]\none = envval\n[main]\none = mainval\n[myname]\none = nameval\n" + file = "/some/file" + file = mock 'file' + file.stubs(:changed?).returns(true) + file.stubs(:file).returns("/whatever") + @settings.stubs(:read_file).with(file).returns(text) + @settings.parse(file) + @settings.value(:one, "env").should == "envval" + end end -end -describe Puppet::Util::Settings, " when parsing its configuration" do - before do - @settings = Puppet::Util::Settings.new - @settings.setdefaults :section, :one => ["ONE", "a"], :two => ["$one TWO", "b"], :three => ["$one $two THREE", "c"] - end + describe "when parsing its configuration" do + before do + @settings = Puppet::Util::Settings.new + @settings.setdefaults :section, :one => ["ONE", "a"], :two => ["$one TWO", "b"], :three => ["$one $two THREE", "c"] + end - it "should return values set in the configuration file" do - text = "[main] - one = fileval - " - file = "/some/file" - @settings.expects(:read_file).with(file).returns(text) - @settings.parse(file) - @settings[:one].should == "fileval" - end + it "should return values set in the configuration file" do + text = "[main] + one = fileval + " + file = "/some/file" + @settings.expects(:read_file).with(file).returns(text) + @settings.parse(file) + @settings[:one].should == "fileval" + end - #484 - this should probably be in the regression area - it "should not throw an exception on unknown parameters" do - text = "[main]\nnosuchparam = mval\n" - file = "/some/file" - @settings.expects(:read_file).with(file).returns(text) - lambda { @settings.parse(file) }.should_not raise_error - end + #484 - this should probably be in the regression area + it "should not throw an exception on unknown parameters" do + text = "[main]\nnosuchparam = mval\n" + file = "/some/file" + @settings.expects(:read_file).with(file).returns(text) + lambda { @settings.parse(file) }.should_not raise_error + end - it "should support an old parse method when per-executable configuration files still exist" do - # I'm not going to bother testing this method. - @settings.should respond_to(:old_parse) - end + it "should support an old parse method when per-executable configuration files still exist" do + # I'm not going to bother testing this method. + @settings.should respond_to(:old_parse) + end - it "should convert booleans in the configuration file into Ruby booleans" do - text = "[main] - one = true - two = false - " - file = "/some/file" - @settings.expects(:read_file).with(file).returns(text) - @settings.parse(file) - @settings[:one].should == true - @settings[:two].should == false - end + it "should convert booleans in the configuration file into Ruby booleans" do + text = "[main] + one = true + two = false + " + file = "/some/file" + @settings.expects(:read_file).with(file).returns(text) + @settings.parse(file) + @settings[:one].should == true + @settings[:two].should == false + end - it "should convert integers in the configuration file into Ruby Integers" do - text = "[main] - one = 65 - " - file = "/some/file" - @settings.expects(:read_file).with(file).returns(text) - @settings.parse(file) - @settings[:one].should == 65 - end + it "should convert integers in the configuration file into Ruby Integers" do + text = "[main] + one = 65 + " + file = "/some/file" + @settings.expects(:read_file).with(file).returns(text) + @settings.parse(file) + @settings[:one].should == 65 + end - it "should support specifying all metadata (owner, group, mode) in the configuration file" do - @settings.setdefaults :section, :myfile => ["/myfile", "a"] - - text = "[main] - myfile = /other/file {owner = luke, group = luke, mode = 644} - " - file = "/some/file" - @settings.expects(:read_file).with(file).returns(text) - @settings.parse(file) - @settings[:myfile].should == "/other/file" - @settings.metadata(:myfile).should == {:owner => "luke", :group => "luke", :mode => "644"} - end + it "should support specifying all metadata (owner, group, mode) in the configuration file" do + @settings.setdefaults :section, :myfile => ["/myfile", "a"] + + text = "[main] + myfile = /other/file {owner = luke, group = luke, mode = 644} + " + file = "/some/file" + @settings.expects(:read_file).with(file).returns(text) + @settings.parse(file) + @settings[:myfile].should == "/other/file" + @settings.metadata(:myfile).should == {:owner => "luke", :group => "luke", :mode => "644"} + end - it "should support specifying a single piece of metadata (owner, group, or mode) in the configuration file" do - @settings.setdefaults :section, :myfile => ["/myfile", "a"] - - text = "[main] - myfile = /other/file {owner = luke} - " - file = "/some/file" - @settings.expects(:read_file).with(file).returns(text) - @settings.parse(file) - @settings[:myfile].should == "/other/file" - @settings.metadata(:myfile).should == {:owner => "luke"} - end + it "should support specifying a single piece of metadata (owner, group, or mode) in the configuration file" do + @settings.setdefaults :section, :myfile => ["/myfile", "a"] + + text = "[main] + myfile = /other/file {owner = luke} + " + file = "/some/file" + @settings.expects(:read_file).with(file).returns(text) + @settings.parse(file) + @settings[:myfile].should == "/other/file" + @settings.metadata(:myfile).should == {:owner => "luke"} + end - it "should call hooks associated with values set in the configuration file" do - values = [] - @settings.setdefaults :section, :mysetting => {:default => "defval", :desc => "a", :hook => proc { |v| values << v }} - - text = "[main] - mysetting = setval - " - file = "/some/file" - @settings.expects(:read_file).with(file).returns(text) - @settings.parse(file) - values.should == ["setval"] - end + it "should call hooks associated with values set in the configuration file" do + values = [] + @settings.setdefaults :section, :mysetting => {:default => "defval", :desc => "a", :hook => proc { |v| values << v }} + + text = "[main] + mysetting = setval + " + file = "/some/file" + @settings.expects(:read_file).with(file).returns(text) + @settings.parse(file) + values.should == ["setval"] + end - it "should not call the same hook for values set multiple times in the configuration file" do - values = [] - @settings.setdefaults :section, :mysetting => {:default => "defval", :desc => "a", :hook => proc { |v| values << v }} - - text = "[main] - mysetting = setval - [puppet] - mysetting = other - " - file = "/some/file" - @settings.expects(:read_file).with(file).returns(text) - @settings.parse(file) - values.should == ["setval"] - end + it "should not call the same hook for values set multiple times in the configuration file" do + values = [] + @settings.setdefaults :section, :mysetting => {:default => "defval", :desc => "a", :hook => proc { |v| values << v }} + + text = "[main] + mysetting = setval + [puppet] + mysetting = other + " + file = "/some/file" + @settings.expects(:read_file).with(file).returns(text) + @settings.parse(file) + values.should == ["setval"] + end - it "should pass the environment-specific value to the hook when one is available" do - values = [] - @settings.setdefaults :section, :mysetting => {:default => "defval", :desc => "a", :hook => proc { |v| values << v }} - @settings.setdefaults :section, :environment => ["yay", "a"] - @settings.setdefaults :section, :environments => ["yay,foo", "a"] - - text = "[main] - mysetting = setval - [yay] - mysetting = other - " - file = "/some/file" - @settings.expects(:read_file).with(file).returns(text) - @settings.parse(file) - values.should == ["other"] - end + it "should pass the environment-specific value to the hook when one is available" do + values = [] + @settings.setdefaults :section, :mysetting => {:default => "defval", :desc => "a", :hook => proc { |v| values << v }} + @settings.setdefaults :section, :environment => ["yay", "a"] + @settings.setdefaults :section, :environments => ["yay,foo", "a"] + + text = "[main] + mysetting = setval + [yay] + mysetting = other + " + file = "/some/file" + @settings.expects(:read_file).with(file).returns(text) + @settings.parse(file) + values.should == ["other"] + end - it "should pass the interpolated value to the hook when one is available" do - values = [] - @settings.setdefaults :section, :base => {:default => "yay", :desc => "a", :hook => proc { |v| values << v }} - @settings.setdefaults :section, :mysetting => {:default => "defval", :desc => "a", :hook => proc { |v| values << v }} - - text = "[main] - mysetting = $base/setval - " - file = "/some/file" - @settings.expects(:read_file).with(file).returns(text) - @settings.parse(file) - values.should == ["yay/setval"] - end + it "should pass the interpolated value to the hook when one is available" do + values = [] + @settings.setdefaults :section, :base => {:default => "yay", :desc => "a", :hook => proc { |v| values << v }} + @settings.setdefaults :section, :mysetting => {:default => "defval", :desc => "a", :hook => proc { |v| values << v }} + + text = "[main] + mysetting = $base/setval + " + file = "/some/file" + @settings.expects(:read_file).with(file).returns(text) + @settings.parse(file) + values.should == ["yay/setval"] + end - it "should allow empty values" do - @settings.setdefaults :section, :myarg => ["myfile", "a"] + it "should allow empty values" do + @settings.setdefaults :section, :myarg => ["myfile", "a"] - text = "[main] - myarg = - " - @settings.stubs(:read_file).returns(text) - @settings.parse("/some/file") - @settings[:myarg].should == "" + text = "[main] + myarg = + " + @settings.stubs(:read_file).returns(text) + @settings.parse("/some/file") + @settings[:myarg].should == "" + end end -end -describe Puppet::Util::Settings, " when reparsing its configuration" do - before do - @settings = Puppet::Util::Settings.new - @settings.setdefaults :section, :one => ["ONE", "a"], :two => ["$one TWO", "b"], :three => ["$one $two THREE", "c"] - end + describe "when reparsing its configuration" do + before do + @settings = Puppet::Util::Settings.new + @settings.setdefaults :section, :one => ["ONE", "a"], :two => ["$one TWO", "b"], :three => ["$one $two THREE", "c"] + end - it "should replace in-memory values with on-file values" do - # Init the value - text = "[main]\none = disk-init\n" - file = mock 'file' - file.stubs(:changed?).returns(true) - file.stubs(:file).returns("/test/file") - @settings[:one] = "init" - @settings.file = file - - # Now replace the value - text = "[main]\none = disk-replace\n" - - # This is kinda ridiculous - the reason it parses twice is that - # it goes to parse again when we ask for the value, because the - # mock always says it should get reparsed. - @settings.expects(:read_file).with(file).returns(text).times(2) - @settings.reparse - @settings[:one].should == "disk-replace" - end + it "should replace in-memory values with on-file values" do + # Init the value + text = "[main]\none = disk-init\n" + file = mock 'file' + file.stubs(:changed?).returns(true) + file.stubs(:file).returns("/test/file") + @settings[:one] = "init" + @settings.file = file + + # Now replace the value + text = "[main]\none = disk-replace\n" + + # This is kinda ridiculous - the reason it parses twice is that + # it goes to parse again when we ask for the value, because the + # mock always says it should get reparsed. + @settings.expects(:read_file).with(file).returns(text).times(2) + @settings.reparse + @settings[:one].should == "disk-replace" + end - it "should retain parameters set by cli when configuration files are reparsed" do - @settings.handlearg("--one", "clival") + it "should retain parameters set by cli when configuration files are reparsed" do + @settings.handlearg("--one", "clival") - text = "[main]\none = on-disk\n" - file = mock 'file' - file.stubs(:file).returns("/test/file") - @settings.stubs(:read_file).with(file).returns(text) - @settings.parse(file) + text = "[main]\none = on-disk\n" + file = mock 'file' + file.stubs(:file).returns("/test/file") + @settings.stubs(:read_file).with(file).returns(text) + @settings.parse(file) - @settings[:one].should == "clival" - end + @settings[:one].should == "clival" + end - it "should remove in-memory values that are no longer set in the file" do - # Init the value - text = "[main]\none = disk-init\n" - file = mock 'file' - file.stubs(:changed?).returns(true) - file.stubs(:file).returns("/test/file") - @settings.expects(:read_file).with(file).returns(text) - @settings.parse(file) - @settings[:one].should == "disk-init" - - # Now replace the value - text = "[main]\ntwo = disk-replace\n" - @settings.expects(:read_file).with(file).returns(text) - @settings.parse(file) - #@settings.reparse - - # The originally-overridden value should be replaced with the default - @settings[:one].should == "ONE" - - # and we should now have the new value in memory - @settings[:two].should == "disk-replace" + it "should remove in-memory values that are no longer set in the file" do + # Init the value + text = "[main]\none = disk-init\n" + file = mock 'file' + file.stubs(:changed?).returns(true) + file.stubs(:file).returns("/test/file") + @settings.expects(:read_file).with(file).returns(text) + @settings.parse(file) + @settings[:one].should == "disk-init" + + # Now replace the value + text = "[main]\ntwo = disk-replace\n" + @settings.expects(:read_file).with(file).returns(text) + @settings.parse(file) + #@settings.reparse + + # The originally-overridden value should be replaced with the default + @settings[:one].should == "ONE" + + # and we should now have the new value in memory + @settings[:two].should == "disk-replace" + end end -end -describe Puppet::Util::Settings, " when being used to manage the host machine" do - before do - @settings = Puppet::Util::Settings.new - @settings.setdefaults :main, :maindir => ["/maindir", "a"], :seconddir => ["/seconddir", "a"] - @settings.setdefaults :other, :otherdir => {:default => "/otherdir", :desc => "a", :owner => "luke", :group => "johnny", :mode => 0755} - @settings.setdefaults :third, :thirddir => ["/thirddir", "b"] - @settings.setdefaults :files, :myfile => {:default => "/myfile", :desc => "a", :mode => 0755} - end + describe "when being used to manage the host machine" do + before do + @settings = Puppet::Util::Settings.new + @settings.setdefaults :main, :maindir => ["/maindir", "a"], :seconddir => ["/seconddir", "a"] + @settings.setdefaults :other, :otherdir => {:default => "/otherdir", :desc => "a", :owner => "luke", :group => "johnny", :mode => 0755} + @settings.setdefaults :third, :thirddir => ["/thirddir", "b"] + @settings.setdefaults :files, :myfile => {:default => "/myfile", :desc => "a", :mode => 0755} + end - def stub_transaction - @bucket = mock 'bucket' - @config = mock 'config', :clear => nil - @trans = mock 'transaction' + def stub_transaction + @bucket = mock 'bucket' + @config = mock 'config', :clear => nil + @trans = mock 'transaction' - @settings.expects(:to_transportable).with(:whatever).returns(@bucket) - @bucket.expects(:to_catalog).returns(@config) - @config.expects(:apply).yields(@trans) - @config.stubs(:host_config=) - end + @settings.expects(:to_transportable).with(:whatever).returns(@bucket) + @bucket.expects(:to_catalog).returns(@config) + @config.expects(:apply).yields(@trans) + @config.stubs(:host_config=) + end - it "should provide a method that writes files with the correct modes" do - pending "Not converted from test/unit yet" - end + it "should provide a method that writes files with the correct modes" do + pending "Not converted from test/unit yet" + end - it "should provide a method that creates directories with the correct modes" do - Puppet::Util::SUIDManager.expects(:asuser).with("luke", "johnny").yields - Dir.expects(:mkdir).with("/otherdir", 0755) - @settings.mkdir(:otherdir) - end + it "should provide a method that creates directories with the correct modes" do + Puppet::Util::SUIDManager.expects(:asuser).with("luke", "johnny").yields + Dir.expects(:mkdir).with("/otherdir", 0755) + @settings.mkdir(:otherdir) + end - it "should be able to create needed directories in a single section" do - Dir.expects(:mkdir).with("/maindir") - Dir.expects(:mkdir).with("/seconddir") - @settings.use(:main) - end + it "should be able to create needed directories in a single section" do + Dir.expects(:mkdir).with("/maindir") + Dir.expects(:mkdir).with("/seconddir") + @settings.use(:main) + end - it "should be able to create needed directories in multiple sections" do - Dir.expects(:mkdir).with("/maindir") - Dir.expects(:mkdir).with("/seconddir") - Dir.expects(:mkdir).with("/thirddir") - @settings.use(:main, :third) - end + it "should be able to create needed directories in multiple sections" do + Dir.expects(:mkdir).with("/maindir") + Dir.expects(:mkdir).with("/seconddir") + Dir.expects(:mkdir).with("/thirddir") + @settings.use(:main, :third) + end - it "should provide a method to trigger enforcing of file modes on existing files and directories" do - pending "Not converted from test/unit yet" - end + it "should provide a method to trigger enforcing of file modes on existing files and directories" do + pending "Not converted from test/unit yet" + end - it "should provide a method to convert the file mode enforcement into a Puppet manifest" do - pending "Not converted from test/unit yet" - end + it "should provide a method to convert the file mode enforcement into a Puppet manifest" do + pending "Not converted from test/unit yet" + end - it "should create files when configured to do so with the :create parameter" - - it "should provide a method to convert the file mode enforcement into transportable resources" do - # Make it think we're root so it tries to manage user and group. - Puppet.features.stubs(:root?).returns(true) - File.stubs(:exist?).with("/myfile").returns(true) - trans = nil - trans = @settings.to_transportable - resources = [] - trans.delve { |obj| resources << obj if obj.is_a? Puppet::TransObject } - %w{/maindir /seconddir /otherdir /myfile}.each do |path| - obj = resources.find { |r| r.type == "file" and r.name == path } - if path.include?("dir") - obj[:ensure].should == :directory - else - # Do not create the file, just manage mode - obj[:ensure].should be_nil + it "should create files when configured to do so with the :create parameter" + + it "should provide a method to convert the file mode enforcement into transportable resources" do + # Make it think we're root so it tries to manage user and group. + Puppet.features.stubs(:root?).returns(true) + File.stubs(:exist?).with("/myfile").returns(true) + trans = nil + trans = @settings.to_transportable + resources = [] + trans.delve { |obj| resources << obj if obj.is_a? Puppet::TransObject } + %w{/maindir /seconddir /otherdir /myfile}.each do |path| + obj = resources.find { |r| r.type == "file" and r.name == path } + if path.include?("dir") + obj[:ensure].should == :directory + else + # Do not create the file, just manage mode + obj[:ensure].should be_nil + end + obj.should be_instance_of(Puppet::TransObject) + case path + when "/otherdir": + obj[:owner].should == "luke" + obj[:group].should == "johnny" + obj[:mode].should == 0755 + when "/myfile": + obj[:mode].should == 0755 + end end - obj.should be_instance_of(Puppet::TransObject) - case path - when "/otherdir": - obj[:owner].should == "luke" - obj[:group].should == "johnny" - obj[:mode].should == 0755 - when "/myfile": - obj[:mode].should == 0755 + end + + it "should not try to manage user or group when not running as root" do + Puppet.features.stubs(:root?).returns(false) + trans = nil + trans = @settings.to_transportable(:other) + trans.delve do |obj| + next unless obj.is_a?(Puppet::TransObject) + obj[:owner].should be_nil + obj[:group].should be_nil end end - end - it "should not try to manage user or group when not running as root" do - Puppet.features.stubs(:root?).returns(false) - trans = nil - trans = @settings.to_transportable(:other) - trans.delve do |obj| - next unless obj.is_a?(Puppet::TransObject) - obj[:owner].should be_nil - obj[:group].should be_nil + it "should add needed users and groups to the manifest when asked" do + # This is how we enable user/group management + @settings.setdefaults :main, :mkusers => [true, "w"] + Puppet.features.stubs(:root?).returns(false) + trans = nil + trans = @settings.to_transportable(:other) + resources = [] + trans.delve { |obj| resources << obj if obj.is_a? Puppet::TransObject and obj.type != "file" } + + user = resources.find { |r| r.type == "user" } + user.should be_instance_of(Puppet::TransObject) + user.name.should == "luke" + user[:ensure].should == :present + + # This should maybe be a separate test, but... + group = resources.find { |r| r.type == "group" } + group.should be_instance_of(Puppet::TransObject) + group.name.should == "johnny" + group[:ensure].should == :present end - end - it "should add needed users and groups to the manifest when asked" do - # This is how we enable user/group management - @settings.setdefaults :main, :mkusers => [true, "w"] - Puppet.features.stubs(:root?).returns(false) - trans = nil - trans = @settings.to_transportable(:other) - resources = [] - trans.delve { |obj| resources << obj if obj.is_a? Puppet::TransObject and obj.type != "file" } - - user = resources.find { |r| r.type == "user" } - user.should be_instance_of(Puppet::TransObject) - user.name.should == "luke" - user[:ensure].should == :present - - # This should maybe be a separate test, but... - group = resources.find { |r| r.type == "group" } - group.should be_instance_of(Puppet::TransObject) - group.name.should == "johnny" - group[:ensure].should == :present - end + it "should ignore tags and schedules when creating files and directories" - it "should ignore tags and schedules when creating files and directories" + it "should apply all resources in debug mode to reduce logging" - it "should apply all resources in debug mode to reduce logging" + it "should not try to manage absent files" do + # Make it think we're root so it tries to manage user and group. + Puppet.features.stubs(:root?).returns(true) + trans = nil + trans = @settings.to_transportable + file = nil + trans.delve { |obj| file = obj if obj.name == "/myfile" } + file.should be_nil + end - it "should not try to manage absent files" do - # Make it think we're root so it tries to manage user and group. - Puppet.features.stubs(:root?).returns(true) - trans = nil - trans = @settings.to_transportable - file = nil - trans.delve { |obj| file = obj if obj.name == "/myfile" } - file.should be_nil - end + it "should not try to manage files in memory" do + main = Puppet::Type.type(:file).create(:path => "/maindir") - it "should not try to manage files in memory" do - main = Puppet::Type.type(:file).create(:path => "/maindir") + trans = @settings.to_transportable - trans = @settings.to_transportable + lambda { trans.to_catalog }.should_not raise_error + end - lambda { trans.to_catalog }.should_not raise_error - end + it "should do nothing if a catalog cannot be created" do + bucket = mock 'bucket' + catalog = mock 'catalog' - it "should do nothing if a catalog cannot be created" do - bucket = mock 'bucket' - catalog = mock 'catalog' + @settings.expects(:to_transportable).returns bucket + bucket.expects(:to_catalog).raises RuntimeError + catalog.expects(:apply).never - @settings.expects(:to_transportable).returns bucket - bucket.expects(:to_catalog).raises RuntimeError - catalog.expects(:apply).never + @settings.use(:mysection) + end - @settings.use(:mysection) - end + it "should clear the catalog after applying" do + bucket = mock 'bucket' + catalog = mock 'catalog' - it "should clear the catalog after applying" do - bucket = mock 'bucket' - catalog = mock 'catalog' + @settings.expects(:to_transportable).returns bucket + bucket.expects(:to_catalog).returns catalog + catalog.stubs(:host_config=) + catalog.stubs(:apply) + catalog.expects(:clear) - @settings.expects(:to_transportable).returns bucket - bucket.expects(:to_catalog).returns catalog - catalog.stubs(:host_config=) - catalog.stubs(:apply) - catalog.expects(:clear) + @settings.use(:mysection) + end - @settings.use(:mysection) - end + it "should clear the catalog even if there is an exception during applying" do + bucket = mock 'bucket' + catalog = mock 'catalog' - it "should clear the catalog even if there is an exception during applying" do - bucket = mock 'bucket' - catalog = mock 'catalog' + @settings.expects(:to_transportable).returns bucket + bucket.expects(:to_catalog).returns catalog + catalog.stubs(:host_config=) + catalog.expects(:apply).raises(ArgumentError) + catalog.expects(:clear) - @settings.expects(:to_transportable).returns bucket - bucket.expects(:to_catalog).returns catalog - catalog.stubs(:host_config=) - catalog.expects(:apply).raises(ArgumentError) - catalog.expects(:clear) + # We don't care about the raised exception, we just care that + # we clear the catalog even with the exception + lambda { @settings.use(:mysection) }.should raise_error + end - # We don't care about the raised exception, we just care that - # we clear the catalog even with the exception - lambda { @settings.use(:mysection) }.should raise_error - end + it "should do nothing if all specified sections have already been used" do + bucket = mock 'bucket' + catalog = mock 'catalog' - it "should do nothing if all specified sections have already been used" do - bucket = mock 'bucket' - catalog = mock 'catalog' + @settings.expects(:to_transportable).once.returns(bucket) + bucket.expects(:to_catalog).returns catalog + catalog.stub_everything - @settings.expects(:to_transportable).once.returns(bucket) - bucket.expects(:to_catalog).returns catalog - catalog.stub_everything + @settings.use(:whatever) - @settings.use(:whatever) + @settings.use(:whatever) + end - @settings.use(:whatever) - end + it "should ignore file settings whose values are not strings" do + @settings[:maindir] = false - it "should ignore file settings whose values are not strings" do - @settings[:maindir] = false + lambda { trans = @settings.to_transportable }.should_not raise_error + end - lambda { trans = @settings.to_transportable }.should_not raise_error - end + it "should be able to turn the current configuration into a parseable manifest" - it "should be able to turn the current configuration into a parseable manifest" + it "should convert octal numbers correctly when producing a manifest" - it "should convert octal numbers correctly when producing a manifest" + it "should be able to provide all of its parameters in a format compatible with GetOpt::Long" do + pending "Not converted from test/unit yet" + end - it "should be able to provide all of its parameters in a format compatible with GetOpt::Long" do - pending "Not converted from test/unit yet" - end + it "should not attempt to manage files within /dev" do + pending "Not converted from test/unit yet" + end - it "should not attempt to manage files within /dev" do - pending "Not converted from test/unit yet" - end + it "should not modify the stored state database when managing resources" do + Puppet::Util::Storage.expects(:store).never + Puppet::Util::Storage.expects(:load).never + Dir.expects(:mkdir).with("/maindir") + Dir.expects(:mkdir).with("/seconddir") + @settings.use(:main) + end - it "should not modify the stored state database when managing resources" do - Puppet::Util::Storage.expects(:store).never - Puppet::Util::Storage.expects(:load).never - Dir.expects(:mkdir).with("/maindir") - Dir.expects(:mkdir).with("/seconddir") - @settings.use(:main) - end + it "should convert all relative paths to fully-qualified paths (#795)" do + @settings[:myfile] = "unqualified" + dir = Dir.getwd + @settings[:myfile].should == File.join(dir, "unqualified") + end - it "should convert all relative paths to fully-qualified paths (#795)" do - @settings[:myfile] = "unqualified" - dir = Dir.getwd - @settings[:myfile].should == File.join(dir, "unqualified") - end + it "should support a method for re-using all currently used sections" do + Dir.expects(:mkdir).with("/thirddir").times(2) + @settings.use(:third) + @settings.reuse + end - it "should support a method for re-using all currently used sections" do - Dir.expects(:mkdir).with("/thirddir").times(2) - @settings.use(:third) - @settings.reuse - end + it "should fail if any resources fail" do + stub_transaction + @trans.expects(:any_failed?).returns(true) - it "should fail if any resources fail" do - stub_transaction - @trans.expects(:any_failed?).returns(true) + proc { @settings.use(:whatever) }.should raise_error(RuntimeError) + end - proc { @settings.use(:whatever) }.should raise_error(RuntimeError) + after { Puppet::Type.allclear } end - after { Puppet::Type.allclear } + describe "when dealing with printing configs" do + before do + @settings = Puppet::Util::Settings.new + #these are the magic default values + @settings.stubs(:value).with(:configprint).returns("") + @settings.stubs(:value).with(:genconfig).returns(false) + @settings.stubs(:value).with(:genmanifest).returns(false) + @settings.stubs(:value).with(:environment).returns(nil) + end + + describe "when checking print_config?" do + it "should return false when the :configprint, :genconfig and :genmanifest are not set" do + @settings.print_configs?.should be_false + end + + it "should return true when :configprint has a value" do + @settings.stubs(:value).with(:configprint).returns("something") + @settings.print_configs?.should be_true + end + + it "should return true when :genconfig has a value" do + @settings.stubs(:value).with(:genconfig).returns(true) + @settings.print_configs?.should be_true + end + + it "should return true when :genmanifest has a value" do + @settings.stubs(:value).with(:genmanifest).returns(true) + @settings.print_configs?.should be_true + end + end + + describe "when printing configs" do + describe "when :configprint has a value" do + it "should call print_config_options" do + @settings.stubs(:value).with(:configprint).returns("something") + @settings.expects(:print_config_options) + @settings.print_configs + end + + it "should get the value of the option using the environment" do + @settings.stubs(:value).with(:configprint).returns("something") + @settings.stubs(:include?).with("something").returns(true) + @settings.expects(:value).with(:environment).returns("env") + @settings.expects(:value).with("something", "env").returns("foo") + @settings.stubs(:puts).with("foo") + @settings.print_configs + end + + it "should print the value of the option" do + @settings.stubs(:value).with(:configprint).returns("something") + @settings.stubs(:include?).with("something").returns(true) + @settings.stubs(:value).with("something", nil).returns("foo") + @settings.expects(:puts).with("foo") + @settings.print_configs + end + + it "should print the value pairs if there are multiple options" do + @settings.stubs(:value).with(:configprint).returns("bar,baz") + @settings.stubs(:include?).with("bar").returns(true) + @settings.stubs(:include?).with("baz").returns(true) + @settings.stubs(:value).with("bar", nil).returns("foo") + @settings.stubs(:value).with("baz", nil).returns("fud") + @settings.expects(:puts).with("bar = foo") + @settings.expects(:puts).with("baz = fud") + @settings.print_configs + end + + it "should print a whole bunch of stuff if :configprint = all" + + it "should return true after printing" do + @settings.stubs(:value).with(:configprint).returns("something") + @settings.stubs(:include?).with("something").returns(true) + @settings.stubs(:value).with("something", nil).returns("foo") + @settings.stubs(:puts).with("foo") + @settings.print_configs.should be_true + end + + it "should return false if a config param is not found" do + @settings.stubs(:value).with(:configprint).returns("something") + @settings.stubs(:include?).with("something").returns(false) + @settings.print_configs.should be_false + end + end + + describe "when genconfig is true" do + it "should call to_config" do + @settings.stubs(:value).with(:genconfig).returns(true) + @settings.expects(:to_config) + @settings.print_configs + end + + it "should return true from print_configs" do + @settings.stubs(:value).with(:genconfig).returns(true) + @settings.stubs(:to_config) + @settings.print_configs.should be_true + end + end + + describe "when genmanifest is true" do + it "should call to_config" do + @settings.stubs(:value).with(:genmanifest).returns(true) + @settings.expects(:to_manifest) + @settings.print_configs + end + + it "should return true from print_configs" do + @settings.stubs(:value).with(:genmanifest).returns(true) + @settings.stubs(:to_manifest) + @settings.print_configs.should be_true + end + end + end + end end |