puppet 4.10.0 → 5.0.0

data/spec/unit/network/http/api/indirected_routes_spec.rb

@@ -127,13 +127,13 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     end
 
     it "should not URI unescape the indirection key" do
-      escaped = URI.escape("foo bar")
+      escaped = Puppet::Util.uri_encode("foo bar")
       indirection, _, key, _ = handler.uri2indirection("GET", "#{master_url_prefix}/node/#{escaped}", params)
       expect(key).to eq(escaped)
     end
 
     it "should not unescape the URI passed through in a call to check_authorization" do
-      key_escaped = URI.escape("foo bar")
+      key_escaped = Puppet::Util.uri_encode("foo bar")
       uri_escaped = "#{master_url_prefix}/node/#{key_escaped}"
       handler.expects(:check_authorization).with(anything, uri_escaped, anything)
       indirection, _, _, _ = handler.uri2indirection("GET", uri_escaped, params)
@@ -199,7 +199,7 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     end
 
     it "should use the escaped key as the remainder of the URI" do
-      escaped = URI.escape("with spaces")
+      escaped = Puppet::Util.uri_encode("with spaces")
       expect(handler.class.request_to_uri_and_body(request).first.split("/")[4].sub(/\?.+/, '')).to eq(escaped)
     end
 
@@ -255,49 +255,41 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     it "uses the first supported format for the response" do
       data = Puppet::IndirectorTesting.new("my data")
       indirection.save(data, "my data")
-      request = a_request_that_finds(data, :accept_header => "unknown, pson")
+      request = a_request_that_finds(data, :accept_header => "unknown, application/json")
 
       handler.call(request, response)
 
-      expect(response.body).to eq(data.render(:pson))
-      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:pson))
+      expect(response.body).to eq(data.render(:json))
+      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:json))
     end
 
-    it "raises not_acceptable_error when no accept header is provided" do
+    it "falls back to the next supported format" do
       data = Puppet::IndirectorTesting.new("my data")
       indirection.save(data, "my data")
-      request = a_request_that_finds(data, :accept_header => nil)
-
-      expect {
-        handler.call(request, response)
-      }.to raise_error(not_acceptable_error)
-    end
+      request = a_request_that_finds(data, :accept_header => "application/json, text/pson")
+      data.stubs(:to_json).raises(Puppet::Network::FormatHandler::FormatError, 'Could not render to Puppet::Network::Format[json]: source sequence is illegal/malformed utf-8')
 
-    it "raises not_acceptable_error when no accepted formats are known" do
-      data = Puppet::IndirectorTesting.new("my data")
-      indirection.save(data, "my data")
-      request = a_request_that_finds(data, :accept_header => "unknown, also/unknown")
+      handler.call(request, response)
 
-      expect {
-        handler.call(request, response)
-      }.to raise_error(not_acceptable_error)
+      expect(response.body).to eq(data.render(:pson))
+      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:pson))
     end
 
     it "should pass the result through without rendering it if the result is a string" do
       data = Puppet::IndirectorTesting.new("my data")
       data_string = "my data string"
-      request = a_request_that_finds(data, :accept_header => "text/pson")
+      request = a_request_that_finds(data, :accept_header => "application/json")
       indirection.expects(:find).returns(data_string)
 
       handler.call(request, response)
 
       expect(response.body).to eq(data_string)
-      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:pson))
+      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:json))
     end
 
     it "should raise not_found_error when no model instance can be found" do
       data = Puppet::IndirectorTesting.new("my data")
-      request = a_request_that_finds(data, :accept_header => "unknown, text/pson")
+      request = a_request_that_finds(data, :accept_header => "unknown, application/json")
 
       expect {
         handler.call(request, response)
@@ -309,7 +301,19 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     it "uses the first supported format for the response" do
       data = Puppet::IndirectorTesting.new("my data")
       indirection.save(data, "my data")
-      request = a_request_that_searches(Puppet::IndirectorTesting.new("my"), :accept_header => "unknown, text/pson")
+      request = a_request_that_searches(Puppet::IndirectorTesting.new("my"), :accept_header => "unknown, application/json")
+
+      handler.call(request, response)
+
+      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:json))
+      expect(response.body).to eq(Puppet::IndirectorTesting.render_multiple(:json, [data]))
+    end
+
+    it "falls back to the next supported format" do
+      data = Puppet::IndirectorTesting.new("my data")
+      indirection.save(data, "my data")
+      request = a_request_that_searches(Puppet::IndirectorTesting.new("my"), :accept_header => "application/json, text/pson")
+      data.stubs(:to_json).raises(Puppet::Network::FormatHandler::FormatError, 'Could not render to Puppet::Network::Format[json]: source sequence is illegal/malformed utf-8')
 
       handler.call(request, response)
 
@@ -317,17 +321,29 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       expect(response.body).to eq(Puppet::IndirectorTesting.render_multiple(:pson, [data]))
     end
 
+    it "raises 406 not acceptable if no formats are accceptable" do
+      data = Puppet::IndirectorTesting.new("my data")
+      indirection.save(data, "my data")
+      request = a_request_that_searches(Puppet::IndirectorTesting.new("my"), :accept_header => "application/json, text/pson")
+      data.stubs(:to_json).raises(Puppet::Network::FormatHandler::FormatError, 'Could not render to Puppet::Network::Format[json]: source sequence is illegal/malformed utf-8')
+      data.stubs(:to_pson).raises(Puppet::Network::FormatHandler::FormatError, 'Could not render to Puppet::Network::Format[pson]: source sequence is illegal/malformed utf-8')
+
+      expect {
+        handler.call(request, response)
+      }.to raise_error(Puppet::Network::HTTP::Error::HTTPNotAcceptableError, /No supported formats are acceptable/)
+    end
+
     it "should return [] when searching returns an empty array" do
-      request = a_request_that_searches(Puppet::IndirectorTesting.new("nothing"), :accept_header => "unknown, text/pson")
+      request = a_request_that_searches(Puppet::IndirectorTesting.new("nothing"), :accept_header => "unknown, application/json")
 
       handler.call(request, response)
 
       expect(response.body).to eq("[]")
-      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:pson))
+      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:json))
     end
 
     it "should raise not_found_error when searching returns nil" do
-      request = a_request_that_searches(Puppet::IndirectorTesting.new("nothing"), :accept_header => "unknown, text/pson")
+      request = a_request_that_searches(Puppet::IndirectorTesting.new("nothing"), :accept_header => "unknown, application/json")
       indirection.expects(:search).returns(nil)
 
       expect {
@@ -347,26 +363,15 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       expect(Puppet::IndirectorTesting.indirection.find("my data")).to be_nil
     end
 
-    it "responds with pson when no Accept header is given" do
-      data = Puppet::IndirectorTesting.new("my data")
-      indirection.save(data, "my data")
-      request = a_request_that_destroys(data, :accept_header => nil)
-
-      handler.call(request, response)
-
-      expect(response.body).to eq(data.render(:pson))
-      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:pson))
-    end
-
     it "uses the first supported format for the response" do
       data = Puppet::IndirectorTesting.new("my data")
       indirection.save(data, "my data")
-      request = a_request_that_destroys(data, :accept_header => "unknown, text/pson")
+      request = a_request_that_destroys(data, :accept_header => "unknown, application/json")
 
       handler.call(request, response)
 
-      expect(response.body).to eq(data.render(:pson))
-      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:pson))
+      expect(response.body).to eq(data.render(:json))
+      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:json))
     end
 
     it "raises an error and does not destroy when no accepted formats are known" do
@@ -399,12 +404,8 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
 
       handler.call(request, response)
 
-      # PUP-3272 this test fails when yaml is removed and pson is used. Instead of returning an
-      # empty string, the a string '""' is returned - Don't know what the expecation is, if this is
-      # corrent or not.
-      # (helindbe)
-      #
-      expect(Puppet::IndirectorTesting.indirection.find("test").name).to eq('')
+      saved = Puppet::IndirectorTesting.indirection.find("test")
+      expect(saved.name).to eq('')
     end
 
     it "saves the data sent in the request" do
@@ -417,24 +418,33 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       expect(saved.name).to eq(data.name)
     end
 
-    it "responds with pson when no Accept header is given" do
+    it "responds with bad request when failing to parse the body" do
       data = Puppet::IndirectorTesting.new("my data")
-      request = a_request_that_submits(data, :accept_header => nil)
+      request = a_request_that_submits(data, :content_type_header => 'application/json', :body => "this is invalid json content")
 
-      handler.call(request, response)
+      expect {
+        handler.call(request, response)
+      }.to raise_error(bad_request_error, /The request body is invalid: Could not intern from json/)
+    end
 
-      expect(response.body).to eq(data.render(:pson))
-      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:pson))
+    it "responds with unsupported media type error when submitted content is known, but not supported by the model" do
+      data = Puppet::IndirectorTesting.new("my data")
+      request = a_request_that_submits(data, :content_type_header => 's')
+      expect(data).to_not be_support_format('s')
+
+      expect {
+        handler.call(request, response)
+      }.to raise_error(unsupported_media_type_error, /Client sent a mime-type \(s\) that doesn't correspond to a format we support/)
     end
 
     it "uses the first supported format for the response" do
       data = Puppet::IndirectorTesting.new("my data")
-      request = a_request_that_submits(data, :accept_header => "unknown, text/pson")
+      request = a_request_that_submits(data, :accept_header => "unknown, application/json")
 
       handler.call(request, response)
 
-      expect(response.body).to eq(data.render(:pson))
-      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:pson))
+      expect(response.body).to eq(data.render(:json))
+      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:json))
     end
 
     it "raises an error and does not save when no accepted formats are known" do

data/spec/unit/network/http/api/master/v3/environment_spec.rb

@@ -5,10 +5,18 @@ require 'puppet/network/http'
 describe Puppet::Network::HTTP::API::Master::V3::Environment do
   let(:response) { Puppet::Network::HTTP::MemoryResponse.new }
 
+  let(:environment) { Puppet::Node::Environment.create(:production, [], '/manifests') }
+  let(:loader) { Puppet::Environments::Static.new(environment) }
+
   around :each do |example|
-    environment = Puppet::Node::Environment.create(:production, [], '/manifests')
-    loader = Puppet::Environments::Static.new(environment)
+    Puppet[:app_management] = true
     Puppet.override(:environments => loader) do
+      Puppet::Type.newtype :sql, :is_capability => true do
+        newparam :name, :namevar => true
+      end
+      Puppet::Type.newtype :http, :is_capability => true do
+        newparam :name, :namevar => true
+      end
       example.run
     end
   end
@@ -25,6 +33,124 @@ describe Puppet::Network::HTTP::API::Master::V3::Environment do
     expect(catalog['applications']).to eq({})
   end
 
+  describe "processing the environment catalog" do
+    def compile_site_to_catalog(site, code_id=nil)
+      Puppet[:code] = <<-MANIFEST
+      define db() { }
+      Db produces Sql { }
+
+      define web() { }
+      Web consumes Sql { }
+      Web produces Http { }
+
+      application myapp() {
+        db { $name:
+          export => Sql[$name],
+        }
+        web { $name:
+          consume => Sql[$name],
+          export => Http[$name],
+        }
+      }
+      site {
+        #{site}
+      }
+      MANIFEST
+      Puppet::Parser::EnvironmentCompiler.compile(environment, code_id).filter { |r| r.virtual? }
+    end
+
+
+    it "includes specified applications" do
+      catalog = compile_site_to_catalog <<-MANIFEST
+      myapp { 'test':
+        nodes => {
+          Node['foo.example.com'] => Db['test'],
+          Node['bar.example.com'] => Web['test'],
+        },
+      }
+      MANIFEST
+
+      result = subject.build_environment_graph(catalog)
+
+      expect(result[:applications]).to eq({'Myapp[test]' =>
+                                            {'Db[test]' => {:produces => ['Sql[test]'], :consumes => [], :node => 'foo.example.com'},
+                                             'Web[test]' => {:produces => ['Http[test]'], :consumes => ['Sql[test]'], :node => 'bar.example.com'}}})
+    end
+
+    it "fails if a component isn't mapped to a node" do
+      catalog = compile_site_to_catalog <<-MANIFEST
+      myapp { 'test':
+        nodes => {
+          Node['foo.example.com'] => Db['test'],
+        }
+      }
+      MANIFEST
+
+      expect { subject.build_environment_graph(catalog) }.to raise_error(Puppet::ParseError, /has components without assigned nodes/)
+    end
+
+    it "fails if a non-existent component is mapped to a node" do
+      catalog = compile_site_to_catalog <<-MANIFEST
+      myapp { 'test':
+        nodes => {
+          Node['foo.example.com'] => [ Db['test'], Web['test'], Web['foobar'] ],
+        }
+      }
+      MANIFEST
+
+      expect { subject.build_environment_graph(catalog) }.to raise_error(Puppet::ParseError, /assigns nodes to non-existent components/)
+    end
+
+    it "fails if a component is mapped twice" do
+      catalog = compile_site_to_catalog <<-MANIFEST
+      myapp { 'test':
+        nodes => {
+          Node['foo.example.com'] => [ Db['test'], Web['test'] ],
+          Node['bar.example.com'] => [ Web['test'] ],
+        }
+      }
+      MANIFEST
+
+      expect { subject.build_environment_graph(catalog) }.to raise_error(Puppet::ParseError, /assigns multiple nodes to component/)
+    end
+
+    it "fails if an application maps components from other applications" do
+      catalog = compile_site_to_catalog <<-MANIFEST
+      myapp { 'test':
+        nodes => {
+          Node['foo.example.com'] => [ Db['test'], Web['test'] ],
+        }
+      }
+      myapp { 'other':
+        nodes => {
+          Node['foo.example.com'] => [ Db['other'], Web['other'], Web['test'] ],
+        }
+      }
+      MANIFEST
+
+      expect { subject.build_environment_graph(catalog) }.to raise_error(Puppet::ParseError, /assigns nodes to non-existent components/)
+    end
+
+    it "doesn't fail if the catalog contains a node cycle" do
+      catalog = compile_site_to_catalog <<-MANIFEST
+      myapp { 'test':
+        nodes => {
+          Node['foo.example.com'] => [ Db['test'] ],
+          Node['bar.example.com'] => [ Web['test'] ],
+        }
+      }
+      myapp { 'other':
+        nodes => {
+          Node['foo.example.com'] => [ Web['other'] ],
+          Node['bar.example.com'] => [ Db['other'] ],
+        }
+      }
+      MANIFEST
+
+      expect { subject.build_environment_graph(catalog) }.not_to raise_error
+    end
+  end
+
   it "returns 404 if the environment doesn't exist" do
     request = Puppet::Network::HTTP::Request.from_hash(:routing_path => "environment/development")
 

data/spec/unit/network/http/api/master/v3_spec.rb

@@ -41,7 +41,7 @@ describe Puppet::Network::HTTP::API::Master::V3 do
     request = Puppet::Network::HTTP::Request.
         from_hash(:path => "#{master_url_prefix}/node/foo",
                   :params => {:environment => "production"},
-                  :headers => {"accept" => "text/pson"})
+                  :headers => {"accept" => "application/json"})
     master_routes.process(request, response)
 
     expect(response.code).to eq(200)

data/spec/unit/network/http/api_spec.rb

@@ -79,7 +79,7 @@ describe Puppet::Network::HTTP::API do
       it "responds to v3 indirector requests" do
         req = Puppet::Network::HTTP::Request.from_hash(:path => "#{master_prefix}/v3/node/foo",
                                                        :params => {:environment => "production"},
-                                                       :headers => {'accept' => "pson"})
+                                                       :headers => {'accept' => "application/json"})
         res = {}
         handler.process(req, res)
         expect(res[:status]).to eq(200)