puppet 4.3.0 → 4.4.0

data/spec/unit/indirector/file_bucket_file/file_spec.rb

@@ -41,7 +41,7 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
       end
 
       it "fails if the contents collide with existing contents" do
-        # This is the shortest known MD5 collision. See http://eprint.iacr.org/2010/643.pdf
+        # This is the shortest known MD5 collision. See https://eprint.iacr.org/2010/643.pdf
         first_contents = [0x6165300e,0x87a79a55,0xf7c60bd0,0x34febd0b,
                           0x6503cf04,0x854f709e,0xfb0fc034,0x874c9c65,
                           0x2f94cc40,0x15a12deb,0x5c15f4a3,0x490786bb,

data/spec/unit/indirector/indirection_spec.rb

@@ -402,7 +402,7 @@ describe Puppet::Indirector::Indirection do
 
           Puppet.expects(:log_exception)
 
-          expect { @indirection.find("/my/key") }.to raise_error
+          expect { @indirection.find("/my/key") }.to raise_error RuntimeError
         end
       end
     end

data/spec/unit/indirector/json_spec.rb

@@ -81,7 +81,7 @@ describe Puppet::Indirector::JSON do
           # I don't like this, but there isn't a credible alternative that
           # also works on Windows, so a stub it is. At least the expectation
           # will fail if the implementation changes. Sorry to the next dev.
-          File.expects(:read).with(file).raises(Errno::EPERM)
+          Puppet::FileSystem.expects(:read).with(file).raises(Errno::EPERM)
           expect { subject.find(request) }.
             to raise_error Puppet::Error, /Could not read JSON/
         end

data/spec/unit/info_service_spec.rb

@@ -19,6 +19,9 @@ describe "Puppet::InfoService" do
            class bar($bar_a, Integer $bar_b, String $bar_c = 'c default value') { }
            class bar2($bar2_a, Integer $bar2_b, String $bar2_c = 'c default value') { }
         CODE
+        'intp.pp' => <<-CODE,
+           class intp(String $intp_a = "default with interpolated $::os_family") { }
+        CODE
         'fee.pp' => <<-CODE,
            class fee(Integer $fee_a = 1+1) { }
         CODE
@@ -31,6 +34,9 @@ describe "Puppet::InfoService" do
         'borked.pp' => <<-CODE,
            class Borked($Herp+$Derp) {}
         CODE
+        'json_unsafe.pp' => <<-CODE,
+             class json_unsafe($arg1 = /.*/, $arg2 = default, $arg3 = {1 => 1}) {}
+          CODE
        })
     end
 
@@ -47,21 +53,23 @@ describe "Puppet::InfoService" do
       result = Puppet::InfoService.classes_per_environment({'production' => files })
       expect(result).to eq({
         "production"=>{
-           "#{code_dir}/foo.pp"=>[
+           "#{code_dir}/foo.pp"=> {:classes => [
              {:name=>"foo",
                :params=>[
                  {:name=>"foo_a"},
                  {:name=>"foo_b", :type=>"Integer"},
-                 {:name=>"foo_c", :type=>"String", :default_literal=>"c default value"}
+                 {:name=>"foo_c", :type=>"String", :default_literal=>"c default value",
+                   :default_source=>"'c default value'"}
                ]},
              {:name=>"foo2",
                :params=>[
                  {:name=>"foo2_a"},
                  {:name=>"foo2_b", :type=>"Integer"},
-                 {:name=>"foo2_c", :type=>"String", :default_literal=>"c default value"}
+                 {:name=>"foo2_c", :type=>"String", :default_literal=>"c default value",
+                   :default_source=>"'c default value'"}
                ]
              }
-           ]} # end production env
+           ]}} # end production env
         })
     end
 
@@ -70,36 +78,40 @@ describe "Puppet::InfoService" do
       result = Puppet::InfoService.classes_per_environment({'production' => files })
       expect(result).to eq({
         "production"=>{
-           "#{code_dir}/foo.pp"=>[
+           "#{code_dir}/foo.pp"=>{:classes => [
              {:name=>"foo",
                :params=>[
                  {:name=>"foo_a"},
                  {:name=>"foo_b", :type=>"Integer"},
-                 {:name=>"foo_c", :type=>"String", :default_literal=>"c default value"}
+                 {:name=>"foo_c", :type=>"String", :default_literal=>"c default value",
+                   :default_source=>"'c default value'"}
                ]},
              {:name=>"foo2",
                :params=>[
                  {:name=>"foo2_a"},
                  {:name=>"foo2_b", :type=>"Integer"},
-                 {:name=>"foo2_c", :type=>"String", :default_literal=>"c default value"}
+                 {:name=>"foo2_c", :type=>"String", :default_literal=>"c default value",
+                   :default_source=>"'c default value'"}
                ]
              }
-           ],
-          "#{code_dir}/bar.pp"=>[
+           ]},
+          "#{code_dir}/bar.pp"=> {:classes =>[
             {:name=>"bar",
               :params=>[
                 {:name=>"bar_a"},
                 {:name=>"bar_b", :type=>"Integer"},
-                {:name=>"bar_c", :type=>"String", :default_literal=>"c default value"}
+                {:name=>"bar_c", :type=>"String", :default_literal=>"c default value",
+                  :default_source=>"'c default value'"}
               ]},
             {:name=>"bar2",
               :params=>[
                 {:name=>"bar2_a"},
                 {:name=>"bar2_b", :type=>"Integer"},
-                {:name=>"bar2_c", :type=>"String", :default_literal=>"c default value"}
+                {:name=>"bar2_c", :type=>"String", :default_literal=>"c default value",
+                :default_source=>"'c default value'"}
               ]
             }
-          ],
+          ]},
 
           } # end production env
         }
@@ -116,50 +128,54 @@ describe "Puppet::InfoService" do
 
       expect(result).to eq({
         "production"=>{
-           "#{code_dir}/foo.pp"=>[
+           "#{code_dir}/foo.pp"=>{:classes => [
              {:name=>"foo",
                :params=>[
                  {:name=>"foo_a"},
                  {:name=>"foo_b", :type=>"Integer"},
-                 {:name=>"foo_c", :type=>"String", :default_literal=>"c default value"}
+                 {:name=>"foo_c", :type=>"String", :default_literal=>"c default value",
+                   :default_source=>"'c default value'"}
                ]},
              {:name=>"foo2",
                :params=>[
                  {:name=>"foo2_a"},
                  {:name=>"foo2_b", :type=>"Integer"},
-                 {:name=>"foo2_c", :type=>"String", :default_literal=>"c default value"}
+                 {:name=>"foo2_c", :type=>"String", :default_literal=>"c default value",
+                   :default_source=>"'c default value'"}
                ]
              }
-           ],
-          "#{code_dir}/bar.pp"=>[
+           ]},
+          "#{code_dir}/bar.pp"=>{:classes => [
             {:name=>"bar",
               :params=>[
                 {:name=>"bar_a"},
                 {:name=>"bar_b", :type=>"Integer"},
-                {:name=>"bar_c", :type=>"String", :default_literal=>"c default value"}
+                {:name=>"bar_c", :type=>"String", :default_literal=>"c default value",
+                  :default_source=>"'c default value'"}
               ]},
             {:name=>"bar2",
               :params=>[
                 {:name=>"bar2_a"},
                 {:name=>"bar2_b", :type=>"Integer"},
-                {:name=>"bar2_c", :type=>"String", :default_literal=>"c default value"}
+                {:name=>"bar2_c", :type=>"String", :default_literal=>"c default value",
+                  :default_source=>"'c default value'"}
                 ]
               }
-            ],
+          ]},
           }, # end production env
         "test"=>{
-           "#{code_dir}/fee.pp"=>[
+           "#{code_dir}/fee.pp"=>{:classes => [
              {:name=>"fee",
                :params=>[
                  {:name=>"fee_a", :type=>"Integer", :default_source=>"1+1"}
                ]},
-           ],
-          "#{code_dir}/fum.pp"=>[
+           ]},
+          "#{code_dir}/fum.pp"=>{:classes => [
             {:name=>"fum",
               :params=>[
                 {:name=>"fum_a"}
               ]},
-          ],
+          ]},
          } # end test env
         }
       )
@@ -177,8 +193,8 @@ describe "Puppet::InfoService" do
         'test'       => files_test
         })
        expect(result).to eq({
-        "production"=>{ "#{code_dir}/fum.pp"=>[ {:name=>"fum", :params=>[ {:name=>"fum_a"}]}]},
-        "test"      =>{ "#{code_dir}/fum.pp"=>[ {:name=>"fum", :params=>[ {:name=>"fum_a"}]}]}
+         "production"=>{ "#{code_dir}/fum.pp"=>{:classes => [ {:name=>"fum", :params=>[ {:name=>"fum_a"}]}]}},
+         "test"      =>{ "#{code_dir}/fum.pp"=>{:classes => [ {:name=>"fum", :params=>[ {:name=>"fum_a"}]}]}}
        }
       )
     end
@@ -188,29 +204,64 @@ describe "Puppet::InfoService" do
       result = Puppet::InfoService.classes_per_environment({'production' => files })
       expect(result).to eq({
         "production"=>{
-           "#{code_dir}/fee.pp"=>[
+           "#{code_dir}/fee.pp"=>{:classes => [
              {:name=>"fee",
                :params=>[
                  {:name=>"fee_a", :type=>"Integer", :default_source=>"1+1"}
                ]},
-           ]} # end production env
+           ]}} # end production env
         })
      end
 
+     it "produces source string for literals that are not pure json" do
+       files = ['json_unsafe.pp'].map {|f| File.join(code_dir, f) }
+       result = Puppet::InfoService.classes_per_environment({'production' => files })
+       expect(result).to eq({
+         "production"=>{
+            "#{code_dir}/json_unsafe.pp" => {:classes => [
+              {:name=>"json_unsafe",
+                :params => [
+                  {:name => "arg1",
+                    :default_source => "/.*/" },
+                  {:name => "arg2",
+                    :default_source => "default" },
+                  {:name => "arg3",
+                    :default_source => "{1 => 1}" }
+                ]}
+            ]}} # end production env
+         })
+     end
+
     it "produces no type entry if type is not given" do
       files = ['fum.pp'].map {|f| File.join(code_dir, f) }
       result = Puppet::InfoService.classes_per_environment({'production' => files })
       expect(result).to eq({
         "production"=>{
-           "#{code_dir}/fum.pp"=>[
+           "#{code_dir}/fum.pp"=>{:classes => [
              {:name=>"fum",
                :params=>[
                  {:name=>"fum_a" }
                ]},
-           ]} # end production env
+           ]}} # end production env
         })
     end
 
+    it 'does not evaluate default expressions' do
+      files = ['intp.pp'].map {|f| File.join(code_dir, f) }
+      result = Puppet::InfoService.classes_per_environment({'production' => files })
+      expect(result).to eq({
+        'production' =>{
+          "#{code_dir}/intp.pp"=>{:classes => [
+            {:name=> 'intp',
+              :params=>[
+                {:name=> 'intp_a',
+                  :type=> 'String',
+                  :default_source=>'"default with interpolated $::os_family"'}
+              ]},
+          ]}} # end production env
+      })
+    end
+
     it "produces error entry if file is broken" do
       files = ['borked.pp'].map {|f| File.join(code_dir, f) }
        result = Puppet::InfoService.classes_per_environment({'production' => files })
@@ -228,9 +279,20 @@ describe "Puppet::InfoService" do
        result = Puppet::InfoService.classes_per_environment({'production' => files })
        expect(result).to eq({
          "production"=>{
-            "#{code_dir}/nothing.pp"=> []
-              },
+           "#{code_dir}/nothing.pp"=> {:classes => [] }
+           },
          })
     end
+
+    it "produces error when given a file that does not exist" do
+      files = ['the_tooth_fairy_does_not_exist.pp'].map {|f| File.join(code_dir, f) }
+      result = Puppet::InfoService.classes_per_environment({'production' => files })
+      expect(result).to eq({
+        "production"=>{
+          "#{code_dir}/the_tooth_fairy_does_not_exist.pp" => {:error  => "The file #{code_dir}/the_tooth_fairy_does_not_exist.pp does not exist"}
+             },
+        })
+    end
+
   end
 end

data/spec/unit/module_spec.rb

@@ -347,6 +347,20 @@ describe Puppet::Module do
       expect(mod.unmet_dependencies).to eq([])
     end
 
+    it "should throw an error if invalid dependencies are specified" do
+      expect {
+        PuppetSpec::Modules.create(
+          'foobar',
+          @modpath,
+          :metadata => {
+            :dependencies => ""
+          }
+        )
+      }.to raise_error(
+        Puppet::Module::MissingMetadata,
+        /dependencies in the file metadata.json of the module foobar must be an array, not: ''/)
+    end
+
     it "should only list unmet dependencies" do
       env = Puppet::Node::Environment.create(:testing, [@modpath])
 

data/spec/unit/module_tool/applications/builder_spec.rb

@@ -343,12 +343,12 @@ symlinkfile
         f.puts({
           "name" => "#{module_name}",
           "version" => "#{version}",
-          "source" => "http://github.com/testing/#{module_name}",
+          "source" => "https://github.com/testing/#{module_name}",
           "author" => "testing",
           "license" => "Apache License Version 2.0",
           "summary" => "Puppet testing module",
           "description" => "This module can be used for basic testing",
-          "project_page" => "http://github.com/testing/#{module_name}"
+          "project_page" => "https://github.com/testing/#{module_name}"
         }.to_json)
       end
     end
@@ -381,12 +381,12 @@ symlinkfile
         f.puts({
           "name" => "#{module_name}",
           "version" => "#{version}",
-          "source" => "http://github.com/testing/#{module_name}",
+          "source" => "https://github.com/testing/#{module_name}",
           "author" => "testing",
           "license" => "Apache License Version 2.0",
           "summary" => "Puppet testing module",
           "description" => "This module can be used for basic testing",
-          "project_page" => "http://github.com/testing/#{module_name}",
+          "project_page" => "https://github.com/testing/#{module_name}",
           "checksums" => {"README.md" => "deadbeef"}
         }.to_json)
       end

data/spec/unit/network/authstore_spec.rb

@@ -301,7 +301,7 @@ describe Puppet::Network::AuthStore::Declaration do
 
       issue_7477 = !(IPAddr.new(ip) rescue false)
 
-      describe "on rubies with a fix for issue [7477](http://goo.gl/Bb1LU)", :if => issue_7477
+      describe "on rubies with a fix for issue [7477](https://goo.gl/Bb1LU)", :if => issue_7477
         it "should match the specified IP" do
           expect(declaration).to be_match('www.testsite.org',ip)
         end

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

@@ -163,6 +163,7 @@ describe Puppet::Network::HTTP::Connection do
 
       Net::HTTP.any_instance.stubs(:start)
       Net::HTTP.any_instance.stubs(:request).returns(httpok)
+      Puppet::Network::HTTP::Pool.any_instance.stubs(:setsockopts)
 
       connection.get('request')
     end

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

@@ -109,6 +109,31 @@ describe Puppet::Network::HTTP::Pool do
       end rescue nil
     end
 
+    it 'sets keepalive bit on network socket' do
+      pool = create_pool
+      s = Socket.new(Socket::PF_INET, Socket::SOCK_STREAM)
+      pool.setsockopts(Net::BufferedIO.new(s))
+
+      # On windows, Socket.getsockopt() doesn't return exactly the same data
+      # as an equivalent Socket::Option.new() statement, so we strip off the
+      # unrelevant bits only on this platform.
+      #
+      # To make sure we're not voiding the test case by doing this, we check
+      # both with and without the keepalive bit set.
+      #
+      # This workaround can be removed once all the ruby versions we care about
+      # have the patch from https://bugs.ruby-lang.org/issues/11958 applied.
+      #
+      if Puppet::Util::Platform.windows?
+        keepalive   = Socket::Option.bool(:INET, :SOCKET, :KEEPALIVE, true).data[0]
+        nokeepalive = Socket::Option.bool(:INET, :SOCKET, :KEEPALIVE, false).data[0]
+        expect(s.getsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE).data).to eq(keepalive)
+        expect(s.getsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE).data).to_not eq(nokeepalive)
+      else
+        expect(s.getsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE).bool).to eq(true)
+      end
+    end
+
     context 'when releasing connections' do
       it 'releases HTTP connections' do
         conn = create_connection(site)
@@ -150,6 +175,7 @@ describe Puppet::Network::HTTP::Pool do
       conn = create_connection(site)
       pool = create_pool
       pool.factory.expects(:create_connection).with(site).returns(conn)
+      pool.expects(:setsockopts)
 
       expect(pool.borrow(site, verify)).to eq(conn)
     end
@@ -169,6 +195,7 @@ describe Puppet::Network::HTTP::Pool do
 
       conn = create_connection(site)
       pool.factory.expects(:create_connection).with(site).returns(conn)
+      pool.expects(:setsockopts)
 
       expect(pool.borrow(site, verify)).to eq(conn)
     end
@@ -179,6 +206,7 @@ describe Puppet::Network::HTTP::Pool do
 
       pool = create_pool
       pool.factory.expects(:create_connection).with(site).returns(conn)
+      pool.expects(:setsockopts)
 
       expect(pool.borrow(site, verify)).to eq(conn)
     end
@@ -205,6 +233,7 @@ describe Puppet::Network::HTTP::Pool do
 
       pool = create_pool_with_expired_connections(site, conn)
       pool.factory.expects(:create_connection => stub('conn', :start => nil))
+      pool.expects(:setsockopts)
 
       pool.borrow(site, verify)
     end
@@ -217,6 +246,7 @@ describe Puppet::Network::HTTP::Pool do
 
       pool = create_pool_with_expired_connections(site, conn)
       pool.factory.expects(:create_connection => stub('open_conn', :start => nil))
+      pool.expects(:setsockopts)
 
       pool.borrow(site, verify)
     end

data/spec/unit/node_spec.rb

@@ -86,6 +86,14 @@ describe Puppet::Node do
                              )
       expect(node.to_pson).to validate_against('api/schemas/node.json')
     end
+
+    it "should allow its environment parameter to be set by attribute after initialization" do
+      node = Puppet::Node.new("foo", { :parameters => { 'environment' => :foo } })
+      node.environment_name = :foo
+      node.environment = :bar
+      expect(node.environment_name).to eq(:bar)
+      expect(node.parameters['environment']).to eq('bar')
+    end
   end
 
   describe "when serializing using yaml" do

data/spec/unit/parser/compiler_spec.rb

@@ -194,24 +194,6 @@ describe Puppet::Parser::Compiler do
       expect(sanitized.trusted_data).to_not eq({ :a => 42 })
     end
 
-    it "should report 'trusted' parameters as trusted_data but as inauthentic if running as non-root" do
-      node = Puppet::Node.new("mynode")
-      node.parameters['trusted'] = { 'authenticated' => true,
-                                     'certname'      => 'foo',
-                                     'extensions'    => 'things' }
-
-      Puppet.features.stubs(:root?).returns(false)
-
-      Puppet.ignore(:trusted_information)
-      compiler = Puppet::Parser::Compiler.new(node)
-      Puppet.restore(:trusted_information)
-
-      sanitized = compiler.node
-      expect(sanitized.trusted_data).to eq({ 'authenticated' => false,
-                                             'certname'      => 'foo',
-                                             'extensions'    => 'things' })
-    end
-
     it "should prefer trusted_data in the node above other plausible sources" do
       node = Puppet::Node.new("mynode")
       node.trusted_data = { 'authenticated' => true,
@@ -276,6 +258,22 @@ describe Puppet::Parser::Compiler do
       expect(@compiler.topscope['c']).to eq("d")
     end
 
+    it "should set node parameters thar are of Symbol type as String variables in the top scope" do
+      params = {"a" => :b}
+      @node.stubs(:parameters).returns(params)
+      compile_stub(:set_node_parameters)
+      @compiler.compile
+      expect(@compiler.topscope['a']).to eq("b")
+    end
+
+    it "should set the node's environment as a string variable in top scope" do
+      compile_stub(:set_node_parameters)
+      @node.merge({'wat' => 'this is how the sausage is made'})
+      @compiler.compile
+      expect(@compiler.topscope['environment']).to eq("testing")
+      expect(@compiler.topscope['wat']).to eq('this is how the sausage is made')
+    end
+
     it "should set the client and server versions on the catalog" do
       params = {"clientversion" => "2", "serverversion" => "3"}
       @node.stubs(:parameters).returns(params)

data/spec/unit/parser/scope_spec.rb

@@ -158,7 +158,7 @@ describe Puppet::Parser::Scope do
       expect { @scope[:foo] = 12 }.to raise_error(Puppet::ParseError, /Scope variable name .* not a string/)
     end
 
-    it "should return nil for unset variables" do
+    it "should return nil for unset variables when --strict variables is not in effect" do
       expect(@scope["var"]).to be_nil
     end
 
@@ -208,6 +208,26 @@ describe Puppet::Parser::Scope do
       expect(@scope).not_to be_include("var")
     end
 
+    it "warns and return nil for non found unqualified variable" do
+      Puppet.expects(:warn_once)
+      expect(@scope["santa_clause"]).to be_nil
+    end
+
+    it "warns once for a non found variable" do
+      Puppet.expects(:warning).once
+      expect([@scope["santa_claus"],@scope["santa_claus"]]).to eq([nil, nil])
+    end
+
+    it "warns and return nil for non found qualified variable" do
+      Puppet.expects(:warn_once)
+      expect(@scope["north_pole::santa_clause"]).to be_nil
+    end
+
+    it "does not warn when a numeric variable is missing - they always exist" do
+      Puppet.expects(:warn_once).never
+      expect(@scope["1"]).to be_nil
+    end
+
     describe "and the variable is qualified" do
       before :each do
         @known_resource_types = @scope.known_resource_types
@@ -266,17 +286,16 @@ describe Puppet::Parser::Scope do
 
       it "should warn and return nil for qualified variables whose classes have not been evaluated" do
         klass = newclass("other::deep::klass")
-        @scope.expects(:warning)
+        Puppet.expects(:warn_once)
         expect(@scope["other::deep::klass::var"]).to be_nil
       end
 
       it "should warn and return nil for qualified variables whose classes do not exist" do
-        @scope.expects(:warning)
+        Puppet.expects(:warn_once)
         expect(@scope["other::deep::klass::var"]).to be_nil
       end
 
       it "should return nil when asked for a non-string qualified variable from a class that does not exist" do
-        @scope.stubs(:warning)
         expect(@scope["other::deep::klass::var"]).to be_nil
       end
 
@@ -489,17 +508,15 @@ describe Puppet::Parser::Scope do
         expect(@scope.include?("1")).to be_falsey
       end
 
-      describe "when calling unset_ephemeral_var with a level" do
+      describe "when using a guarded scope" do
         it "should remove ephemeral scopes up to this level" do
           @scope.set_match_data({1 => :value1})
           @scope.new_ephemeral
           @scope.set_match_data({1 => :value2})
-          level = @scope.ephemeral_level()
-          @scope.new_ephemeral
-          @scope.set_match_data({1 => :value3})
-
-          @scope.unset_ephemeral_var(level)
-
+          @scope.with_guarded_scope do
+            @scope.new_ephemeral
+            @scope.set_match_data({1 => :value3})
+          end
           expect(@scope["1"]).to eq(:value2)
         end
       end

data/spec/unit/pops/evaluator/access_ops_spec.rb

@@ -120,12 +120,12 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
 
     it 'produces an Integer[1]' do
       expr = fqr('Integer')[1]
-      expect(evaluate(expr)).to eql(range(1,1))
+      expect(evaluate(expr)).to eql(range(1,:default))
     end
 
-    it 'produces an Integer[from, <from]' do
+    it 'gives an error for Integer[from, <from]' do
       expr = fqr('Integer')[1,0]
-      expect(evaluate(expr)).to eql(range(1,0))
+      expect{evaluate(expr)}.to raise_error(/'from' must be less or equal to 'to'/)
     end
 
     it 'produces an error for Integer[] if there are more than 2 keys' do
@@ -146,17 +146,17 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
 
     it 'produces a Float[1.0]' do
       expr = fqr('Float')[1.0]
-      expect(evaluate(expr)).to eql(float_range(1.0,1.0))
+      expect(evaluate(expr)).to eql(float_range(1.0,:default))
     end
 
     it 'produces a Float[1]' do
       expr = fqr('Float')[1]
-      expect(evaluate(expr)).to eql(float_range(1.0,1.0))
+      expect(evaluate(expr)).to eql(float_range(1.0,:default))
     end
 
-    it 'produces a Float[from, <from]' do
+    it 'gives an error for Float[from, <from]' do
       expr = fqr('Float')[1.0,0.0]
-      expect(evaluate(expr)).to eql(float_range(1.0,0.0))
+      expect{evaluate(expr)}.to raise_error(/'from' must be less or equal to 'to'/)
     end
 
     it 'produces an error for Float[] if there are more than 2 keys' do

data/spec/unit/pops/evaluator/comparison_ops_spec.rb

@@ -86,6 +86,9 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       it "'1.0' < 1.1 == true" do
         expect{evaluate(literal('1.0') <  literal(1.1))}.to raise_error(/String < Float/)
       end
+      it "undef < 1.1 == true" do
+        expect{evaluate(literal(nil) <  literal(1.1))}.to raise_error(/Undef Value < Float/)
+      end
     end
 
     context "of regular expressions" do