puppet 0.25.0 → 0.25.1

data/spec/unit/relationship.rb

@@ -155,68 +155,43 @@ describe Puppet::Relationship, " when matching edges with a non-standard event"
     end
 end
 
-describe Puppet::Relationship, "when converting to json" do
-    confine "Missing 'json' library" => Puppet.features.json?
+describe Puppet::Relationship, "when converting to pson" do
+    confine "Missing 'pson' library" => Puppet.features.pson?
 
     before do
         @edge = Puppet::Relationship.new(:a, :b, :event => :random, :callback => :whatever)
     end
 
-    def json_output_should
-        @edge.class.expects(:json_create).with { |hash| yield hash }
-    end
-
-    # LAK:NOTE For all of these tests, we convert back to the edge so we can
-    # trap the actual data structure then.
-    it "should set the 'json_class' to Puppet::Relationship" do
-        json_output_should { |hash| hash['json_class'] == "Puppet::Relationship" }
-
-        JSON.parse @edge.to_json
-    end
-
     it "should store the stringified source as the source in the data" do
-        json_output_should { |hash| hash['data']['source'] == "a" }
-
-        JSON.parse @edge.to_json
+        PSON.parse(@edge.to_pson)["source"].should == "a"
     end
 
     it "should store the stringified target as the target in the data" do
-        json_output_should { |hash| hash['data']['target'] == "b" }
-
-        JSON.parse @edge.to_json
+        PSON.parse(@edge.to_pson)['target'].should == "b"
     end
 
-    it "should store the jsonified event as the event in the data" do
-        @edge.event = :random
-        json_output_should { |hash| hash['data']['event'] == "random" }
-
-        JSON.parse @edge.to_json
+    it "should store the psonified event as the event in the data" do
+        PSON.parse(@edge.to_pson)["event"].should == "random"
     end
 
     it "should not store an event when none is set" do
         @edge.event = nil
-        json_output_should { |hash| hash['data']['event'].nil? }
-
-        JSON.parse @edge.to_json
+        PSON.parse(@edge.to_pson)["event"].should be_nil
     end
 
-    it "should store the jsonified callback as the callback in the data" do
+    it "should store the psonified callback as the callback in the data" do
         @edge.callback = "whatever"
-        json_output_should { |hash| hash['data']['callback'] == "whatever" }
-
-        JSON.parse @edge.to_json
+        PSON.parse(@edge.to_pson)["callback"].should == "whatever"
     end
 
     it "should not store a callback when none is set in the edge" do
         @edge.callback = nil
-        json_output_should { |hash| hash['data']['callback'].nil? }
-
-        JSON.parse @edge.to_json
+        PSON.parse(@edge.to_pson)["callback"].should be_nil
     end
 end
 
-describe Puppet::Relationship, "when converting from json" do
-    confine "Missing 'json' library" => Puppet.features.json?
+describe Puppet::Relationship, "when converting from pson" do
+    confine "Missing 'pson' library" => Puppet.features.pson?
 
     before do
         @event = "random"
@@ -227,35 +202,35 @@ describe Puppet::Relationship, "when converting from json" do
             "event" => @event,
             "callback" => @callback
         }
-        @json = {
-            "json_class" => "Puppet::Relationship",
+        @pson = {
+            "type" => "Puppet::Relationship",
             "data" => @data
         }
     end
 
-    def json_result_should
+    def pson_result_should
         Puppet::Relationship.expects(:new).with { |*args| yield args }
     end
 
-    it "should be extended with the JSON utility module" do
-        Puppet::Relationship.metaclass.ancestors.should be_include(Puppet::Util::Json)
+    it "should be extended with the PSON utility module" do
+        Puppet::Relationship.metaclass.ancestors.should be_include(Puppet::Util::Pson)
     end
 
     # LAK:NOTE For all of these tests, we convert back to the edge so we can
     # trap the actual data structure then.
     it "should pass the source in as the first argument" do
-        Puppet::Relationship.from_json("source" => "mysource", "target" => "mytarget").source.should == "mysource"
+        Puppet::Relationship.from_pson("source" => "mysource", "target" => "mytarget").source.should == "mysource"
     end
 
     it "should pass the target in as the second argument" do
-        Puppet::Relationship.from_json("source" => "mysource", "target" => "mytarget").target.should == "mytarget"
+        Puppet::Relationship.from_pson("source" => "mysource", "target" => "mytarget").target.should == "mytarget"
     end
 
     it "should pass the event as an argument if it's provided" do
-        Puppet::Relationship.from_json("source" => "mysource", "target" => "mytarget", "event" => "myevent", "callback" => "eh").event.should == "myevent"
+        Puppet::Relationship.from_pson("source" => "mysource", "target" => "mytarget", "event" => "myevent", "callback" => "eh").event.should == "myevent"
     end
 
     it "should pass the callback as an argument if it's provided" do
-        Puppet::Relationship.from_json("source" => "mysource", "target" => "mytarget", "callback" => "mycallback").callback.should == "mycallback"
+        Puppet::Relationship.from_pson("source" => "mysource", "target" => "mytarget", "callback" => "mycallback").callback.should == "mycallback"
     end
 end

data/spec/unit/resource.rb

@@ -354,63 +354,60 @@ describe Puppet::Resource do
         end
     end
 
-    describe "when converting to json" do
-        confine "Missing 'json' library" => Puppet.features.json?
+    describe "when converting to pson" do
+        confine "Missing 'pson' library" => Puppet.features.pson?
 
-        def json_output_should
-            @resource.class.expects(:json_create).with { |hash| yield hash }
+        def pson_output_should
+            @resource.class.expects(:pson_create).with { |hash| yield hash }
         end
 
-        it "should include the json util module" do
-            Puppet::Resource.metaclass.ancestors.should be_include(Puppet::Util::Json)
+        it "should include the pson util module" do
+            Puppet::Resource.metaclass.ancestors.should be_include(Puppet::Util::Pson)
         end
 
         # 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 json_class to 'Puppet::Resource'" do
-            JSON.parse(Puppet::Resource.new("file", "yay").to_json).should be_instance_of(Puppet::Resource)
-        end
 
         it "should set its type to the provided type" do
-            JSON.parse(Puppet::Resource.new("File", "/foo").to_json).type.should == "File"
+            Puppet::Resource.from_pson(PSON.parse(Puppet::Resource.new("File", "/foo").to_pson)).type.should == "File"
         end
 
         it "should set its title to the provided title" do
-            JSON.parse(Puppet::Resource.new("File", "/foo").to_json).title.should == "/foo"
+            Puppet::Resource.from_pson(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")
 
-            JSON.parse(resource.to_json).tags.should == resource.tags
+            Puppet::Resource.from_pson(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"
 
-            JSON.parse(resource.to_json).file.should == "/my/file"
+            Puppet::Resource.from_pson(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
 
-            JSON.parse(resource.to_json).line.should == 50
+            Puppet::Resource.from_pson(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
 
-            JSON.parse(resource.to_json).exported.should be_true
+            Puppet::Resource.from_pson(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")
 
-            JSON.parse(resource.to_json).exported.should be_false
+            Puppet::Resource.from_pson(PSON.parse(resource.to_pson)).exported.should be_false
         end
 
         it "should set all of its parameters as the 'parameters' entry" do
@@ -418,22 +415,16 @@ describe Puppet::Resource do
             resource[:foo] = %w{bar eh}
             resource[:fee] = %w{baz}
 
-            result = JSON.parse(resource.to_json)
+            result = Puppet::Resource.from_pson(PSON.parse(resource.to_pson))
             result["foo"].should == %w{bar eh}
             result["fee"].should == %w{baz}
         end
-
-        it "should set all parameter values as arrays" do
-            resource = Puppet::Resource.new("File", "/foo")
-            resource[:foo] = "bar"
-            JSON.parse(resource.to_json)["foo"].should == %w{bar}
-        end
     end
 
-    describe "when converting from json" do
-        confine "Missing 'json' library" => Puppet.features.json?
+    describe "when converting from pson" do
+        confine "Missing 'pson' library" => Puppet.features.pson?
 
-        def json_result_should
+        def pson_result_should
             Puppet::Resource.expects(:new).with { |hash| yield hash }
         end
 
@@ -445,59 +436,59 @@ describe Puppet::Resource do
         end
 
         it "should set its type to the provided type" do
-            Puppet::Resource.from_json(@data).type.should == "File"
+            Puppet::Resource.from_pson(@data).type.should == "File"
         end
 
         it "should set its title to the provided title" do
-            Puppet::Resource.from_json(@data).title.should == "yay"
+            Puppet::Resource.from_pson(@data).title.should == "yay"
         end
 
         it "should tag the resource with any provided tags" do
             @data['tags'] = %w{foo bar}
-            resource = Puppet::Resource.from_json(@data)
+            resource = Puppet::Resource.from_pson(@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_json(@data).file.should == "/foo/bar"
+            Puppet::Resource.from_pson(@data).file.should == "/foo/bar"
         end
 
         it "should set its line to the provided line" do
             @data['line'] = 50
-            Puppet::Resource.from_json(@data).line.should == 50
+            Puppet::Resource.from_pson(@data).line.should == 50
         end
 
-        it "should 'exported' to true if set in the json data" do
+        it "should 'exported' to true if set in the pson data" do
             @data['exported'] = true
-            Puppet::Resource.from_json(@data).exported.should be_true
+            Puppet::Resource.from_pson(@data).exported.should be_true
         end
 
-        it "should 'exported' to false if not set in the json data" do
-            Puppet::Resource.from_json(@data).exported.should be_false
+        it "should 'exported' to false if not set in the pson data" do
+            Puppet::Resource.from_pson(@data).exported.should be_false
         end
 
         it "should fail if no title is provided" do
             @data.delete('title')
-            lambda { Puppet::Resource.from_json(@data) }.should raise_error(ArgumentError)
+            lambda { Puppet::Resource.from_pson(@data) }.should raise_error(ArgumentError)
         end
 
         it "should fail if no type is provided" do
             @data.delete('type')
-            lambda { Puppet::Resource.from_json(@data) }.should raise_error(ArgumentError)
+            lambda { Puppet::Resource.from_pson(@data) }.should 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_json(@data)
+            resource = Puppet::Resource.from_pson(@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_json(@data)
+            resource = Puppet::Resource.from_pson(@data)
             resource['foo'].should == %w{one}
         end
     end

data/spec/unit/resource/catalog.rb

@@ -35,6 +35,18 @@ describe Puppet::Resource::Catalog, "when compiling" do
         @catalog.write_class_file
     end
 
+    it "should have a client_version attribute" do
+        @catalog = Puppet::Resource::Catalog.new("host")
+        @catalog.client_version = 5
+        @catalog.client_version.should == 5
+    end
+
+    it "should have a server_version attribute" do
+        @catalog = Puppet::Resource::Catalog.new("host")
+        @catalog.server_version = 5
+        @catalog.server_version.should == 5
+    end
+
     describe "when compiling" do
         it "should accept tags" do
             config = Puppet::Resource::Catalog.new("mynode")
@@ -875,71 +887,70 @@ describe Puppet::Resource::Catalog, "when compiling" do
     end
 end
 
-describe Puppet::Resource::Catalog, "when converting to json" do
-    confine "Missing 'json' library" => Puppet.features.json?
+describe Puppet::Resource::Catalog, "when converting to pson" do
+    confine "Missing 'pson' library" => Puppet.features.pson?
 
     before do
         @catalog = Puppet::Resource::Catalog.new("myhost")
     end
 
-    def json_output_should
-        @catalog.class.expects(:json_create).with { |hash| yield hash }
+    def pson_output_should
+        @catalog.class.expects(:pson_create).with { |hash| yield hash }.returns(:something)
     end
 
     # 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 json_class to 'Puppet::Resource::Catalog'" do
-        json_output_should { |hash| hash['json_class'] == "Puppet::Resource::Catalog" }
+    it "should set its document_type to 'Catalog'" do
+        pson_output_should { |hash| hash['document_type'] == "Catalog" }
 
-        JSON.parse @catalog.to_json
+        PSON.parse @catalog.to_pson
     end
 
     it "should set its data as a hash" do
-        json_output_should { |hash| hash['data'].is_a?(Hash) }
-        JSON.parse @catalog.to_json
+        pson_output_should { |hash| hash['data'].is_a?(Hash) }
+        PSON.parse @catalog.to_pson
     end
 
-    [:name, :version, :tags].each do |param|
+    [:name, :version, :tags, :classes].each do |param|
         it "should set its #{param} to the #{param} of the resource" do
             @catalog.send(param.to_s + "=", "testing") unless @catalog.send(param)
 
-            json_output_should { |hash| hash['data'][param.to_s] == @catalog.send(param) }
-            JSON.parse @catalog.to_json
+            pson_output_should { |hash| hash['data'][param.to_s] == @catalog.send(param) }
+            PSON.parse @catalog.to_pson
         end
     end
 
-    it "should convert its resources to a JSON-encoded array and store it as the 'resources' data" do
-        one = stub 'one', :to_json => '"one_resource"', :ref => "Foo[one]"
-        two = stub 'two', :to_json => '"two_resource"', :ref => "Foo[two]"
+    it "should convert its resources to a PSON-encoded array and store it as the 'resources' data" do
+        one = stub 'one', :to_pson_data_hash => "one_resource", :ref => "Foo[one]"
+        two = stub 'two', :to_pson_data_hash => "two_resource", :ref => "Foo[two]"
 
         @catalog.add_resource(one)
         @catalog.add_resource(two)
 
         # TODO this should really guarantee sort order
-        json_output_should { |hash| JSON.parse(hash['data']['resources']).sort == ["one_resource", "two_resource"].sort }
-        JSON.parse @catalog.to_json
+        PSON.parse(@catalog.to_pson,:create_additions => false)['data']['resources'].sort.should == ["one_resource", "two_resource"].sort
+
     end
 
-    it "should convert its edges to a JSON-encoded array and store it as the 'edges' data" do
-        one = stub 'one', :to_json => '"one_resource"', :ref => 'Foo[one]'
-        two = stub 'two', :to_json => '"two_resource"', :ref => 'Foo[two]'
-        three = stub 'three', :to_json => '"three_resource"', :ref => 'Foo[three]'
+    it "should convert its edges to a PSON-encoded array and store it as the 'edges' data" do
+        one   = stub 'one',   :to_pson_data_hash => "one_resource",   :ref => 'Foo[one]'
+        two   = stub 'two',   :to_pson_data_hash => "two_resource",   :ref => 'Foo[two]'
+        three = stub 'three', :to_pson_data_hash => "three_resource", :ref => 'Foo[three]'
 
         @catalog.add_edge(one, two)
         @catalog.add_edge(two, three)
 
-        @catalog.edge(one, two).expects(:to_json).returns '"one_two_json"'
-        @catalog.edge(two, three).expects(:to_json).returns '"two_three_json"'
+        @catalog.edge(one, two  ).expects(:to_pson_data_hash).returns "one_two_pson"
+        @catalog.edge(two, three).expects(:to_pson_data_hash).returns "two_three_pson"
 
-        json_output_should { |hash| JSON.parse(hash['data']['edges']).sort == %w{one_two_json two_three_json}.sort }
-        JSON.parse @catalog.to_json
+        PSON.parse(@catalog.to_pson,:create_additions => false)['data']['edges'].sort.should == %w{one_two_pson two_three_pson}.sort
     end
 end
 
-describe Puppet::Resource::Catalog, "when converting from json" do
-    confine "Missing 'json' library" => Puppet.features.json?
+describe Puppet::Resource::Catalog, "when converting from pson" do
+    confine "Missing 'pson' library" => Puppet.features.pson?
 
-    def json_result_should
+    def pson_result_should
         Puppet::Resource::Catalog.expects(:new).with { |hash| yield hash }
     end
 
@@ -947,54 +958,58 @@ describe Puppet::Resource::Catalog, "when converting from json" do
         @data = {
             'name' => "myhost"
         }
-        @json = {
-            'json_class' => 'Puppet::Resource::Catalog',
-            'data' => @data
+        @pson = {
+            'document_type' => 'Puppet::Resource::Catalog',
+            'data' => @data,
+            'metadata' => {}
         }
 
         @catalog = Puppet::Resource::Catalog.new("myhost")
         Puppet::Resource::Catalog.stubs(:new).returns @catalog
     end
 
-    it "should be extended with the JSON utility module" do
-        Puppet::Resource::Catalog.metaclass.ancestors.should be_include(Puppet::Util::Json)
+    it "should be extended with the PSON utility module" do
+        Puppet::Resource::Catalog.metaclass.ancestors.should be_include(Puppet::Util::Pson)
     end
 
     it "should create it with the provided name" do
         Puppet::Resource::Catalog.expects(:new).with('myhost').returns @catalog
-        JSON.parse @json.to_json
+        PSON.parse @pson.to_pson
     end
 
     it "should set the provided version on the catalog if one is set" do
         @data['version'] = 50
-        @catalog.expects(:version=).with(@data['version'])
-
-        JSON.parse @json.to_json
+        PSON.parse @pson.to_pson
+        @catalog.version.should == @data['version']
     end
 
     it "should set any provided tags on the catalog" do
         @data['tags'] = %w{one two}
-        @catalog.expects(:tag).with("one", "two")
+        PSON.parse @pson.to_pson
+        @catalog.tags.should == @data['tags']
+    end
 
-        JSON.parse @json.to_json
+    it "should set any provided classes on the catalog" do
+        @data['classes'] = %w{one two}
+        PSON.parse @pson.to_pson
+        @catalog.classes.should == @data['classes']
     end
 
     it 'should convert the resources list into resources and add each of them' do
         @data['resources'] = [Puppet::Resource.new(:file, "/foo"), Puppet::Resource.new(:file, "/bar")]
 
         @catalog.expects(:add_resource).times(2).with { |res| res.type == "File" }
-
-        JSON.parse @json.to_json
+        PSON.parse @pson.to_pson
     end
 
-    it 'should convert resources even if they do not include "json_class" information' do
+    it 'should convert resources even if they do not include "type" information' do
         @data['resources'] = [Puppet::Resource.new(:file, "/foo")]
 
-        @data['resources'][0].expects(:to_json).returns "{\"title\":\"\\/foo\",\"tags\":[\"file\"],\"type\":\"File\"}"
+        @data['resources'][0].expects(:to_pson).returns '{"title":"/foo","tags":["file"],"type":"File"}'
 
         @catalog.expects(:add_resource).with { |res| res.type == "File" }
 
-        JSON.parse @json.to_json
+        PSON.parse @pson.to_pson
     end
 
     it 'should convert the edges list into edges and add each of them' do
@@ -1008,12 +1023,12 @@ describe Puppet::Resource::Catalog, "when converting from json" do
         @catalog.expects(:add_edge).with { |edge| edge.event == "one" }
         @catalog.expects(:add_edge).with { |edge| edge.event == "two" }
 
-        JSON.parse @json.to_json
+        PSON.parse @pson.to_pson
     end
 
-    it "should be able to convert relationships that do not include 'json_class' information" do
+    it "should be able to convert relationships that do not include 'type' information" do
         one = Puppet::Relationship.new("osource", "otarget", :event => "one", :callback => "refresh")
-        one.expects(:to_json).returns "{\"event\":\"one\",\"callback\":\"refresh\",\"source\":\"osource\",\"target\":\"otarget\"}"
+        one.expects(:to_pson).returns "{\"event\":\"one\",\"callback\":\"refresh\",\"source\":\"osource\",\"target\":\"otarget\"}"
 
         @data['edges'] = [one]
 
@@ -1021,7 +1036,7 @@ describe Puppet::Resource::Catalog, "when converting from json" do
 
         @catalog.expects(:add_edge).with { |edge| edge.event == "one" }
 
-        JSON.parse @json.to_json
+        PSON.parse @pson.to_pson
     end
 
     it "should set the source and target for each edge to the actual resource" do
@@ -1034,7 +1049,7 @@ describe Puppet::Resource::Catalog, "when converting from json" do
 
         @catalog.expects(:add_edge).with { |edge| edge.source == "source_resource" and edge.target == "target_resource" }
 
-        JSON.parse @json.to_json
+        PSON.parse @pson.to_pson
     end
 
     it "should fail if the source resource cannot be found" do
@@ -1045,7 +1060,7 @@ describe Puppet::Resource::Catalog, "when converting from json" do
         @catalog.expects(:resource).with("source").returns(nil)
         @catalog.stubs(:resource).with("target").returns("target_resource")
 
-        lambda { JSON.parse @json.to_json }.should raise_error(ArgumentError)
+        lambda { PSON.parse @pson.to_pson }.should raise_error(ArgumentError)
     end
 
     it "should fail if the target resource cannot be found" do
@@ -1056,6 +1071,6 @@ describe Puppet::Resource::Catalog, "when converting from json" do
         @catalog.stubs(:resource).with("source").returns("source_resource")
         @catalog.expects(:resource).with("target").returns(nil)
 
-        lambda { JSON.parse @json.to_json }.should raise_error(ArgumentError)
+        lambda { PSON.parse @pson.to_pson }.should raise_error(ArgumentError)
     end
 end