puppet 3.4.3 → 3.5.0.rc1

data/spec/unit/resource_spec.rb

@@ -5,7 +5,8 @@ require 'puppet/resource'
 describe Puppet::Resource do
   include PuppetSpec::Files
 
-  let :basepath do make_absolute("/somepath") end
+  let(:basepath) { make_absolute("/somepath") }
+  let(:environment) { Puppet::Node::Environment.create(:testing, [], '') }
 
   [:catalog, :file, :line].each do |attr|
     it "should have an #{attr} attribute" do
@@ -120,10 +121,6 @@ describe Puppet::Resource do
     resource.should be_exported
   end
 
-  it "should support an environment attribute" do
-    Puppet::Resource.new("file", "/my/file", :environment => :foo).environment.name.should == :foo
-  end
-
   describe "and munging its type and title" do
     describe "when modeling a builtin resource" do
       it "should be able to find the resource type" do
@@ -139,19 +136,19 @@ describe Puppet::Resource do
       describe "that exists" do
         before do
           @type = Puppet::Resource::Type.new(:definition, "foo::bar")
-          Puppet::Node::Environment.new.known_resource_types.add @type
+          environment.known_resource_types.add @type
         end
 
         it "should set its type to the capitalized type name" do
-          Puppet::Resource.new("foo::bar", "/my/file").type.should == "Foo::Bar"
+          Puppet::Resource.new("foo::bar", "/my/file", :environment => environment).type.should == "Foo::Bar"
         end
 
         it "should be able to find the resource type" do
-          Puppet::Resource.new("foo::bar", "/my/file").resource_type.should equal(@type)
+          Puppet::Resource.new("foo::bar", "/my/file", :environment => environment).resource_type.should equal(@type)
         end
 
         it "should set its title to the provided title" do
-          Puppet::Resource.new("foo::bar", "/my/file").title.should == "/my/file"
+          Puppet::Resource.new("foo::bar", "/my/file", :environment => environment).title.should == "/my/file"
         end
       end
 
@@ -179,15 +176,15 @@ describe Puppet::Resource do
       describe "that exists" do
         before do
           @type = Puppet::Resource::Type.new(:hostclass, "foo::bar")
-          Puppet::Node::Environment.new.known_resource_types.add @type
+          environment.known_resource_types.add @type
         end
 
         it "should set its title to the capitalized, fully qualified resource type" do
-          Puppet::Resource.new("class", "foo::bar").title.should == "Foo::Bar"
+          Puppet::Resource.new("class", "foo::bar", :environment => environment).title.should == "Foo::Bar"
         end
 
         it "should be able to find the resource type" do
-          Puppet::Resource.new("class", "foo::bar").resource_type.should equal(@type)
+          Puppet::Resource.new("class", "foo::bar", :environment => environment).resource_type.should equal(@type)
         end
       end
 
@@ -207,9 +204,9 @@ describe Puppet::Resource do
         describe "and a class exists whose name is the empty string" do # this was a bit tough to track down
           it "should set its title to :main" do
             @type = Puppet::Resource::Type.new(:hostclass, "")
-            Puppet::Node::Environment.new.known_resource_types.add @type
+            environment.known_resource_types.add @type
 
-            Puppet::Resource.new("class", "").title.should == :main
+            Puppet::Resource.new("class", "", :environment => environment).title.should == :main
           end
         end
       end
@@ -222,9 +219,9 @@ describe Puppet::Resource do
         describe "and a class exists whose name is the empty string" do # this was a bit tough to track down
           it "should set its title to :main" do
             @type = Puppet::Resource::Type.new(:hostclass, "")
-            Puppet::Node::Environment.new.known_resource_types.add @type
+            environment.known_resource_types.add @type
 
-            Puppet::Resource.new("class", :main).title.should == :main
+            Puppet::Resource.new("class", :main, :environment => environment).title.should == :main
           end
         end
       end
@@ -237,8 +234,8 @@ describe Puppet::Resource do
 
   it "should not fail when an invalid parameter is used and strict mode is disabled" do
     type = Puppet::Resource::Type.new(:definition, "foobar")
-    Puppet::Node::Environment.new.known_resource_types.add type
-    resource = Puppet::Resource.new("foobar", "/my/file")
+    environment.known_resource_types.add type
+    resource = Puppet::Resource.new("foobar", "/my/file", :environment => environment)
     resource[:yay] = true
   end
 
@@ -267,7 +264,7 @@ describe Puppet::Resource do
   end
 
   describe "when setting default parameters" do
-    let(:foo_node) { Puppet::Node.new('foo') }
+    let(:foo_node) { Puppet::Node.new('foo', :environment => environment) }
     let(:compiler) { Puppet::Parser::Compiler.new(foo_node) }
     let(:scope)    { Puppet::Parser::Scope.new(compiler) }
 
@@ -276,15 +273,15 @@ describe Puppet::Resource do
     end
 
     it "should fail when asked to set default values and it is not a parser resource" do
-      Puppet::Node::Environment.new.known_resource_types.add(
+      environment.known_resource_types.add(
       Puppet::Resource::Type.new(:definition, "default_param", :arguments => {"a" => ast_string("default")})
       )
-      resource = Puppet::Resource.new("default_param", "name")
+      resource = Puppet::Resource.new("default_param", "name", :environment => environment)
       lambda { resource.set_default_parameters(scope) }.should raise_error(Puppet::DevError)
     end
 
     it "should evaluate and set any default values when no value is provided" do
-      Puppet::Node::Environment.new.known_resource_types.add(
+      environment.known_resource_types.add(
         Puppet::Resource::Type.new(:definition, "default_param", :arguments => {"a" => ast_string("a_default_value")})
       )
       resource = Puppet::Parser::Resource.new("default_param", "name", :scope => scope)
@@ -293,7 +290,7 @@ describe Puppet::Resource do
     end
 
     it "should skip attributes with no default value" do
-      Puppet::Node::Environment.new.known_resource_types.add(
+      environment.known_resource_types.add(
         Puppet::Resource::Type.new(:definition, "no_default_param", :arguments => {"a" => ast_string("a_default_value")})
       )
       resource = Puppet::Parser::Resource.new("no_default_param", "name", :scope => scope)
@@ -301,7 +298,7 @@ describe Puppet::Resource do
     end
 
     it "should return the list of default parameters set" do
-      Puppet::Node::Environment.new.known_resource_types.add(
+      environment.known_resource_types.add(
         Puppet::Resource::Type.new(:definition, "default_param", :arguments => {"a" => ast_string("a_default_value")})
       )
       resource = Puppet::Parser::Resource.new("default_param", "name", :scope => scope)
@@ -315,11 +312,10 @@ describe Puppet::Resource do
       let(:apache) { Puppet::Resource::Type.new(:hostclass, 'apache', :arguments => { 'port' => port }) }
 
       before do
-        environment = Puppet::Node::Environment.new(environment_name)
         environment.known_resource_types.add(apache)
 
         scope.stubs(:host).returns('host')
-        scope.stubs(:environment).returns(Puppet::Node::Environment.new(environment_name))
+        scope.stubs(:environment).returns(environment)
         scope.stubs(:facts).returns(Puppet::Node::Facts.new("facts", fact_values))
       end
 
@@ -338,14 +334,6 @@ describe Puppet::Resource do
           resource.set_default_parameters(scope)
         end
 
-        it "should query the injector using a namespaced key" do
-          compiler.injector.expects(:lookup).with(scope, 'apache::port').returns("8081")
-
-          resource.set_default_parameters(scope)
-
-          resource[:port].should == "8081"
-        end
-
         it "should use the value from the data_binding terminus" do
           Puppet::DataBinding.indirection.expects(:find).returns('443')
 
@@ -354,23 +342,6 @@ describe Puppet::Resource do
           resource[:port].should == '443'
         end
 
-        it "should use the value from the injector" do
-          compiler.injector.expects(:lookup).with(scope, 'apache::port').returns('443')
-
-          resource.set_default_parameters(scope)
-
-          resource[:port].should == '443'
-        end
-
-        it "should not call the DataBinding terminus when injector produces a value" do
-          compiler.injector.expects(:lookup).with(scope, 'apache::port').returns('443')
-          Puppet::DataBinding.indirection.expects(:find).never()
-
-          resource.set_default_parameters(scope)
-
-          resource[:port].should == '443'
-        end
-
         it "should use the default value if the data_binding terminus returns nil" do
           Puppet::DataBinding.indirection.expects(:find).returns(nil)
 
@@ -386,14 +357,6 @@ describe Puppet::Resource do
           }.to raise_error(Puppet::Error, /Error from DataBinding 'hiera' while looking up 'apache::port':.*Forgettabotit/)
         end
 
-        it "should use the default value if the injector returns nil" do
-          compiler.injector.expects(:lookup).returns(nil)
-          Puppet::DataBinding.indirection.expects(:find).returns(nil)
-
-          resource.set_default_parameters(scope)
-
-          resource[:port].should == '80'
-        end
       end
 
       context "when a value is provided" do
@@ -431,17 +394,17 @@ describe Puppet::Resource do
 
   describe "when validating all required parameters are present" do
     it "should be able to validate that all required parameters are present" do
-      Puppet::Node::Environment.new.known_resource_types.add(
+      environment.known_resource_types.add(
         Puppet::Resource::Type.new(:definition, "required_param", :arguments => {"a" => nil})
       )
-      lambda { Puppet::Resource.new("required_param", "name").validate_complete }.should raise_error(Puppet::ParseError)
+      lambda { Puppet::Resource.new("required_param", "name", :environment => environment).validate_complete }.should raise_error(Puppet::ParseError)
     end
 
     it "should not fail when all required parameters are present" do
-      Puppet::Node::Environment.new.known_resource_types.add(
+      environment.known_resource_types.add(
         Puppet::Resource::Type.new(:definition, "no_required_param")
       )
-      resource = Puppet::Resource.new("no_required_param", "name")
+      resource = Puppet::Resource.new("no_required_param", "name", :environment => environment)
       resource["a"] = "meh"
       lambda { resource.validate_complete }.should_not raise_error
     end
@@ -488,14 +451,14 @@ describe Puppet::Resource do
 
     it "should correctly detect when provided parameters are not valid for defined resource types" do
       type = Puppet::Resource::Type.new(:definition, "foobar")
-      Puppet::Node::Environment.new.known_resource_types.add type
-      Puppet::Resource.new("foobar", "/my/file").should_not be_valid_parameter("myparam")
+      environment.known_resource_types.add type
+      Puppet::Resource.new("foobar", "/my/file", :environment => environment).should_not be_valid_parameter("myparam")
     end
 
     it "should correctly detect when provided parameters are valid for defined resource types" do
       type = Puppet::Resource::Type.new(:definition, "foobar", :arguments => {"myparam" => nil})
-      Puppet::Node::Environment.new.known_resource_types.add type
-      Puppet::Resource.new("foobar", "/my/file").should be_valid_parameter("myparam")
+      environment.known_resource_types.add type
+      Puppet::Resource.new("foobar", "/my/file", :environment => environment).should be_valid_parameter("myparam")
     end
 
     it "should allow setting and retrieving of parameters" do
@@ -636,11 +599,9 @@ describe Puppet::Resource do
   describe "when serializing a defined type" do
     before do
       type = Puppet::Resource::Type.new(:definition, "foo::bar")
-      Puppet::Node::Environment.new.known_resource_types.add type
-    end
+      environment.known_resource_types.add type
 
-    before :each do
-      @resource = Puppet::Resource.new('foo::bar', 'xyzzy')
+      @resource = Puppet::Resource.new('foo::bar', 'xyzzy', :environment => environment)
       @resource['one'] = 'test'
       @resource['two'] = 'other'
       @resource.resource_type
@@ -710,45 +671,45 @@ describe Puppet::Resource do
     # trap the actual data structure then.
 
     it "should set its type to the provided type" do
-      Puppet::Resource.from_pson(PSON.parse(Puppet::Resource.new("File", "/foo").to_pson)).type.should == "File"
+      Puppet::Resource.from_data_hash(PSON.parse(Puppet::Resource.new("File", "/foo").to_pson)).type.should == "File"
     end
 
     it "should set its title to the provided title" do
-      Puppet::Resource.from_pson(PSON.parse(Puppet::Resource.new("File", "/foo").to_pson)).title.should == "/foo"
+      Puppet::Resource.from_data_hash(PSON.parse(Puppet::Resource.new("File", "/foo").to_pson)).title.should == "/foo"
     end
 
     it "should include all tags from the resource" do
       resource = Puppet::Resource.new("File", "/foo")
       resource.tag("yay")
 
-      Puppet::Resource.from_pson(PSON.parse(resource.to_pson)).tags.should == resource.tags
+      Puppet::Resource.from_data_hash(PSON.parse(resource.to_pson)).tags.should == resource.tags
     end
 
     it "should include the file if one is set" do
       resource = Puppet::Resource.new("File", "/foo")
       resource.file = "/my/file"
 
-      Puppet::Resource.from_pson(PSON.parse(resource.to_pson)).file.should == "/my/file"
+      Puppet::Resource.from_data_hash(PSON.parse(resource.to_pson)).file.should == "/my/file"
     end
 
     it "should include the line if one is set" do
       resource = Puppet::Resource.new("File", "/foo")
       resource.line = 50
 
-      Puppet::Resource.from_pson(PSON.parse(resource.to_pson)).line.should == 50
+      Puppet::Resource.from_data_hash(PSON.parse(resource.to_pson)).line.should == 50
     end
 
     it "should include the 'exported' value if one is set" do
       resource = Puppet::Resource.new("File", "/foo")
       resource.exported = true
 
-      Puppet::Resource.from_pson(PSON.parse(resource.to_pson)).exported?.should be_true
+      Puppet::Resource.from_data_hash(PSON.parse(resource.to_pson)).exported?.should be_true
     end
 
     it "should set 'exported' to false if no value is set" do
       resource = Puppet::Resource.new("File", "/foo")
 
-      Puppet::Resource.from_pson(PSON.parse(resource.to_pson)).exported?.should be_false
+      Puppet::Resource.from_data_hash(PSON.parse(resource.to_pson)).exported?.should be_false
     end
 
     it "should set all of its parameters as the 'parameters' entry" do
@@ -756,7 +717,7 @@ describe Puppet::Resource do
       resource[:foo] = %w{bar eh}
       resource[:fee] = %w{baz}
 
-      result = Puppet::Resource.from_pson(PSON.parse(resource.to_pson))
+      result = Puppet::Resource.from_data_hash(PSON.parse(resource.to_pson))
       result["foo"].should == %w{bar eh}
       result["fee"].should == %w{baz}
     end
@@ -764,14 +725,14 @@ describe Puppet::Resource do
     it "should serialize relationships as reference strings" do
       resource = Puppet::Resource.new("File", "/foo")
       resource[:requires] = Puppet::Resource.new("File", "/bar")
-      result = Puppet::Resource.from_pson(PSON.parse(resource.to_pson))
+      result = Puppet::Resource.from_data_hash(PSON.parse(resource.to_pson))
       result[:requires].should == "File[/bar]"
     end
 
     it "should serialize multiple relationships as arrays of reference strings" do
       resource = Puppet::Resource.new("File", "/foo")
       resource[:requires] = [Puppet::Resource.new("File", "/bar"), Puppet::Resource.new("File", "/baz")]
-      result = Puppet::Resource.from_pson(PSON.parse(resource.to_pson))
+      result = Puppet::Resource.from_data_hash(PSON.parse(resource.to_pson))
       result[:requires].should == [ "File[/bar]",  "File[/baz]" ]
     end
   end
@@ -789,64 +750,64 @@ describe Puppet::Resource do
     end
 
     it "should set its type to the provided type" do
-      Puppet::Resource.from_pson(@data).type.should == "File"
+      Puppet::Resource.from_data_hash(@data).type.should == "File"
     end
 
     it "should set its title to the provided title" do
-      Puppet::Resource.from_pson(@data).title.should == basepath+"/yay"
+      Puppet::Resource.from_data_hash(@data).title.should == basepath+"/yay"
     end
 
     it "should tag the resource with any provided tags" do
       @data['tags'] = %w{foo bar}
-      resource = Puppet::Resource.from_pson(@data)
+      resource = Puppet::Resource.from_data_hash(@data)
       resource.tags.should be_include("foo")
       resource.tags.should be_include("bar")
     end
 
     it "should set its file to the provided file" do
       @data['file'] = "/foo/bar"
-      Puppet::Resource.from_pson(@data).file.should == "/foo/bar"
+      Puppet::Resource.from_data_hash(@data).file.should == "/foo/bar"
     end
 
     it "should set its line to the provided line" do
       @data['line'] = 50
-      Puppet::Resource.from_pson(@data).line.should == 50
+      Puppet::Resource.from_data_hash(@data).line.should == 50
     end
 
     it "should 'exported' to true if set in the pson data" do
       @data['exported'] = true
-      Puppet::Resource.from_pson(@data).exported.should be_true
+      Puppet::Resource.from_data_hash(@data).exported.should be_true
     end
 
     it "should 'exported' to false if not set in the pson data" do
-      Puppet::Resource.from_pson(@data).exported.should be_false
+      Puppet::Resource.from_data_hash(@data).exported.should be_false
     end
 
     it "should fail if no title is provided" do
       @data.delete('title')
-      expect { Puppet::Resource.from_pson(@data) }.to raise_error(ArgumentError)
+      expect { Puppet::Resource.from_data_hash(@data) }.to raise_error(ArgumentError)
     end
 
     it "should fail if no type is provided" do
       @data.delete('type')
-      expect { Puppet::Resource.from_pson(@data) }.to raise_error(ArgumentError)
+      expect { Puppet::Resource.from_data_hash(@data) }.to raise_error(ArgumentError)
     end
 
     it "should set each of the provided parameters" do
       @data['parameters'] = {'foo' => %w{one two}, 'fee' => %w{three four}}
-      resource = Puppet::Resource.from_pson(@data)
+      resource = Puppet::Resource.from_data_hash(@data)
       resource['foo'].should == %w{one two}
       resource['fee'].should == %w{three four}
     end
 
     it "should convert single-value array parameters to normal values" do
       @data['parameters'] = {'foo' => %w{one}}
-      resource = Puppet::Resource.from_pson(@data)
+      resource = Puppet::Resource.from_data_hash(@data)
       resource['foo'].should == %w{one}
     end
   end
 
-  describe "it should implement copy_as_resource" do
+  it "implements copy_as_resource" do
     resource = Puppet::Resource.new("file", "/my/file")
     resource.copy_as_resource.should == resource
   end

data/spec/unit/run_spec.rb

@@ -121,14 +121,14 @@ describe Puppet::Run do
     end
   end
 
-  describe ".from_pson" do
+  describe ".from_data_hash" do
     it "should read from a hash that represents the 'options' to initialize" do
       options = {
         "tags" => "whatever",
         "background" => true,
         "ignoreschedules" => false,
       }
-      run = Puppet::Run.from_pson(options)
+      run = Puppet::Run.from_data_hash(options)
 
       run.options.should == {
         :tags => "whatever",
@@ -145,7 +145,7 @@ describe Puppet::Run do
                 "tags" => [],
                 "ignoreschedules" => false},
               "status" => "success"}
-      run = Puppet::Run.from_pson(hash)
+      run = Puppet::Run.from_data_hash(hash)
 
       run.options.should == {
         :pluginsync => true,

data/spec/unit/settings/autosign_setting_spec.rb

@@ -74,7 +74,7 @@ describe Puppet::Settings::AutosignSetting do
     it "converts the file path to a file resource" do
       path = File.expand_path('/path/to/autosign.conf')
       settings.stubs(:value).with('autosign').returns(path)
-      Puppet::FileSystem::File.stubs(:exist?).with(path).returns true
+      Puppet::FileSystem.stubs(:exist?).with(path).returns true
       Puppet.stubs(:features).returns(stub(:root? => true, :microsoft_windows? => false))
 
       setting.mode = '0664'

data/spec/unit/settings/config_file_spec.rb

@@ -20,8 +20,15 @@ describe Puppet::Settings::ConfigFile do
 
   let(:filename) { "a/fake/filename.conf" }
 
+  Conf = Puppet::Settings::ConfigFile::Conf
+  Section = Puppet::Settings::ConfigFile::Section
+  Meta = Puppet::Settings::ConfigFile::Meta
+  NO_META = Puppet::Settings::ConfigFile::NO_META
+
   it "interprets an empty file to contain a main section with no entries" do
-    the_parse_of("").should == { :main => section_containing(NOTHING) }
+    result = the_parse_of("")
+
+    expect(result).to eq(Conf.new.with_section(Section.new(:main)))
   end
 
   it "interprets an empty main section the same as an empty file" do
@@ -29,39 +36,71 @@ describe Puppet::Settings::ConfigFile do
   end
 
   it "places an entry in no section in main" do
-    the_parse_of("var = value").should == { :main => section_containing(:var => "value") }
+    result = the_parse_of("var = value")
+
+    expect(result).to eq(Conf.new.with_section(Section.new(:main).with_setting(:var, "value", NO_META)))
   end
 
   it "places an entry after a section header in that section" do
-    the_parse_of("[section]", "var = value").should == { :main => section_containing(NOTHING),
-                                                       :section => section_containing(:var => "value") }
+    result = the_parse_of("[section]", "var = value")
+
+    expect(result).to eq(Conf.new.
+                         with_section(Section.new(:main)).
+                         with_section(Section.new(:section).
+                                      with_setting(:var, "value", NO_META)))
   end
 
   it "does not include trailing whitespace in the value" do
-    the_parse_of("var = value\t ").should == { :main => section_containing(:var => "value") }
+    result = the_parse_of("var = value\t ")
+
+    expect(result).to eq(Conf.new.
+                         with_section(Section.new(:main).
+                                      with_setting(:var, "value", NO_META)))
   end
 
   it "does not include leading whitespace in the name" do
-    the_parse_of("  \t var=value").should == { :main => section_containing(:var => "value") }
+    result = the_parse_of("  \t var=value")
+
+    expect(result).to eq(Conf.new.
+                         with_section(Section.new(:main).
+                                      with_setting(:var, "value", NO_META)))
   end
 
   it "skips lines that are commented out" do
-    the_parse_of("#var = value").should == { :main => section_containing(NOTHING) }
+    result = the_parse_of("#var = value")
+
+    expect(result).to eq(Conf.new.with_section(Section.new(:main)))
   end
 
   it "skips lines that are entirely whitespace" do
-    the_parse_of("   \t ").should == { :main => section_containing(NOTHING) }
+    result = the_parse_of("   \t ")
+
+    expect(result).to eq(Conf.new.with_section(Section.new(:main)))
   end
 
   it "errors when a line is not a known form" do
     expect { the_parse_of("unknown") }.to raise_error Puppet::Settings::ParseError, /Could not match line/
   end
 
+  it "errors providing correct line number when line is not a known form" do
+    multi_line_config = <<-EOF
+[main]
+foo=bar
+badline
+    EOF
+    expect { the_parse_of(multi_line_config) }.to(
+        raise_error(Puppet::Settings::ParseError, /Could not match line/) do |exception|
+          expect(exception.line).to eq(3)
+        end
+      )
+  end
+
   it "stores file meta information in the _meta section" do
-    the_parse_of("var = value { owner = me, group = you, mode = 0666 }").should ==
-      { :main => section_containing(:var => "value", :meta => { :var => { :owner => "me",
-                                                                          :group => "you",
-                                                                          :mode => "0666" } }) }
+    result = the_parse_of("var = value { owner = me, group = you, mode = 0666 }")
+
+    expect(result).to eq(Conf.new.with_section(Section.new(:main).
+                                               with_setting(:var, "value",
+                                                            Meta.new("me", "you", "0666"))))
   end
 
   it "errors when there is unknown meta information" do
@@ -82,19 +121,33 @@ describe Puppet::Settings::ConfigFile do
   it "errors when an application_defaults section is created" do
     expect { the_parse_of("[application_defaults]") }.
       to raise_error Puppet::Error,
-        "Illegal section 'application_defaults' in config file #{filename} at line [application_defaults]"
+        "Illegal section 'application_defaults' in config file #{filename} at line 1"
+  end
+
+  it "errors when a global_defaults section is created" do
+    expect { the_parse_of("[main]\n[global_defaults]") }.
+      to raise_error Puppet::Error,
+        "Illegal section 'global_defaults' in config file #{filename} at line 2"
   end
 
   it "transforms values with the given function" do
     config = Puppet::Settings::ConfigFile.new(Proc.new { |value| value + " changed" })
 
-    config.parse_file(filename, "var = value").should == { :main => section_containing(:var => "value changed") }
+    result = config.parse_file(filename, "var = value")
+
+    expect(result).to eq(Conf.new.
+                            with_section(Section.new(:main).
+                                         with_setting(:var, "value changed", NO_META)))
   end
 
   it "does not try to transform an entry named 'mode'" do
     config = Puppet::Settings::ConfigFile.new(Proc.new { raise "Should not transform" })
 
-    config.parse_file(filename, "mode = value").should == { :main => section_containing(:mode => "value") }
+    result = config.parse_file(filename, "mode = value")
+
+    expect(result).to eq(Conf.new.
+                            with_section(Section.new(:main).
+                                         with_setting(:mode, "value", NO_META)))
   end
 end