puppet 4.10.12 → 5.0.0

data/spec/unit/resource/status_spec.rb

@@ -6,67 +6,68 @@ require 'puppet/resource/status'
 describe Puppet::Resource::Status do
   include PuppetSpec::Files
 
+  let(:resource) { Puppet::Type.type(:file).new(:path => make_absolute("/my/file")) }
+  let(:containment_path) { ["foo", "bar", "baz"] }
+  let(:status) { Puppet::Resource::Status.new(resource) }
+
   before do
-    @resource = Puppet::Type.type(:file).new :path => make_absolute("/my/file")
-    @containment_path = ["foo", "bar", "baz"]
-    @resource.stubs(:pathbuilder).returns @containment_path
-    @status = Puppet::Resource::Status.new(@resource)
+    resource.stubs(:pathbuilder).returns(containment_path)
   end
 
   it "should compute type and title correctly" do
-    expect(@status.resource_type).to eq("File")
-    expect(@status.title).to eq(make_absolute("/my/file"))
+    expect(status.resource_type).to eq("File")
+    expect(status.title).to eq(make_absolute("/my/file"))
   end
 
   [:file, :line, :evaluation_time].each do |attr|
     it "should support #{attr}" do
-      @status.send(attr.to_s + "=", "foo")
-      expect(@status.send(attr)).to eq("foo")
+      status.send(attr.to_s + "=", "foo")
+      expect(status.send(attr)).to eq("foo")
     end
   end
 
   [:skipped, :failed, :restarted, :failed_to_restart, :changed, :out_of_sync, :scheduled].each do |attr|
     it "should support #{attr}" do
-      @status.send(attr.to_s + "=", "foo")
-      expect(@status.send(attr)).to eq("foo")
+      status.send(attr.to_s + "=", "foo")
+      expect(status.send(attr)).to eq("foo")
     end
 
     it "should have a boolean method for determining whehter it was #{attr}" do
-      @status.send(attr.to_s + "=", "foo")
-      expect(@status).to send("be_#{attr}")
+      status.send(attr.to_s + "=", "foo")
+      expect(status).to send("be_#{attr}")
     end
   end
 
   it "should accept a resource at initialization" do
-    expect(Puppet::Resource::Status.new(@resource).resource).not_to be_nil
+    expect(Puppet::Resource::Status.new(resource).resource).not_to be_nil
   end
 
   it "should set its source description to the resource's path" do
-    @resource.expects(:path).returns "/my/path"
-    expect(Puppet::Resource::Status.new(@resource).source_description).to eq("/my/path")
+    resource.expects(:path).returns "/my/path"
+    expect(Puppet::Resource::Status.new(resource).source_description).to eq("/my/path")
   end
 
   it "should set its containment path" do
-    expect(Puppet::Resource::Status.new(@resource).containment_path).to eq(@containment_path)
+  expect(Puppet::Resource::Status.new(resource).containment_path).to eq(containment_path)
   end
 
   [:file, :line].each do |attr|
     it "should copy the resource's #{attr}" do
-      @resource.expects(attr).returns "foo"
-      expect(Puppet::Resource::Status.new(@resource).send(attr)).to eq("foo")
+      resource.expects(attr).returns "foo"
+      expect(Puppet::Resource::Status.new(resource).send(attr)).to eq("foo")
     end
   end
 
   it "should copy the resource's tags" do
-    @resource.expects(:tags).returns %w{foo bar}
-    status = Puppet::Resource::Status.new(@resource)
+    resource.expects(:tags).returns %w{foo bar}
+    status = Puppet::Resource::Status.new(resource)
     expect(status).to be_tagged("foo")
     expect(status).to be_tagged("bar")
   end
 
   it "should always convert the resource to a string" do
-    @resource.expects(:to_s).returns "foo"
-    expect(Puppet::Resource::Status.new(@resource).resource).to eq("foo")
+    resource.expects(:to_s).returns "foo"
+    expect(Puppet::Resource::Status.new(resource).resource).to eq("foo")
   end
 
   it "should support tags" do
@@ -74,121 +75,131 @@ describe Puppet::Resource::Status do
   end
 
   it "should create a timestamp at its creation time" do
-    expect(@status.time).to be_instance_of(Time)
+    expect(status.time).to be_instance_of(Time)
   end
 
   it "should support adding events" do
     event = Puppet::Transaction::Event.new(:name => :foobar)
-    @status.add_event(event)
-    expect(@status.events).to eq([event])
+    status.add_event(event)
+    expect(status.events).to eq([event])
   end
 
   it "should use '<<' to add events" do
     event = Puppet::Transaction::Event.new(:name => :foobar)
-    expect(@status << event).to equal(@status)
-    expect(@status.events).to eq([event])
+    expect(status << event).to equal(status)
+    expect(status.events).to eq([event])
   end
 
-  it "records an event for a failure caused by an error" do
-    @status.failed_because(StandardError.new("the message"))
+  it "fails and records a failure event with a given message" do
+    status.fail_with_event("foo fail")
+    event = status.events[0]
 
-    expect(@status.events[0].message).to eq("the message")
-    expect(@status.events[0].status).to eq("failure")
-    expect(@status.events[0].name).to eq(:resource_error)
+    expect(event.message).to eq("foo fail")
+    expect(event.status).to eq("failure")
+    expect(event.name).to eq(:resource_error)
+    expect(status.failed?).to be_truthy
+  end
+
+  it "fails and records a failure event with a given exception" do
+    error = StandardError.new("the message")
+    resource.expects(:log_exception).with(error, "Could not evaluate: the message")
+    status.expects(:fail_with_event).with("the message")
+
+    status.failed_because(error)
   end
 
   it "should count the number of successful events and set changed" do
-    3.times{ @status << Puppet::Transaction::Event.new(:status => 'success') }
-    expect(@status.change_count).to eq(3)
+    3.times{ status << Puppet::Transaction::Event.new(:status => 'success') }
+    expect(status.change_count).to eq(3)
 
-    expect(@status.changed).to eq(true)
-    expect(@status.out_of_sync).to eq(true)
+    expect(status.changed).to eq(true)
+    expect(status.out_of_sync).to eq(true)
   end
 
   it "should not start with any changes" do
-    expect(@status.change_count).to eq(0)
+    expect(status.change_count).to eq(0)
 
-    expect(@status.changed).to eq(false)
-    expect(@status.out_of_sync).to eq(false)
+    expect(status.changed).to eq(false)
+    expect(status.out_of_sync).to eq(false)
   end
 
   it "should not treat failure, audit, or noop events as changed" do
-    ['failure', 'audit', 'noop'].each do |s| @status << Puppet::Transaction::Event.new(:status => s) end
-    expect(@status.change_count).to eq(0)
-    expect(@status.changed).to eq(false)
+    ['failure', 'audit', 'noop'].each do |s| status << Puppet::Transaction::Event.new(:status => s) end
+    expect(status.change_count).to eq(0)
+    expect(status.changed).to eq(false)
   end
 
   it "should not treat audit events as out of sync" do
-    @status << Puppet::Transaction::Event.new(:status => 'audit')
-    expect(@status.out_of_sync_count).to eq(0)
-    expect(@status.out_of_sync).to eq(false)
+    status << Puppet::Transaction::Event.new(:status => 'audit')
+    expect(status.out_of_sync_count).to eq(0)
+    expect(status.out_of_sync).to eq(false)
   end
 
   ['failure', 'noop', 'success'].each do |event_status|
     it "should treat #{event_status} events as out of sync" do
-      3.times do @status << Puppet::Transaction::Event.new(:status => event_status) end
-      expect(@status.out_of_sync_count).to eq(3)
-      expect(@status.out_of_sync).to eq(true)
+      3.times do status << Puppet::Transaction::Event.new(:status => event_status) end
+      expect(status.out_of_sync_count).to eq(3)
+      expect(status.out_of_sync).to eq(true)
     end
   end
 
-  describe "When converting to YAML" do
-    it "should include only documented attributes" do
-      @status.file = "/foo.rb"
-      @status.line = 27
-      @status.evaluation_time = 2.7
-      @status.tags = %w{one two}
-      expect(@status.to_yaml_properties).to match_array(Puppet::Resource::Status::YAML_ATTRIBUTES)
+  context 'when serializing' do
+    let(:status) do
+      s = Puppet::Resource::Status.new(resource)
+      s.file = "/foo.rb"
+      s.line = 27
+      s.evaluation_time = 2.7
+      s.tags = %w{one two}
+      s << Puppet::Transaction::Event.new(:name => :mode_changed, :status => 'audit')
+      s.failed = false
+      s.changed = true
+      s.out_of_sync = true
+      s.skipped = false
+      s
+    end
+
+    it "should round trip through json" do
+      expect(status.containment_path).to eq(containment_path)
+
+      tripped = Puppet::Resource::Status.from_data_hash(JSON.parse(status.to_json))
+
+      expect(tripped.title).to eq(status.title)
+      expect(tripped.containment_path).to eq(status.containment_path)
+      expect(tripped.file).to eq(status.file)
+      expect(tripped.line).to eq(status.line)
+      expect(tripped.resource).to eq(status.resource)
+      expect(tripped.resource_type).to eq(status.resource_type)
+      expect(tripped.evaluation_time).to eq(status.evaluation_time)
+      expect(tripped.tags).to eq(status.tags)
+      expect(tripped.time).to eq(status.time)
+      expect(tripped.failed).to eq(status.failed)
+      expect(tripped.changed).to eq(status.changed)
+      expect(tripped.out_of_sync).to eq(status.out_of_sync)
+      expect(tripped.skipped).to eq(status.skipped)
+
+      expect(tripped.change_count).to eq(status.change_count)
+      expect(tripped.out_of_sync_count).to eq(status.out_of_sync_count)
+      expect(events_as_hashes(tripped)).to eq(events_as_hashes(status))
+    end
+
+    it 'to_data_hash returns value that is instance of to Data' do
+      expect(Puppet::Pops::Types::TypeFactory.data.instance?(status.to_data_hash)).to be_truthy
     end
-  end
 
-  it "should round trip through pson" do
-    @status.file = "/foo.rb"
-    @status.line = 27
-    @status.evaluation_time = 2.7
-    @status.tags = %w{one two}
-    @status << Puppet::Transaction::Event.new(:name => :mode_changed, :status => 'audit')
-    @status.failed = false
-    @status.changed = true
-    @status.out_of_sync = true
-    @status.skipped = false
-
-    expect(@status.containment_path).to eq(@containment_path)
-
-    tripped = Puppet::Resource::Status.from_data_hash(PSON.parse(@status.to_pson))
-
-    expect(tripped.title).to eq(@status.title)
-    expect(tripped.containment_path).to eq(@status.containment_path)
-    expect(tripped.file).to eq(@status.file)
-    expect(tripped.line).to eq(@status.line)
-    expect(tripped.resource).to eq(@status.resource)
-    expect(tripped.resource_type).to eq(@status.resource_type)
-    expect(tripped.evaluation_time).to eq(@status.evaluation_time)
-    expect(tripped.tags).to eq(@status.tags)
-    expect(tripped.time).to eq(@status.time)
-    expect(tripped.failed).to eq(@status.failed)
-    expect(tripped.changed).to eq(@status.changed)
-    expect(tripped.out_of_sync).to eq(@status.out_of_sync)
-    expect(tripped.skipped).to eq(@status.skipped)
-
-    expect(tripped.change_count).to eq(@status.change_count)
-    expect(tripped.out_of_sync_count).to eq(@status.out_of_sync_count)
-    expect(events_as_hashes(tripped)).to eq(events_as_hashes(@status))
-  end
-
-  def events_as_hashes(report)
-    report.events.collect do |e|
-      {
-        :audited => e.audited,
-        :property => e.property,
-        :previous_value => e.previous_value,
-        :desired_value => e.desired_value,
-        :historical_value => e.historical_value,
-        :message => e.message,
-        :name => e.name,
-        :status => e.status,
-        :time => e.time,
-      }
+    def events_as_hashes(report)
+      report.events.collect do |e|
+        {
+          :audited => e.audited,
+          :property => e.property,
+          :previous_value => e.previous_value,
+          :desired_value => e.desired_value,
+          :historical_value => e.historical_value,
+          :message => e.message,
+          :name => e.name,
+          :status => e.status,
+          :time => e.time,
+        }
+      end
     end
   end
 end

data/spec/unit/resource/type_collection_spec.rb

@@ -51,14 +51,14 @@ describe Puppet::Resource::TypeCollection do
     expect(@code.hostclass("foo")).to equal(klass)
   end
 
-  it "merge together hostclasses of the same name" do
+  it "errors if an attempt is made to merge hostclasses of the same name" do
     klass1 = Puppet::Resource::Type.new(:hostclass, "foo", :doc => "first")
     klass2 = Puppet::Resource::Type.new(:hostclass, "foo", :doc => "second")
 
-    @code.add(klass1)
-    @code.add(klass2)
-
-    expect(@code.hostclass("foo").doc).to eq("firstsecond")
+    expect {
+      @code.add(klass1)
+      @code.add(klass2)
+    }.to raise_error(/.*is already defined; cannot redefine/)
   end
 
   it "should store definitions as definitions" do

data/spec/unit/resource/type_spec.rb

@@ -25,73 +25,6 @@ describe Puppet::Resource::Type do
     end
   end
 
-  it "should indirect 'resource_type'" do
-    expect(Puppet::Resource::Type.indirection.name).to eq(:resource_type)
-  end
-
-  it "should default to 'parser' for its terminus class" do
-    expect(Puppet::Resource::Type.indirection.terminus_class).to eq(:parser)
-  end
-
-  describe "when converting to json" do
-    before do
-      @type = Puppet::Resource::Type.new(:hostclass, "foo")
-    end
-
-    def from_json(json)
-      Puppet::Resource::Type.from_data_hash(json)
-    end
-
-    def double_convert
-      Puppet::Resource::Type.from_data_hash(PSON.parse(@type.to_pson))
-    end
-
-    it "should include the name and type" do
-      expect(double_convert.name).to eq(@type.name)
-      expect(double_convert.type).to eq(@type.type)
-    end
-
-    it "should validate with only name and kind" do
-      expect(@type.to_pson).to validate_against('api/schemas/resource_type.json')
-    end
-
-    it "should validate with all fields set" do
-      @type.set_arguments("one" => nil, "two" => "foo")
-      @type.line = 100
-      @type.doc = "A weird type"
-      @type.file = "/etc/manifests/thing.pp"
-      @type.parent = "one::two"
-
-      expect(@type.to_pson).to validate_against('api/schemas/resource_type.json')
-    end
-
-    it "should include any arguments" do
-      @type.set_arguments("one" => nil, "two" => "foo")
-
-      expect(double_convert.arguments).to eq({"one" => nil, "two" => "foo"})
-    end
-
-    it "should not include arguments if none are present" do
-      expect(@type.to_pson["arguments"]).to be_nil
-    end
-
-    [:line, :doc, :file, :parent].each do |attr|
-      it "should include #{attr} when set" do
-        @type.send(attr.to_s + "=", "value")
-        expect(double_convert.send(attr)).to eq("value")
-      end
-
-      it "should not include #{attr} when not set" do
-        expect(@type.to_pson[attr.to_s]).to be_nil
-      end
-    end
-
-    it "should not include docs if they are empty" do
-      @type.doc = ""
-      expect(@type.to_pson["doc"]).to be_nil
-    end
-  end
-
   describe "when a node"  do
     it "should allow a regex as its name" do
       expect { Puppet::Resource::Type.new(:node, /foo/) }.not_to raise_error
@@ -243,7 +176,7 @@ describe Puppet::Resource::Type do
     let(:parser) { Puppet::Pops::Parser::Parser.new() }
 
     def wrap3x(expression)
-      Puppet::Parser::AST::PopsBridge::Expression.new(:value => expression.current)
+      Puppet::Parser::AST::PopsBridge::Expression.new(:value => expression.model)
     end
 
     def parse_expression(expr_string)
@@ -589,7 +522,7 @@ describe Puppet::Resource::Type do
       @type.stubs(:code).returns code
 
       subscope = stub 'subscope', :compiler => @compiler
-      @scope.expects(:newscope).with(:source => @type, :namespace => '', :resource => @resource).returns subscope
+      @scope.expects(:newscope).with(:source => @type, :resource => @resource).returns subscope
 
       elevel = 876
       subscope.expects(:with_guarded_scope).yields
@@ -615,7 +548,7 @@ describe Puppet::Resource::Type do
 
     it "should set all of its parameters in a subscope" do
       subscope = stub 'subscope', :compiler => @compiler
-      @scope.expects(:newscope).with(:source => @type, :namespace => 'foo', :resource => @resource).returns subscope
+      @scope.expects(:newscope).with(:source => @type, :resource => @resource).returns subscope
       @type.expects(:set_resource_parameters).with(@resource, subscope)
 
       @type.evaluate_code(@resource)
@@ -903,7 +836,7 @@ describe Puppet::Resource::Type do
 
     it "should set the other class's code as its code if it has none" do
       dest = Puppet::Resource::Type.new(:hostclass, "bar")
-      source = Puppet::Resource::Type.new(:hostclass, "foo", :code => code("bar"))
+      source = Puppet::Resource::Type.new(:hostclass, "foo", :code => code("bar").model)
 
       dest.merge(source)
 

data/spec/unit/resource_spec.rb

@@ -399,11 +399,6 @@ describe Puppet::Resource do
             inject_and_set_defaults(resource, scope)
           end
 
-          it "should not query the injector" do
-            compiler.injector.expects(:find).never
-            inject_and_set_defaults(resource, scope)
-          end
-
           it "should use the value provided" do
             Puppet::DataBinding.indirection.expects(:find).never
             expect(resource.set_default_parameters(scope)).to eq([])
@@ -653,11 +648,11 @@ describe Puppet::Resource do
       expect(newresource).to equal_resource_attributes_of(@resource)
     end
 
-    # PUP-3272, since serialization to network is done in pson, not yaml
-    it "should produce an equivalent pson object" do
-      text = @resource.render('pson')
+    # PUP-3272, since serialization to network is done in json, not yaml
+    it "should produce an equivalent json object" do
+      text = @resource.render('json')
 
-      newresource = Puppet::Resource.convert_from('pson', text)
+      newresource = Puppet::Resource.convert_from('json', text)
       expect(newresource).to equal_resource_attributes_of(@resource)
     end
   end
@@ -674,15 +669,20 @@ describe Puppet::Resource do
     end
 
     it "doesn't include transient instance variables (#4506)" do
-      expect(@resource.to_yaml_properties).to_not include(:@rstype)
+      expect(@resource.to_data_hash.keys).to_not include('rstype')
     end
 
-    it "produces an equivalent pson object" do
-      text = @resource.render('pson')
+    it "produces an equivalent json object" do
+      text = @resource.render('json')
 
-      newresource = Puppet::Resource.convert_from('pson', text)
+      newresource = Puppet::Resource.convert_from('json', text)
       expect(newresource).to equal_resource_attributes_of(@resource)
     end
+
+    it 'to_data_hash returns value that is instance of to Data' do
+      Puppet::Pops::Types::TypeAsserter.assert_instance_of('', Puppet::Pops::Types::TypeFactory.data, @resource.to_data_hash)
+      expect(Puppet::Pops::Types::TypeFactory.data.instance?(@resource.to_data_hash)).to be_truthy
+    end
   end
 
   describe "when converting to a RAL resource" do
@@ -732,7 +732,7 @@ describe Puppet::Resource do
         one::two { '/my/file':
           ensure => 'present',
           foo    => ['one', 'two'],
-          noop   => 'true',
+          noop   => true,
         }
       HEREDOC
     end
@@ -754,54 +754,54 @@ describe Puppet::Resource do
           /my/file:
             ensure: 'present'
             foo   : ['one', 'two']
-            noop  : 'true'
+            noop  : true
       HEREDOC
     end
   end
-  describe "when converting to pson" do
+  describe "when converting to json" do
     # LAK:NOTE For all of these tests, we convert back to the resource so we can
     # trap the actual data structure then.
 
     it "should set its type to the provided type" do
-      expect(Puppet::Resource.from_data_hash(PSON.parse(Puppet::Resource.new("File", "/foo").to_pson)).type).to eq("File")
+      expect(Puppet::Resource.from_data_hash(JSON.parse(Puppet::Resource.new("File", "/foo").to_json)).type).to eq("File")
     end
 
     it "should set its title to the provided title" do
-      expect(Puppet::Resource.from_data_hash(PSON.parse(Puppet::Resource.new("File", "/foo").to_pson)).title).to eq("/foo")
+      expect(Puppet::Resource.from_data_hash(JSON.parse(Puppet::Resource.new("File", "/foo").to_json)).title).to eq("/foo")
     end
 
     it "should include all tags from the resource" do
       resource = Puppet::Resource.new("File", "/foo")
       resource.tag("yay")
 
-      expect(Puppet::Resource.from_data_hash(PSON.parse(resource.to_pson)).tags).to eq(resource.tags)
+      expect(Puppet::Resource.from_data_hash(JSON.parse(resource.to_json)).tags).to eq(resource.tags)
     end
 
     it "should include the file if one is set" do
       resource = Puppet::Resource.new("File", "/foo")
       resource.file = "/my/file"
 
-      expect(Puppet::Resource.from_data_hash(PSON.parse(resource.to_pson)).file).to eq("/my/file")
+      expect(Puppet::Resource.from_data_hash(JSON.parse(resource.to_json)).file).to eq("/my/file")
     end
 
     it "should include the line if one is set" do
       resource = Puppet::Resource.new("File", "/foo")
       resource.line = 50
 
-      expect(Puppet::Resource.from_data_hash(PSON.parse(resource.to_pson)).line).to eq(50)
+      expect(Puppet::Resource.from_data_hash(JSON.parse(resource.to_json)).line).to eq(50)
     end
 
     it "should include the 'exported' value if one is set" do
       resource = Puppet::Resource.new("File", "/foo")
       resource.exported = true
 
-      expect(Puppet::Resource.from_data_hash(PSON.parse(resource.to_pson)).exported?).to be_truthy
+      expect(Puppet::Resource.from_data_hash(JSON.parse(resource.to_json)).exported?).to be_truthy
     end
 
     it "should set 'exported' to false if no value is set" do
       resource = Puppet::Resource.new("File", "/foo")
 
-      expect(Puppet::Resource.from_data_hash(PSON.parse(resource.to_pson)).exported?).to be_falsey
+      expect(Puppet::Resource.from_data_hash(JSON.parse(resource.to_json)).exported?).to be_falsey
     end
 
     it "should set all of its parameters as the 'parameters' entry" do
@@ -809,37 +809,33 @@ describe Puppet::Resource do
       resource[:foo] = %w{bar eh}
       resource[:fee] = %w{baz}
 
-      result = Puppet::Resource.from_data_hash(PSON.parse(resource.to_pson))
+      result = Puppet::Resource.from_data_hash(JSON.parse(resource.to_json))
       expect(result["foo"]).to eq(%w{bar eh})
       expect(result["fee"]).to eq(%w{baz})
     end
 
     it "should set sensitive parameters as an array of strings" do
       resource = Puppet::Resource.new("File", "/foo", :sensitive_parameters => [:foo, :fee])
-      result = PSON.parse(resource.to_pson)
+      result = JSON.parse(resource.to_json)
       expect(result["sensitive_parameters"]).to eq ["foo", "fee"]
     end
 
     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_data_hash(PSON.parse(resource.to_pson))
+      result = Puppet::Resource.from_data_hash(JSON.parse(resource.to_json))
       expect(result[:requires]).to eq("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_data_hash(PSON.parse(resource.to_pson))
+      result = Puppet::Resource.from_data_hash(JSON.parse(resource.to_json))
       expect(result[:requires]).to eq([ "File[/bar]",  "File[/baz]" ])
     end
   end
 
-  describe "when converting from pson" do
-    def pson_result_should
-      Puppet::Resource.expects(:new).with { |hash| yield hash }
-    end
-
+  describe "when converting from json" do
     before do
       @data = {
         'type' => "file",
@@ -872,12 +868,12 @@ describe Puppet::Resource do
       expect(Puppet::Resource.from_data_hash(@data).line).to eq(50)
     end
 
-    it "should 'exported' to true if set in the pson data" do
+    it "should 'exported' to true if set in the json data" do
       @data['exported'] = true
       expect(Puppet::Resource.from_data_hash(@data).exported).to be_truthy
     end
 
-    it "should 'exported' to false if not set in the pson data" do
+    it "should 'exported' to false if not set in the json data" do
       expect(Puppet::Resource.from_data_hash(@data).exported).to be_falsey
     end