Hello community,
here is the log from the commit of package rubygem-mixlib-config for
openSUSE:Factory checked in at 2016-10-10 16:22:31
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/rubygem-mixlib-config (Old)
and /work/SRC/openSUSE:Factory/.rubygem-mixlib-config.new (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "rubygem-mixlib-config"
Changes:
--------
---
/work/SRC/openSUSE:Factory/rubygem-mixlib-config/rubygem-mixlib-config.changes
2016-09-12 13:26:38.000000000 +0200
+++
/work/SRC/openSUSE:Factory/.rubygem-mixlib-config.new/rubygem-mixlib-config.changes
2016-10-10 16:22:35.000000000 +0200
@@ -1,0 +2,6 @@
+Sat Sep 10 04:33:47 UTC 2016 - [email protected]
+
+- updated to version 2.2.4
+ no changelog found
+
+-------------------------------------------------------------------
Old:
----
mixlib-config-2.2.2.gem
New:
----
mixlib-config-2.2.4.gem
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ rubygem-mixlib-config.spec ++++++
--- /var/tmp/diff_new_pack.sbNhHR/_old 2016-10-10 16:22:37.000000000 +0200
+++ /var/tmp/diff_new_pack.sbNhHR/_new 2016-10-10 16:22:37.000000000 +0200
@@ -24,7 +24,7 @@
#
Name: rubygem-mixlib-config
-Version: 2.2.2
+Version: 2.2.4
Release: 0
%define mod_name mixlib-config
%define mod_full_name %{mod_name}-%{version}
++++++ mixlib-config-2.2.2.gem -> mixlib-config-2.2.4.gem ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/NOTICE new/NOTICE
--- old/NOTICE 2016-08-22 22:18:42.000000000 +0200
+++ new/NOTICE 2016-09-03 00:20:31.000000000 +0200
@@ -1,25 +1,25 @@
-Mixin::Config NOTICE
+Mixlib::Config NOTICE
=================
-Developed at Opscode (http://www.opscode.com).
+Developed at Chef (http://www.chef.io).
- * Copyright 2009, Opscode, Inc. <[email protected]>
+ * Copyright 2009-2016, Chef Software, Inc. <[email protected]>
-Mixin::Config incorporates code from Chef. The Chef notice file follows:
+Mixlib::Config incorporates code from Chef. The Chef notice file follows:
Chef NOTICE
===========
-Developed at Opscode (http://www.opscode.com).
+Developed at Chef (http://www.chef.io).
Contributors and Copyright holders:
- * Copyright 2008, Adam Jacob <[email protected]>
+ * Copyright 2008, Adam Jacob <[email protected]>
* Copyright 2008, Arjuna Christensen <[email protected]>
* Copyright 2008, Bryan McLellan <[email protected]>
* Copyright 2008, Ezra Zygmuntowicz <[email protected]>
* Copyright 2009, Sean Cribbs <[email protected]>
- * Copyright 2009, Christopher Brown <[email protected]>
+ * Copyright 2009, Christopher Brown <[email protected]>
* Copyright 2009, Thom May <[email protected]>
Chef incorporates code modified from Open4
(http://www.codeforpeople.com/lib/ruby/open4/), which was written by Ara T.
Howard.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/README.md new/README.md
--- old/README.md 2016-08-22 22:18:42.000000000 +0200
+++ new/README.md 2016-09-03 00:20:31.000000000 +0200
@@ -1,6 +1,8 @@
-# Mixlib::Config #
+# Mixlib::Config
-Mixlib::Config provides a class-based configuration object, as used in Chef.
To use in your project:
+[](https://travis-ci.org/chef/mixlib-config)[](https://badge.fury.io/rb/mixlib-config)
+
+Mixlib::Config provides a class-based configuration object, as used in Chef.
To use in your project:
```ruby
require 'mixlib/config'
@@ -13,7 +15,7 @@
end
```
-You can use this to provide a configuration file for a user. For example, if
you do this:
+You can use this to provide a configuration file for a user. For example, if
you do this:
```ruby
MyConfig.from_file('~/.myconfig.rb')
@@ -32,6 +34,7 @@
MyConfig.first_value # returns 'something'
MyConfig[:first_value] # returns 'something'
```
+
And you can modify configuration values with this syntax:
```ruby
@@ -40,9 +43,9 @@
MyConfig[:first_value] = 'foobar' # sets first_value to 'foobar'
```
-## Nested Configuration ##
+## Nested Configuration
-Often you want to be able to group configuration options to provide a common
context. Mixlib::Config supports this thus:
+Often you want to be able to group configuration options to provide a common
context. Mixlib::Config supports this thus:
```ruby
require 'mixlib/config'
@@ -56,11 +59,30 @@
end
```
-The user can write their config file like this:
+The user can write their config file in one of three formats:
+
+#### Method Style
+```ruby
+logging.base_filename 'superlog'
+logging.max_log_files 2
+```
+#### Block Style
+Using this format the block is executed in the context, so all configurables
on that context is directly accessible
```ruby
- logging.base_filename 'superlog'
- logging.max_log_files 2
+logging do
+ base_filename 'superlog'
+ max_log_files 2
+end
+```
+
+#### Block with Argument Style
+Using this format the context is given to the block as an argument
+```ruby
+logging do |l|
+ l.base_filename = 'superlog'
+ l.max_log_files = 2
+end
```
You can access these variables thus:
@@ -70,9 +92,9 @@
MyConfig[:logging][:max_log_files]
```
-## Default Values ##
+## Default Values
-Mixlib::Config has a powerful default value facility. In addition to being
able to specify explicit default values, you can even specify Ruby code blocks
that will run if the config value is not set. This can allow you to build
options whose values are based on other options.
+Mixlib::Config has a powerful default value facility. In addition to being
able to specify explicit default values, you can even specify Ruby code blocks
that will run if the config value is not set. This can allow you to build
options whose values are based on other options.
```ruby
require 'mixlib/config'
@@ -93,9 +115,9 @@
print_network_requests false
```
-## Strict Mode ##
+## Strict Mode
-Misspellings are a common configuration problem, and Mixlib::Config has an
answer: `config_strict_mode`. Setting `config_strict_mode` to `true` will
cause any misspelled or incorrect configuration option references to throw
`Mixlib::Config::UnknownConfigOptionError`.
+Misspellings are a common configuration problem, and Mixlib::Config has an
answer: `config_strict_mode`. Setting `config_strict_mode` to `true` will cause
any misspelled or incorrect configuration option references to throw
`Mixlib::Config::UnknownConfigOptionError`.
```ruby
require 'mixlib/config'
@@ -112,18 +134,16 @@
end
```
-Now if a user types `fielname "~/output-mine.txt"` in their configuration
file, it will toss an exception telling them that the option "fielname" is
unknown. If you do not set config_strict_mode, the fielname option will be
merrily set and the application just won't know about it.
-
-Different config_contexts can have different strict modes; but they inherit
the strict mode of their parent if you don't explicitly set it. So setting it
once at the top level is sufficient. In the above example, `logging.base_naem
'mylog'` will raise an error.
+Now if a user types `fielname "~/output-mine.txt"` in their configuration
file, it will toss an exception telling them that the option "fielname" is
unknown. If you do not set config_strict_mode, the fielname option will be
merrily set and the application just won't know about it.
-In conclusion: *always set config_strict_mode to true*. You know you want to.
+Different config_contexts can have different strict modes; but they inherit
the strict mode of their parent if you don't explicitly set it. So setting it
once at the top level is sufficient. In the above example, `logging.base_naem
'mylog'` will raise an error.
-## Testing and Reset ##
+In conclusion: _always set config_strict_mode to true_. You know you want to.
-Testing your application with different sets of arguments can by simplified
with `reset`. Call `MyConfig.reset` before each test and all configuration will
be reset to its default value. There's no need to explicitly unset all your
options between each run.
+## Testing and Reset
-NOTE: if you have arrays of arrays, or other deep nesting, we suggest you use
code blocks to set up your default values (`default(:option) { [ [ 1, 2 ], [ 3,
4 ] ] }`). Deep children will not always be reset to their default values.
+Testing your application with different sets of arguments can by simplified
with `reset`. Call `MyConfig.reset` before each test and all configuration will
be reset to its default value. There's no need to explicitly unset all your
options between each run.
-Report bugs [here](https://tickets.opscode.com).
+NOTE: if you have arrays of arrays, or other deep nesting, we suggest you use
code blocks to set up your default values (`default(:option) { [ [ 1, 2 ], [ 3,
4 ] ] }`). Deep children will not always be reset to their default values.
Enjoy!
Files old/checksums.yaml.gz and new/checksums.yaml.gz differ
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/lib/mixlib/config/configurable.rb
new/lib/mixlib/config/configurable.rb
--- old/lib/mixlib/config/configurable.rb 2016-08-22 22:18:42.000000000
+0200
+++ new/lib/mixlib/config/configurable.rb 2016-09-03 00:20:31.000000000
+0200
@@ -1,6 +1,6 @@
#
-# Author:: John Keiser (<[email protected]>)
-# Copyright:: Copyright (c) 2013 Opscode, Inc.
+# Author:: John Keiser (<[email protected]>)
+# Copyright:: Copyright (c) 2013-2016 Chef Software, Inc.
# License:: Apache License, Version 2.0
#
# Licensed under the Apache License, Version 2.0 (the "License");
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/lib/mixlib/config/reopened_config_context_with_configurable_error.rb
new/lib/mixlib/config/reopened_config_context_with_configurable_error.rb
--- old/lib/mixlib/config/reopened_config_context_with_configurable_error.rb
2016-08-22 22:18:42.000000000 +0200
+++ new/lib/mixlib/config/reopened_config_context_with_configurable_error.rb
2016-09-03 00:20:31.000000000 +0200
@@ -1,6 +1,6 @@
#
-# Author:: John Keiser (<[email protected]>)
-# Copyright:: Copyright (c) 2013 Opscode, Inc.
+# Author:: John Keiser (<[email protected]>)
+# Copyright:: Copyright (c) 2013-2016 Chef Software, Inc.
# License:: Apache License, Version 2.0
#
# Licensed under the Apache License, Version 2.0 (the "License");
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/lib/mixlib/config/reopened_configurable_with_config_context_error.rb
new/lib/mixlib/config/reopened_configurable_with_config_context_error.rb
--- old/lib/mixlib/config/reopened_configurable_with_config_context_error.rb
2016-08-22 22:18:42.000000000 +0200
+++ new/lib/mixlib/config/reopened_configurable_with_config_context_error.rb
2016-09-03 00:20:31.000000000 +0200
@@ -1,6 +1,6 @@
#
-# Author:: John Keiser (<[email protected]>)
-# Copyright:: Copyright (c) 2013 Opscode, Inc.
+# Author:: John Keiser (<[email protected]>)
+# Copyright:: Copyright (c) 2013-2016 Chef Software, Inc.
# License:: Apache License, Version 2.0
#
# Licensed under the Apache License, Version 2.0 (the "License");
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/lib/mixlib/config/unknown_config_option_error.rb
new/lib/mixlib/config/unknown_config_option_error.rb
--- old/lib/mixlib/config/unknown_config_option_error.rb 2016-08-22
22:18:42.000000000 +0200
+++ new/lib/mixlib/config/unknown_config_option_error.rb 2016-09-03
00:20:31.000000000 +0200
@@ -1,6 +1,6 @@
#
-# Author:: John Keiser (<[email protected]>)
-# Copyright:: Copyright (c) 2013 Opscode, Inc.
+# Author:: John Keiser (<[email protected]>)
+# Copyright:: Copyright (c) 2013-2016 Chef Software, Inc.
# License:: Apache License, Version 2.0
#
# Licensed under the Apache License, Version 2.0 (the "License");
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/lib/mixlib/config/version.rb
new/lib/mixlib/config/version.rb
--- old/lib/mixlib/config/version.rb 2016-08-22 22:18:42.000000000 +0200
+++ new/lib/mixlib/config/version.rb 2016-09-03 00:20:31.000000000 +0200
@@ -1,6 +1,6 @@
#
-# Author:: Daniel DeLeo (<[email protected]>)
-# Copyright:: Copyright (c) 2013 Opscode, Inc.
+# Author:: Daniel DeLeo (<[email protected]>)
+# Copyright:: Copyright (c) 2013-2016 Chef Software, Inc.
# License:: Apache License, Version 2.0
#
# Licensed under the Apache License, Version 2.0 (the "License");
@@ -19,7 +19,7 @@
module Mixlib
module Config
- VERSION = "2.2.2"
+ VERSION = "2.2.4"
end
end
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/lib/mixlib/config.rb new/lib/mixlib/config.rb
--- old/lib/mixlib/config.rb 2016-08-22 22:18:42.000000000 +0200
+++ new/lib/mixlib/config.rb 2016-09-03 00:20:31.000000000 +0200
@@ -1,8 +1,8 @@
#
-# Author:: Adam Jacob (<[email protected]>)
-# Author:: Nuo Yan (<[email protected]>)
-# Author:: Christopher Brown (<[email protected]>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# Author:: Adam Jacob (<[email protected]>)
+# Author:: Nuo Yan (<[email protected]>)
+# Author:: Christopher Brown (<[email protected]>)
+# Copyright:: Copyright (c) 2008-2016 Chef Software, Inc.
# License:: Apache License, Version 2.0
#
# Licensed under the Apache License, Version 2.0 (the "License");
@@ -174,19 +174,24 @@
end
result
end
+ alias :to_hash :save
# Restore non-default values from the given hash.
#
- # This method is the equivalent of +reset+ followed by +merge!(hash)+.
- #
# === Parameters
# hash<Hash>: a hash in the same format as output by save.
- #
+ #
# === Returns
# self
def restore(hash)
- reset
- merge!(hash)
+ self.configuration = hash.reject { |key, value|
config_contexts.has_key?(key) }
+ config_contexts.each do |key, config_context|
+ if hash.has_key?(key)
+ config_context.restore(hash[key])
+ else
+ config_context.reset
+ end
+ end
end
# Merge an incoming hash with our config options
@@ -412,7 +417,7 @@
if configurables.has_key?(symbol)
configurables[symbol].set(self.configuration, value)
elsif config_contexts.has_key?(symbol)
- config_contexts[symbol].restore(value)
+ config_contexts[symbol].restore(value.to_hash)
else
if config_strict_mode == :warn
Chef::Log.warn("Setting unsupported config value #{symbol}.")
@@ -457,8 +462,18 @@
internal_set(symbol, value)
end
# Getter
- meta.send :define_method, symbol do |*args|
- internal_get_or_set(symbol, *args)
+ meta.send :define_method, symbol do |*args, &block|
+ # If a block was given, eval it in the context
+ if block
+ # If the block expects no arguments, then instance_eval
+ if block.arity == 0
+ internal_get(symbol).instance_eval(&block)
+ else # yield to the block
+ block.yield(internal_get(symbol))
+ end
+ else
+ internal_get_or_set(symbol, *args)
+ end
end
end
end
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/metadata new/metadata
--- old/metadata 2016-08-22 22:18:42.000000000 +0200
+++ new/metadata 2016-09-03 00:20:31.000000000 +0200
@@ -1,14 +1,14 @@
--- !ruby/object:Gem::Specification
name: mixlib-config
version: !ruby/object:Gem::Version
- version: 2.2.2
+ version: 2.2.4
platform: ruby
authors:
- Chef Software, Inc.
autorequire:
bindir: bin
cert_chain: []
-date: 2016-08-22 00:00:00.000000000 Z
+date: 2016-09-02 00:00:00.000000000 Z
dependencies:
- !ruby/object:Gem::Dependency
name: rake
@@ -30,14 +30,14 @@
requirements:
- - "~>"
- !ruby/object:Gem::Version
- version: '2.99'
+ version: '3.0'
type: :development
prerelease: false
version_requirements: !ruby/object:Gem::Requirement
requirements:
- - "~>"
- !ruby/object:Gem::Version
- version: '2.99'
+ version: '3.0'
- !ruby/object:Gem::Dependency
name: rdoc
requirement: !ruby/object:Gem::Requirement
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/mixlib-config.gemspec new/mixlib-config.gemspec
--- old/mixlib-config.gemspec 2016-08-22 22:18:42.000000000 +0200
+++ new/mixlib-config.gemspec 2016-09-03 00:20:31.000000000 +0200
@@ -23,6 +23,6 @@
s.license = "Apache-2.0"
s.add_development_dependency "rake"
- s.add_development_dependency "rspec", "~> 2.99"
+ s.add_development_dependency "rspec", "~> 3.0"
s.add_development_dependency "rdoc"
end
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/spec/mixlib/config_spec.rb
new/spec/mixlib/config_spec.rb
--- old/spec/mixlib/config_spec.rb 2016-08-22 22:18:42.000000000 +0200
+++ new/spec/mixlib/config_spec.rb 2016-09-03 00:20:31.000000000 +0200
@@ -1,6 +1,6 @@
#
-# Author:: Adam Jacob (<[email protected]>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# Author:: Adam Jacob (<[email protected]>)
+# Copyright:: Copyright (c) 2008-2016 Chef Software, Inc.
# License:: Apache License, Version 2.0
#
# Licensed under the Apache License, Version 2.0 (the "License");
@@ -26,62 +26,62 @@
end
end
- it "should load a config file" do
- File.stub(:exists?).and_return(true)
- File.stub(:readable?).and_return(true)
- IO.stub(:read).with("config.rb").and_return("alpha = 'omega'\nfoo = 'bar'")
- lambda {
+ it "loads a config file" do
+ allow(File).to receive(:exists?).and_return(true)
+ allow(File).to receive(:readable?).and_return(true)
+ allow(IO).to receive(:read).with("config.rb").and_return("alpha =
'omega'\nfoo = 'bar'")
+ expect(lambda {
ConfigIt.from_file("config.rb")
- }.should_not raise_error
+ }).to_not raise_error
end
- it "should not raise an ArgumentError with an explanation if you try and set
a non-existent variable" do
- lambda {
+ it "doesn't raise an ArgumentError with an explanation if you try and set a
non-existent variable" do
+ expect(lambda {
ConfigIt[:foobar] = "blah"
- }.should_not raise_error
+ }).to_not raise_error
end
- it "should raise an Errno::ENOENT if it can't find the file" do
- lambda {
+ it "raises an Errno::ENOENT if it can't find the file" do
+ expect(lambda {
ConfigIt.from_file("/tmp/timmytimmytimmy")
- }.should raise_error(Errno::ENOENT)
+ }).to raise_error(Errno::ENOENT)
end
- it "should allow the error to bubble up when it's anything other than
IOError" do
- IO.stub(:read).with("config.rb").and_return("@#asdf")
- lambda {
+ it "allows the error to bubble up when it's anything other than IOError" do
+ allow(IO).to receive(:read).with("config.rb").and_return("@#asdf")
+ expect(lambda {
ConfigIt.from_file("config.rb")
- }.should raise_error(SyntaxError)
+ }).to raise_error(SyntaxError)
end
- it "should allow you to reference a value by index" do
- ConfigIt[:alpha].should == "omega"
+ it "allows you to reference a value by index" do
+ expect(ConfigIt[:alpha]).to eql("omega")
end
- it "should allow you to reference a value by string index" do
- ConfigIt["alpha"].should == "omega"
+ it "allows you to reference a value by string index" do
+ expect(ConfigIt["alpha"]).to eql("omega")
end
- it "should allow you to set a value by index" do
+ it "allows you to set a value by index" do
ConfigIt[:alpha] = "one"
- ConfigIt[:alpha].should == "one"
+ expect(ConfigIt[:alpha]).to eql("one")
end
- it "should allow you to set a value by string index" do
+ it "allows you to set a value by string index" do
ConfigIt["alpha"] = "one"
- ConfigIt[:alpha].should == "one"
+ expect(ConfigIt[:alpha]).to eql("one")
end
- it "should allow setting a value with attribute form" do
+ it "allows setting a value with attribute form" do
ConfigIt.arbitrary_value = 50
- ConfigIt.arbitrary_value.should == 50
- ConfigIt[:arbitrary_value].should == 50
+ expect(ConfigIt.arbitrary_value).to eql(50)
+ expect(ConfigIt[:arbitrary_value]).to eql(50)
end
- it "should allow setting a value with method form" do
+ it "allows setting a value with method form" do
ConfigIt.arbitrary_value 50
- ConfigIt.arbitrary_value.should == 50
- ConfigIt[:arbitrary_value].should == 50
+ expect(ConfigIt.arbitrary_value).to eql(50)
+ expect(ConfigIt[:arbitrary_value]).to eql(50)
end
describe "when strict mode is on" do
@@ -97,23 +97,23 @@
end
it "raises an error when you get an arbitrary config option with .y" do
- lambda { StrictClass.y }.should
raise_error(Mixlib::Config::UnknownConfigOptionError, "Reading unsupported
config value y.")
+ expect(lambda { StrictClass.y }).to
raise_error(Mixlib::Config::UnknownConfigOptionError, "Reading unsupported
config value y.")
end
it "raises an error when you get an arbitrary config option with [:y]" do
- lambda { StrictClass[:y] }.should
raise_error(Mixlib::Config::UnknownConfigOptionError, "Reading unsupported
config value y.")
+ expect(lambda { StrictClass[:y] }).to
raise_error(Mixlib::Config::UnknownConfigOptionError, "Reading unsupported
config value y.")
end
it "raises an error when you set an arbitrary config option with .y = 10"
do
- lambda { StrictClass.y = 10 }.should
raise_error(Mixlib::Config::UnknownConfigOptionError, "Cannot set unsupported
config value y.")
+ expect(lambda { StrictClass.y = 10 }).to
raise_error(Mixlib::Config::UnknownConfigOptionError, "Cannot set unsupported
config value y.")
end
it "raises an error when you set an arbitrary config option with .y 10" do
- lambda { StrictClass.y 10 }.should
raise_error(Mixlib::Config::UnknownConfigOptionError, "Cannot set unsupported
config value y.")
+ expect(lambda { StrictClass.y 10 }).to
raise_error(Mixlib::Config::UnknownConfigOptionError, "Cannot set unsupported
config value y.")
end
it "raises an error when you set an arbitrary config option with [:y] =
10" do
- lambda { StrictClass[:y] = 10 }.should
raise_error(Mixlib::Config::UnknownConfigOptionError, "Cannot set unsupported
config value y.")
+ expect(lambda { StrictClass[:y] = 10 }).to
raise_error(Mixlib::Config::UnknownConfigOptionError, "Cannot set unsupported
config value y.")
end
end
@@ -123,23 +123,23 @@
end
{ :cookbook_path => "monkey_rabbit", :otherthing => "boo" }.each do |k, v|
- it "should allow you to retrieve the config value for #{k} via []" do
- ConfigIt[k].should == v
+ it "allows you to retrieve the config value for #{k} via []" do
+ expect(ConfigIt[k]).to eql(v)
end
- it "should allow you to retrieve the config value for #{k} via
method_missing" do
- ConfigIt.send(k).should == v
+ it "allows you to retrieve the config value for #{k} via method_missing"
do
+ expect(ConfigIt.send(k)).to eql(v)
end
end
end
- it "should not raise an ArgumentError if you access a config option that
does not exist" do
- lambda { ConfigIt[:snob_hobbery] }.should_not raise_error
+ it "doesn't raise an ArgumentError if you access a config option that does
not exist" do
+ expect(lambda { ConfigIt[:snob_hobbery] }).to_not raise_error
end
- it "should return true or false with has_key?" do
- ConfigIt.has_key?(:monkey).should eql(false)
+ it "returns true or false with has_key?" do
+ expect(ConfigIt.has_key?(:monkey)).to be false
ConfigIt[:monkey] = "gotcha"
- ConfigIt.has_key?(:monkey).should eql(true)
+ expect(ConfigIt.has_key?(:monkey)).to be true
end
describe "when a class method override writer exists" do
@@ -153,29 +153,29 @@
end
end
- it "should multiply an integer by 1000" do
+ it "multiplies an integer by 1000" do
@klass[:test_method] = 53
- @klass[:test_method].should == 53000
+ expect(@klass[:test_method]).to eql(53000)
end
- it "should multiply an integer by 1000 with the method_missing form" do
+ it "multiplies an integer by 1000 with the method_missing form" do
@klass.test_method = 63
- @klass.test_method.should == 63000
+ expect(@klass.test_method).to eql(63000)
end
- it "should multiply an integer by 1000 with the instance_eval DSL form" do
+ it "multiplies an integer by 1000 with the instance_eval DSL form" do
@klass.instance_eval("test_method 73")
- @klass.test_method.should == 73000
+ expect(@klass.test_method).to eql(73000)
end
- it "should multiply an integer by 1000 via from-file, too" do
- IO.stub(:read).with("config.rb").and_return("test_method 99")
+ it "multiplies an integer by 1000 via from-file, too" do
+ allow(IO).to receive(:read).with("config.rb").and_return("test_method
99")
@klass.from_file("config.rb")
- @klass.test_method.should == 99000
+ expect(@klass.test_method).to eql(99000)
end
- it "should receive internal_set with the method name and config value" do
- @klass.should_receive(:internal_set).with(:test_method,
53).and_return(true)
+ it "receives internal_set with the method name and config value" do
+ expect(@klass).to receive(:internal_set).with(:test_method,
53).and_return(true)
@klass[:test_method] = 53
end
@@ -194,19 +194,19 @@
end
it "Getter methods are created for the configurable" do
- @klass.respond_to?(:daemonizeme).should == true
- @klass.respond_to?(:a).should == true
- @klass.respond_to?(:b).should == true
- @klass.respond_to?(:c).should == true
- @klass.respond_to?(:z).should == false
+ expect(@klass.respond_to?(:daemonizeme)).to be true
+ expect(@klass.respond_to?(:a)).to be true
+ expect(@klass.respond_to?(:b)).to be true
+ expect(@klass.respond_to?(:c)).to be true
+ expect(@klass.respond_to?(:z)).to be false
end
it "Setter methods are created for the configurable" do
- @klass.respond_to?("daemonizeme=".to_sym).should == true
- @klass.respond_to?("a=".to_sym).should == true
- @klass.respond_to?("b=".to_sym).should == true
- @klass.respond_to?("c=".to_sym).should == true
- @klass.respond_to?("z=".to_sym).should == false
+ expect(@klass.respond_to?("daemonizeme=".to_sym)).to be true
+ expect(@klass.respond_to?("a=".to_sym)).to be true
+ expect(@klass.respond_to?("b=".to_sym)).to be true
+ expect(@klass.respond_to?("c=".to_sym)).to be true
+ expect(@klass.respond_to?("z=".to_sym)).to be false
end
describe "and extra methods have been dumped into Object" do
@@ -229,17 +229,17 @@
it "Normal classes call the extra method" do
normal_class = Class.new
normal_class.extend(::Mixlib::Config)
- lambda { normal_class.daemonizeme }.should raise_error(NopeError)
+ expect(lambda { normal_class.daemonizeme }).to raise_error(NopeError)
end
it "Configurables with the same name as the extra method can be set" do
@klass.daemonizeme = 10
- @klass[:daemonizeme].should == 10
+ expect(@klass[:daemonizeme]).to eql(10)
end
it "Configurables with the same name as the extra method can be
retrieved" do
@klass[:daemonizeme] = 10
- @klass.daemonizeme.should == 10
+ expect(@klass.daemonizeme).to eql(10)
end
end
end
@@ -251,55 +251,55 @@
@klass.class_eval { default :attr, 4 }
end
- it "should default to that value" do
- @klass.attr.should == 4
+ it "defaults to that value" do
+ expect(@klass.attr).to eql(4)
end
- it "should default to that value when retrieved as a hash" do
- @klass[:attr].should == 4
+ it "defaults to that value when retrieved as a hash" do
+ expect(@klass[:attr]).to eql(4)
end
- it "should be settable to another value" do
+ it "is settable to another value" do
@klass.attr 5
- @klass.attr.should == 5
+ expect(@klass.attr).to eql(5)
end
- it "should still default to that value after delete" do
+ it "still defaults to that value after delete" do
@klass.attr 5
@klass.delete(:attr)
- @klass.attr.should == 4
+ expect(@klass.attr).to eql(4)
end
- it "should still default to that value after reset" do
+ it "still defaults to that value after reset" do
@klass.attr 5
@klass.reset
- @klass.attr.should == 4
+ expect(@klass.attr).to eql(4)
end
it "save should not save anything for it" do
- @klass.save.should == {}
+ expect(@klass.save).to eql({})
end
it "save with include_defaults should save all defaults" do
- @klass.save(true).should == { :attr => 4 }
+ expect(@klass.save(true)).to eql({ :attr => 4 })
end
- it "save should save the new value if it gets set" do
+ it "saves the new value if it gets set" do
@klass.attr 5
- (saved = @klass.save).should == { :attr => 5 }
+ expect((saved = @klass.save)).to eql({ :attr => 5 })
@klass.reset
- @klass.attr.should == 4
+ expect(@klass.attr).to eql(4)
@klass.restore(saved)
- @klass.attr.should == 5
+ expect(@klass.attr).to eql(5)
end
- it "save should save the new value even if it is set to its default value"
do
+ it "saves the new value even if it is set to its default value" do
@klass.attr 4
- (saved = @klass.save).should == { :attr => 4 }
+ expect((saved = @klass.save)).to eql({ :attr => 4 })
@klass.reset
- @klass.save.should == {}
+ expect(@klass.save).to eql({})
@klass.restore(saved)
- @klass.save.should == { :attr => 4 }
+ expect(@klass.save).to eql({ :attr => 4 })
end
end
@@ -313,61 +313,61 @@
end
end
- it "should default to that value" do
- @klass.attr.should == 8
+ it "defaults to that value" do
+ expect(@klass.attr).to eql(8)
end
- it "should be recalculated each time it is retrieved" do
- @klass.attr.should == 8
+ it "is recalculated each time it is retrieved" do
+ expect(@klass.attr).to eql(8)
@klass.x = 2
- @klass.attr.should == 4
+ expect(@klass.attr).to eql(4)
end
- it "should default to that value when retrieved as a hash" do
- @klass[:attr].should == 8
+ it "defaults to that value when retrieved as a hash" do
+ expect(@klass[:attr]).to eql(8)
end
- it "should be settable to another value" do
+ it "is settable to another value" do
@klass.attr 5
- @klass.attr.should == 5
+ expect(@klass.attr).to eql(5)
end
- it "should still default to that value after delete" do
+ it "still defaults to that value after delete" do
@klass.attr 5
@klass.delete(:attr)
- @klass.attr.should == 8
+ expect(@klass.attr).to eql(8)
end
- it "should still default to that value after reset" do
+ it "still defaults to that value after reset" do
@klass.attr 5
@klass.reset
- @klass.attr.should == 8
+ expect(@klass.attr).to eql(8)
end
it "save should not save anything for it" do
- @klass.save.should == {}
+ expect(@klass.save).to eql({})
end
it "save with include_defaults should save all defaults" do
- @klass.save(true).should == { :attr => 8, :x => 4 }
+ expect(@klass.save(true)).to eql({ :attr => 8, :x => 4 })
end
- it "save should save the new value if it gets set" do
+ it "saves the new value if it gets set" do
@klass.attr 5
- (saved = @klass.save).should == { :attr => 5 }
+ expect((saved = @klass.save)).to eql({ :attr => 5 })
@klass.reset
- @klass.attr.should == 8
+ expect(@klass.attr).to eql(8)
@klass.restore(saved)
- @klass.attr.should == 5
+ expect(@klass.attr).to eql(5)
end
- it "save should save the new value even if it is set to its default value"
do
+ it "saves the new value even if it is set to its default value" do
@klass.attr 8
- (saved = @klass.save).should == { :attr => 8 }
+ expect((saved = @klass.save)).to eql({ :attr => 8 })
@klass.reset
- @klass.save.should == {}
+ expect(@klass.save).to eql({})
@klass.restore(saved)
- @klass.save.should == { :attr => 8 }
+ expect(@klass.save).to eql({ :attr => 8 })
end
end
@@ -380,35 +380,35 @@
it "reset clears it to its default" do
@klass.attr << "x"
- @klass.attr.should == [ "x" ]
+ expect(@klass.attr).to eql([ "x" ])
@klass.reset
- @klass.attr.should == []
+ expect(@klass.attr).to eql([])
end
it "save should not save anything for it" do
- @klass.save.should == {}
+ expect(@klass.save).to eql({})
end
it "save with include_defaults should save all defaults" do
- @klass.save(true).should == { :attr => [] }
+ expect(@klass.save(true)).to eql({ :attr => [] })
end
- it "save should save the new value if it gets set" do
+ it "saves the new value if it gets set" do
@klass.attr << "x"
- (saved = @klass.save).should == { :attr => [ "x" ] }
+ expect((saved = @klass.save)).to eql({ :attr => [ "x" ] })
@klass.reset
- @klass.attr.should == []
+ expect(@klass.attr).to eql([])
@klass.restore(saved)
- @klass.attr.should == [ "x" ]
+ expect(@klass.attr).to eql([ "x" ])
end
- it "save should save the new value even if it is set to its default value"
do
+ it "saves the new value even if it is set to its default value" do
@klass.attr = []
- (saved = @klass.save).should == { :attr => [] }
+ expect((saved = @klass.save)).to eql({ :attr => [] })
@klass.reset
- @klass.save.should == {}
+ expect(@klass.save).to eql({})
@klass.restore(saved)
- @klass.save.should == { :attr => [] }
+ expect(@klass.save).to eql({ :attr => [] })
end
end
@@ -421,35 +421,35 @@
it "reset clears it to its default" do
@klass.attr[:x] = 10
- @klass.attr[:x].should == 10
+ expect(@klass.attr[:x]).to eql(10)
@klass.reset
- @klass.attr[:x].should == nil
+ expect(@klass.attr[:x]).to be_nil
end
it "save should not save anything for it" do
- @klass.save.should == {}
+ expect(@klass.save).to eql({})
end
it "save with include_defaults should save all defaults" do
- @klass.save(true).should == { :attr => {} }
+ expect(@klass.save(true)).to eql({ :attr => {} })
end
- it "save should save the new value if it gets set" do
+ it "saves the new value if it gets set" do
@klass.attr[:hi] = "lo"
- (saved = @klass.save).should == { :attr => { :hi => "lo" } }
+ expect((saved = @klass.save)).to eql({ :attr => { :hi => "lo" } })
@klass.reset
- @klass.attr.should == {}
+ expect(@klass.attr).to eql({})
@klass.restore(saved)
- @klass.save.should == { :attr => { :hi => "lo" } }
+ expect(@klass.save).to eql({ :attr => { :hi => "lo" } })
end
- it "save should save the new value even if it is set to its default value"
do
+ it "saves the new value even if it is set to its default value" do
@klass.attr = {}
- (saved = @klass.save).should == { :attr => {} }
+ expect((saved = @klass.save)).to eql({ :attr => {} })
@klass.reset
- @klass.save.should == {}
+ expect(@klass.save).to eql({})
@klass.restore(saved)
- @klass.save.should == { :attr => {} }
+ expect(@klass.save).to eql({ :attr => {} })
end
end
@@ -462,35 +462,35 @@
it "reset clears it to its default" do
@klass.attr << " world"
- @klass.attr.should == "hello world"
+ expect(@klass.attr).to eql("hello world")
@klass.reset
- @klass.attr.should == "hello"
+ expect(@klass.attr).to eql("hello")
end
it "save should not save anything for it" do
- @klass.save.should == {}
+ expect(@klass.save).to eql({})
end
it "save with include_defaults should save all defaults" do
- @klass.save(true).should == { :attr => "hello" }
+ expect(@klass.save(true)).to eql({ :attr => "hello" })
end
- it "save should save the new value if it gets set" do
+ it "saves the new value if it gets set" do
@klass.attr << " world"
- (saved = @klass.save).should == { :attr => "hello world" }
+ expect((saved = @klass.save)).to eql({ :attr => "hello world" })
@klass.reset
- @klass.attr.should == "hello"
+ expect(@klass.attr).to eql("hello")
@klass.restore(saved)
- @klass.attr.should == "hello world"
+ expect(@klass.attr).to eql("hello world")
end
- it "save should save the new value even if it is set to its default value"
do
+ it "saves the new value even if it is set to its default value" do
@klass.attr "hello world"
- (saved = @klass.save).should == { :attr => "hello world" }
+ expect((saved = @klass.save)).to eql({ :attr => "hello world" })
@klass.reset
- @klass.save.should == {}
+ expect(@klass.save).to eql({})
@klass.restore(saved)
- @klass.save.should == { :attr => "hello world" }
+ expect(@klass.save).to eql({ :attr => "hello world" })
end
end
@@ -503,56 +503,56 @@
end
end
- it "should default to that value" do
- @klass.attr.should == 4
+ it "defaults to that value" do
+ expect(@klass.attr).to eql(4)
end
- it "should default to that value when retrieved as a hash" do
- @klass[:attr].should == 4
+ it "defaults to that value when retrieved as a hash" do
+ expect(@klass[:attr]).to eql(4)
end
- it "should be settable to another value" do
+ it "is settable to another value" do
@klass.attr 5
- @klass.attr.should == 5
- @klass[:attr].should == 5
+ expect(@klass.attr).to eql(5)
+ expect(@klass[:attr]).to eql(5)
end
- it "should still default to that value after delete" do
+ it "still defaults to that value after delete" do
@klass.attr 5
@klass.delete(:attr)
- @klass.attr.should == 4
+ expect(@klass.attr).to eql(4)
end
- it "should still default to that value after reset" do
+ it "still defaults to that value after reset" do
@klass.attr 5
@klass.reset
- @klass.attr.should == 4
+ expect(@klass.attr).to eql(4)
end
it "save should not save anything for it" do
- @klass.save.should == {}
+ expect(@klass.save).to eql({})
end
it "save with include_defaults should save all defaults" do
- @klass.save(true).should == { :attr => 4 }
+ expect(@klass.save(true)).to eql({ :attr => 4 })
end
- it "save should save the new value if it gets set" do
+ it "saves the new value if it gets set" do
@klass.attr 5
- (saved = @klass.save).should == { :attr => 5 }
+ expect((saved = @klass.save)).to eql({ :attr => 5 })
@klass.reset
- @klass.attr.should == 4
+ expect(@klass.attr).to eql(4)
@klass.restore(saved)
- @klass.attr.should == 5
+ expect(@klass.attr).to eql(5)
end
- it "save should save the new value even if it is set to its default value"
do
+ it "saves the new value even if it is set to its default value" do
@klass.attr 4
- (saved = @klass.save).should == { :attr => 4 }
+ expect((saved = @klass.save)).to eql({ :attr => 4 })
@klass.reset
- @klass.save.should == {}
+ expect(@klass.save).to eql({})
@klass.restore(saved)
- @klass.save.should == { :attr => 4 }
+ expect(@klass.save).to eql({ :attr => 4 })
end
end
@@ -568,68 +568,68 @@
end
end
- it "should default to that value" do
- @klass.attr.should == 4
+ it "defaults to that value" do
+ expect(@klass.attr).to eql(4)
end
- it "should default to that value when retrieved as a hash" do
- @klass[:attr].should == 4
+ it "defaults to that value when retrieved as a hash" do
+ expect(@klass[:attr]).to eql(4)
end
- it "should be settable to another value" do
+ it "is settable to another value" do
@klass.attr 5
- @klass.attr.should == 10
- @klass[:attr].should == 10
+ expect(@klass.attr).to eql(10)
+ expect(@klass[:attr]).to eql(10)
end
- it "should be settable to another value with attr=" do
+ it "is settable to another value with attr=" do
@klass.attr = 5
- @klass.attr.should == 10
- @klass[:attr].should == 10
+ expect(@klass.attr).to eql(10)
+ expect(@klass[:attr]).to eql(10)
end
- it "should be settable to another value with [:attr]=" do
+ it "is settable to another value with [:attr]=" do
@klass[:attr] = 5
- @klass.attr.should == 10
- @klass[:attr].should == 10
+ expect(@klass.attr).to eql(10)
+ expect(@klass[:attr]).to eql(10)
end
- it "should still default to that value after delete" do
+ it "still defaults to that value after delete" do
@klass.attr 5
@klass.delete(:attr)
- @klass.attr.should == 4
+ expect(@klass.attr).to eql(4)
end
- it "should still default to that value after reset" do
+ it "still defaults to that value after reset" do
@klass.attr 5
@klass.reset
- @klass.attr.should == 4
+ expect(@klass.attr).to eql(4)
end
it "save should not save anything for it" do
- @klass.save.should == {}
+ expect(@klass.save).to eql({})
end
it "save with include_defaults should save all defaults" do
- @klass.save(true).should == { :attr => 4 }
+ expect(@klass.save(true)).to eql({ :attr => 4 })
end
- it "save should save the new value if it gets set" do
+ it "saves the new value if it gets set" do
@klass.attr 5
- (saved = @klass.save).should == { :attr => 10 }
+ expect((saved = @klass.save)).to eql({ :attr => 10 })
@klass.reset
- @klass.attr.should == 4
+ expect(@klass.attr).to eql(4)
@klass.restore(saved)
- @klass.attr.should == 10
+ expect(@klass.attr).to eql(10)
end
- it "save should save the new value even if it is set to its default value"
do
+ it "saves the new value even if it is set to its default value" do
@klass.attr 4
- (saved = @klass.save).should == { :attr => 8 }
+ expect((saved = @klass.save)).to eql({ :attr => 8 })
@klass.reset
- @klass.save.should == {}
+ expect(@klass.save).to eql({})
@klass.restore(saved)
- @klass.save.should == { :attr => 8 }
+ expect(@klass.save).to eql({ :attr => 8 })
end
end
@@ -642,68 +642,68 @@
end
end
- it "should default to that value" do
- @klass.attr.should == 4
+ it "defaults to that value" do
+ expect(@klass.attr).to eql(4)
end
- it "should default to that value when retrieved as a hash" do
- @klass[:attr].should == 4
+ it "defaults to that value when retrieved as a hash" do
+ expect(@klass[:attr]).to eql(4)
end
- it "should be settable to another value" do
+ it "is settable to another value" do
@klass.attr 5
- @klass.attr.should == 10
- @klass[:attr].should == 10
+ expect(@klass.attr).to eql(10)
+ expect(@klass[:attr]).to eql(10)
end
- it "should be settable to another value with attr=" do
+ it "is settable to another value with attr=" do
@klass.attr = 5
- @klass.attr.should == 10
- @klass[:attr].should == 10
+ expect(@klass.attr).to eql(10)
+ expect(@klass[:attr]).to eql(10)
end
- it "should be settable to another value with [:attr]=" do
+ it "is settable to another value with [:attr]=" do
@klass[:attr] = 5
- @klass.attr.should == 10
- @klass[:attr].should == 10
+ expect(@klass.attr).to eql(10)
+ expect(@klass[:attr]).to eql(10)
end
- it "should still default to that value after delete" do
+ it "still defaults to that value after delete" do
@klass.attr 5
@klass.delete(:attr)
- @klass.attr.should == 4
+ expect(@klass.attr).to eql(4)
end
- it "should still default to that value after reset" do
+ it "still defaults to that value after reset" do
@klass.attr 5
@klass.reset
- @klass.attr.should == 4
+ expect(@klass.attr).to eql(4)
end
it "save should not save anything for it" do
- @klass.save.should == {}
+ expect(@klass.save).to eql({})
end
it "save with include_defaults should save all defaults" do
- @klass.save(true).should == { :attr => 4 }
+ expect(@klass.save(true)).to eql({ :attr => 4 })
end
- it "save should save the new value if it gets set" do
+ it "saves the new value if it gets set" do
@klass.attr 5
- (saved = @klass.save).should == { :attr => 10 }
+ expect((saved = @klass.save)).to eql({ :attr => 10 })
@klass.reset
- @klass.attr.should == 4
+ expect(@klass.attr).to eql(4)
@klass.restore(saved)
- @klass.attr.should == 10
+ expect(@klass.attr).to eql(10)
end
- it "save should save the new value even if it is set to its default value"
do
+ it "saves the new value even if it is set to its default value" do
@klass.attr 2
- (saved = @klass.save).should == { :attr => 4 }
+ expect((saved = @klass.save)).to eql({ :attr => 4 })
@klass.reset
- @klass.save.should == {}
+ expect(@klass.save).to eql({})
@klass.restore(saved)
- @klass.save.should == { :attr => 4 }
+ expect(@klass.save).to eql({ :attr => 4 })
end
end
@@ -720,63 +720,81 @@
end
it "configurable defaults in that context work" do
- @klass.blah.x.should == 5
+ expect(@klass.blah.x).to eql(5)
end
it "after setting values in the context, the values remain set" do
@klass.blah.x = 10
- @klass.blah.x.should == 10
+ expect(@klass.blah.x).to eql(10)
end
it "setting values with the same name in the parent context do not affect
the child context" do
@klass.x = 10
- @klass.x.should == 10
- @klass.blah.x.should == 5
+ expect(@klass.x).to eql(10)
+ expect(@klass.blah.x).to eql(5)
end
it "setting the entire context to a hash with default value overridden
sets the value" do
@klass.blah = { :x => 10 }
- @klass.blah.x.should == 10
+ expect(@klass.blah.x).to eql(10)
end
it "setting the entire context to a hash sets non-default values" do
@klass.blah = { :y => 10 }
- @klass.blah.x.should == 5
- @klass.blah.y.should == 10
+ expect(@klass.blah.x).to eql(5)
+ expect(@klass.blah.y).to eql(10)
end
it "setting the entire context to a hash deletes any non-default values
and resets default values" do
@klass.blah.x = 10
@klass.blah.y = 10
@klass.blah = { :z => 10 }
- @klass.blah.x.should == 5
- @klass.blah.y.should == nil
- @klass.blah.z.should == 10
+ expect(@klass.blah.x).to eql(5)
+ expect(@klass.blah.y).to be_nil
+ expect(@klass.blah.z).to eql(10)
+ end
+
+ it "setting the context values in a block overrides the default values" do
+ @klass.blah do
+ x 10
+ y 20
+ end
+ @klass.blah.x.should == 10
+ @klass.blah.y.should == 20
+ end
+
+ it "setting the context values in a yielded block overrides the default
values" do
+ @klass.blah do |b|
+ b.x = 10
+ b.y = 20
+ end
+ @klass.blah.x.should == 10
+ @klass.blah.y.should == 20
end
it "after reset of the parent class, children are reset" do
@klass.blah.x = 10
- @klass.blah.x.should == 10
+ expect(@klass.blah.x).to eql(10)
@klass.reset
- @klass.blah.x.should == 5
+ expect(@klass.blah.x).to eql(5)
end
it "save should not save anything for it by default" do
- @klass.save.should == {}
+ expect(@klass.save).to eql({})
end
it "save with include_defaults should save all defaults" do
- @klass.save(true).should == { :blah => { :x => 5 } }
+ expect(@klass.save(true)).to eql({ :blah => { :x => 5 } })
end
- it "save should save any new values that are set in the context" do
+ it "saves any new values that are set in the context" do
@klass.blah.x = 10
- (saved = @klass.save).should == { :blah => { :x => 10 } }
+ expect((saved = @klass.save)).to eql({ :blah => { :x => 10 } })
@klass.reset
- @klass.blah.x.should == 5
+ expect(@klass.blah.x).to eql(5)
@klass.restore(saved)
- @klass.blah.x.should == 10
- @klass.save.should == { :blah => { :x => 10 } }
+ expect(@klass.blah.x).to eql(10)
+ expect(@klass.save).to eql({ :blah => { :x => 10 } })
end
end
@@ -788,6 +806,7 @@
config_context(:blah) do
config_context(:yarr) do
default :x, 5
+ default :y, 6
end
end
configurable :x
@@ -795,43 +814,73 @@
end
it "configurable defaults in that context work" do
- @klass.blah.yarr.x.should == 5
+ expect(@klass.blah.yarr.x).to eql(5)
+ expect(@klass.blah.yarr.y).to eql(6)
end
it "after setting values in the context, the values remain set" do
@klass.blah.yarr.x = 10
- @klass.blah.yarr.x.should == 10
+ @klass.blah.yarr.y = 11
+ expect(@klass.blah.yarr.x).to eql(10)
+ expect(@klass.blah.yarr.y).to eql(11)
end
it "setting values with the same name in the parent context do not affect
the child context" do
@klass.x = 10
- @klass.x.should == 10
- @klass.blah.yarr.x.should == 5
+ expect(@klass.x).to eql(10)
+ expect(@klass.blah.yarr.x).to eql(5)
end
it "after reset of the parent class, children are reset" do
@klass.blah.yarr.x = 10
- @klass.blah.yarr.x.should == 10
+ @klass.blah.yarr.y = 11
+ expect(@klass.blah.yarr.x).to eql(10)
+ expect(@klass.blah.yarr.y).to eql(11)
@klass.reset
- @klass.blah.yarr.x.should == 5
+ expect(@klass.blah.yarr.x).to eql(5)
+ expect(@klass.blah.yarr.y).to eql(6)
end
it "save should not save anything for it by default" do
- @klass.save.should == {}
+ expect(@klass.save).to eql({})
end
it "save with include_defaults should save all defaults" do
- @klass.save(true).should == { :blah => { :yarr => { :x => 5 } } }
+ expect(@klass.save(true)).to eql({ :blah => { :yarr => { :x => 5, :y =>
6 } } })
end
- it "save should save any new values that are set in the context" do
+ it "saves any new values that are set in the context" do
@klass.blah.yarr.x = 10
- (saved = @klass.save).should == { :blah => { :yarr => { :x => 10 } } }
+ @klass.blah.yarr.y = 11
+ expect((saved = @klass.save)).to eql({ :blah => { :yarr => { :x => 10,
:y => 11 } } })
@klass.reset
- @klass.blah.yarr.x.should == 5
+ expect(@klass.blah.yarr.x).to eql(5)
+ expect(@klass.blah.yarr.y).to eql(6)
@klass.restore(saved)
- @klass.blah.yarr.x.should == 10
- @klass.save.should == { :blah => { :yarr => { :x => 10 } } }
+ expect(@klass.blah.yarr.x).to eql(10)
+ expect(@klass.blah.yarr.y).to eql(11)
+ expect(@klass.save).to eql({ :blah => { :yarr => { :x => 10, :y => 11 }
} })
+ end
+
+ it "restores defaults not included in saved data" do
+ @klass.restore( :blah => { :yarr => { :x => 10 } } )
+ expect(@klass.blah.yarr.x).to eql(10)
+ expect(@klass.blah.yarr.y).to eql(6)
+ end
+
+ it "removes added properties not included in saved state" do
+ @klass.blah.yarr.z = 12
+ @klass.restore( :blah => { :yarr => { :x => 10 } } )
+ expect(@klass.blah.yarr.x).to eql(10)
+ expect(@klass.blah.yarr.z).to eql(nil)
+ end
+
+ it "can set a config context from another context" do
+ @klass.blah.blyme = { :x => 7 }
+ blyme = @klass.blah.blyme
+ @klass.blah.yarr.x = 12
+ @klass.blah.yarr = blyme
+ expect(@klass.blah.yarr.x).to eql(7)
end
end
@@ -847,11 +896,11 @@
end
it "save does not save the hash for the config_context" do
- @klass.save.should == {}
+ expect(@klass.save).to eql({})
end
it "save with defaults saves the hash for the config_context" do
- @klass.save(true).should == { :blah => {} }
+ expect(@klass.save(true)).to eql({ :blah => {} })
end
end
@@ -865,11 +914,11 @@
end
it "save does not save the hash for the config_context" do
- @klass.save.should == {}
+ expect(@klass.save).to eql({})
end
it "save with defaults saves the hash for the config_context" do
- @klass.save(true).should == { :blah => {} }
+ expect(@klass.save(true)).to eql({ :blah => {} })
end
end
@@ -887,7 +936,7 @@
end
it "The nested class does not allow you to set arbitrary config options" do
- lambda { StrictClass2.c.y = 10 }.should
raise_error(Mixlib::Config::UnknownConfigOptionError, "Cannot set unsupported
config value y.")
+ expect(lambda { StrictClass2.c.y = 10 }).to
raise_error(Mixlib::Config::UnknownConfigOptionError, "Cannot set unsupported
config value y.")
end
end
@@ -900,11 +949,11 @@
end
it "The parent class does not allow you to set arbitrary config options" do
- lambda { StrictClass3.y = 10 }.should
raise_error(Mixlib::Config::UnknownConfigOptionError, "Cannot set unsupported
config value y.")
+ expect(lambda { StrictClass3.y = 10 }).to
raise_error(Mixlib::Config::UnknownConfigOptionError, "Cannot set unsupported
config value y.")
end
it "The nested class does not allow you to set arbitrary config options" do
- lambda { StrictClass3.y = 10 }.should
raise_error(Mixlib::Config::UnknownConfigOptionError, "Cannot set unsupported
config value y.")
+ expect(lambda { StrictClass3.y = 10 }).to
raise_error(Mixlib::Config::UnknownConfigOptionError, "Cannot set unsupported
config value y.")
end
end
@@ -931,27 +980,27 @@
it "When a config_context is opened in place of a regular configurable, an
error is raised" do
klass = Class.new
klass.extend(::Mixlib::Config)
- lambda do
+ expect(lambda do
klass.class_eval do
default :blah, 10
config_context(:blah) do
default :y, 20
end
end
- end.should
raise_error(Mixlib::Config::ReopenedConfigurableWithConfigContextError)
+ end).to
raise_error(Mixlib::Config::ReopenedConfigurableWithConfigContextError)
end
it "When a config_context is opened in place of a regular configurable, an
error is raised" do
klass = Class.new
klass.extend(::Mixlib::Config)
- lambda do
+ expect(lambda do
klass.class_eval do
config_context(:blah) do
default :y, 20
end
default :blah, 10
end
- end.should
raise_error(Mixlib::Config::ReopenedConfigContextWithConfigurableError)
+ end).to
raise_error(Mixlib::Config::ReopenedConfigContextWithConfigurableError)
end
end
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/spec/spec_helper.rb new/spec/spec_helper.rb
--- old/spec/spec_helper.rb 2016-08-22 22:18:42.000000000 +0200
+++ new/spec/spec_helper.rb 2016-09-03 00:20:31.000000000 +0200
@@ -11,6 +11,5 @@
RSpec.configure do |config|
config.filter_run :focus => true
config.run_all_when_everything_filtered = true
- config.treat_symbols_as_metadata_keys_with_true_values = true
config.warnings = true
end
