puppet 4.0.0 → 4.9.1

data/spec/unit/module_spec.rb

@@ -132,23 +132,6 @@ describe Puppet::Module do
       mod.description = "GPL2"
       expect(mod.description).to eq("GPL2")
     end
-
-    it "should support specifying a compatible puppet version" do
-      mod.puppetversion = "0.25"
-      expect(mod.puppetversion).to eq("0.25")
-    end
-  end
-
-  it "should validate that the puppet version is compatible" do
-    mod.puppetversion = "0.25"
-    Puppet.expects(:version).returns "0.25"
-    mod.validate_puppet_version
-  end
-
-  it "should fail if the specified puppet version is not compatible" do
-    mod.puppetversion = "0.25"
-    Puppet.stubs(:version).returns "0.24"
-    expect { mod.validate_puppet_version }.to raise_error(Puppet::Module::IncompatibleModule)
   end
 
   describe "when finding unmet dependencies" do
@@ -364,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])
 
@@ -612,21 +609,14 @@ describe Puppet::Module do
 
   it "should have metadata if it has a metadata file and its data is not empty" do
     Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns true
-    File.stubs(:read).with(@module.metadata_file).returns "{\"foo\" : \"bar\"}"
-
-    expect(@module).to be_has_metadata
-  end
-
-  it "should have metadata if it has a metadata file and its data is not empty" do
-    Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns true
-    File.stubs(:read).with(@module.metadata_file).returns "{\"foo\" : \"bar\"}"
+    File.stubs(:read).with(@module.metadata_file, {:encoding => 'utf-8'}).returns "{\"foo\" : \"bar\"}"
 
     expect(@module).to be_has_metadata
   end
 
   it "should not have metadata if has a metadata file and its data is empty" do
     Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns true
-    File.stubs(:read).with(@module.metadata_file).returns "This is some invalid json.\n"
+    File.stubs(:read).with(@module.metadata_file, {:encoding => 'utf-8'}).returns "This is some invalid json.\n"
     expect(@module).not_to be_has_metadata
   end
 
@@ -649,17 +639,60 @@ describe Puppet::Module do
 
   it "should tolerate failure to parse" do
     Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns true
-    File.stubs(:read).with(@module.metadata_file).returns(my_fixture('trailing-comma.json'))
+    File.stubs(:read).with(@module.metadata_file, {:encoding => 'utf-8'}).returns(my_fixture('trailing-comma.json'))
 
     expect(@module.has_metadata?).to be_falsey
   end
 
+  describe 'when --strict is warning' do
+    before :each do
+      Puppet[:strict] = :warning
+    end
+
+    it "should warn about a failure to parse" do
+      Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns true
+      File.stubs(:read).with(@module.metadata_file, {:encoding => 'utf-8'}).returns(my_fixture('trailing-comma.json'))
+
+      expect(@module.has_metadata?).to be_falsey
+      expect(@logs).to have_matching_log(/mymod has an invalid and unparsable metadata\.json file/)
+    end
+  end
+
+    describe 'when --strict is off' do
+      before :each do
+        Puppet[:strict] = :off
+      end
+
+      it "should warn about a failure to parse" do
+        Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns true
+        File.stubs(:read).with(@module.metadata_file, {:encoding => 'utf-8'}).returns(my_fixture('trailing-comma.json'))
+
+        expect(@module.has_metadata?).to be_falsey
+        expect(@logs).to have_matching_log(/mymod has an invalid and unparsable metadata\.json file.*/)
+      end
+    end
+
+    describe 'when --strict is error' do
+      before :each do
+        Puppet[:strict] = :error
+      end
+
+      it "should fail on a failure to parse" do
+        Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns true
+        File.stubs(:read).with(@module.metadata_file, {:encoding => 'utf-8'}).returns(my_fixture('trailing-comma.json'))
+
+        expect do
+        expect(@module.has_metadata?).to be_falsey
+        end.to raise_error(/mymod has an invalid and unparsable metadata\.json file/)
+      end
+    end
+
   def a_module_with_metadata(data)
     text = data.to_pson
 
     mod = Puppet::Module.new("foo", "/path", mock("env"))
     mod.stubs(:metadata_file).returns "/my/file"
-    File.stubs(:read).with("/my/file").returns text
+    File.stubs(:read).with("/my/file", {:encoding => 'utf-8'}).returns text
     mod
   end
 
@@ -670,7 +703,6 @@ describe Puppet::Module do
         :author        => "luke",
         :version       => "1.0",
         :source        => "http://foo/",
-        :puppetversion => "0.25",
         :dependencies  => []
       }
       @module = a_module_with_metadata(@data)
@@ -685,17 +717,36 @@ describe Puppet::Module do
       it "should fail if #{attr} is not present in the metadata file" do
         @data.delete(attr.to_sym)
         @text = @data.to_pson
-        File.stubs(:read).with("/my/file").returns @text
+        File.stubs(:read).with("/my/file", {:encoding => 'utf-8'}).returns @text
         expect { @module.load_metadata }.to raise_error(
           Puppet::Module::MissingMetadata,
           "No #{attr} module metadata provided for foo"
         )
       end
     end
+  end
+
+  describe "when loading the metadata file from disk" do
+    it "should properly parse utf-8 contents" do
+      rune_utf8 = "\u16A0\u16C7\u16BB" # ᚠᛇᚻ
+      metadata_json = tmpfile('metadata.json')
+      File.open(metadata_json, 'w:UTF-8') do |file|
+        file.puts <<-EOF
+  {
+    "license" : "GPL2",
+    "author" : "#{rune_utf8}",
+    "version" : "1.0",
+    "source" : "http://foo/",
+    "dependencies" : []
+  }
+        EOF
+      end
+
+      mod = Puppet::Module.new('foo', '/path', mock('env'))
+      mod.stubs(:metadata_file).returns metadata_json
 
-    it "should set puppetversion if present in the metadata file" do
-      @module.load_metadata
-      expect(@module.puppetversion).to eq(@data[:puppetversion])
+      mod.load_metadata
+      expect(mod.author).to eq(rune_utf8)
     end
   end
 

data/spec/unit/module_tool/application_spec.rb

@@ -18,7 +18,7 @@ describe Puppet::ModuleTool::Applications::Application do
 
     bad_versions.each do |ver|
       it "should not accept version string #{ver}" do
-        expect { app.parse_filename("puppetlabs-ntp-#{ver}") }.to raise_error
+        expect { app.parse_filename("puppetlabs-ntp-#{ver}") }.to raise_error(ArgumentError, /(Invalid version format|Could not parse filename)/)
       end
     end
   end

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

@@ -56,37 +56,41 @@ describe Puppet::ModuleTool::Applications::Builder do
       Puppet::FileSystem.touch(File.join(path, 'gitdirectory/gitartifact'))
       Puppet::FileSystem.touch(File.join(path, 'gitdirectory/gitimportantfile'))
       Puppet::FileSystem.touch(File.join(path, 'gitdirectory/sub/artifact'))
+      Puppet::FileSystem.touch(File.join(path, "git\u16A0\u16C7\u16BB"))
       Puppet::FileSystem.touch(File.join(path, 'pmtignored.foo'))
       Puppet::FileSystem.mkpath(File.join(path, 'pmtdirectory/sub'))
       Puppet::FileSystem.touch(File.join(path, 'pmtdirectory/pmtimportantfile'))
       Puppet::FileSystem.touch(File.join(path, 'pmtdirectory/pmtartifact'))
       Puppet::FileSystem.touch(File.join(path, 'pmtdirectory/sub/artifact'))
+      Puppet::FileSystem.touch(File.join(path, "pmt\u16A0\u16C7\u16BB"))
     end
 
     def create_pmtignore_file
-      Puppet::FileSystem.open(File.join(path, '.pmtignore'), 0600, 'w') do |f|
+      File.open(File.join(path, '.pmtignore'), 'w', 0600, :encoding => 'utf-8') do |f|
         f << <<-PMTIGNORE
 pmtignored.*
 pmtdirectory/sub/**
 pmtdirectory/pmt*
 !pmtimportantfile
+pmt\u16A0\u16C7\u16BB
 PMTIGNORE
       end
     end
 
     def create_gitignore_file
-      Puppet::FileSystem.open(File.join(path, '.gitignore'), 0600, 'w') do |f|
+      File.open(File.join(path, '.gitignore'), 'w', 0600, :encoding => 'utf-8') do |f|
         f << <<-GITIGNORE
 gitignored.*
 gitdirectory/sub/**
 gitdirectory/git*
 !gitimportantfile
+git\u16A0\u16C7\u16BB
 GITIGNORE
       end
     end
 
     def create_symlink_gitignore_file
-      Puppet::FileSystem.open(File.join(path, '.gitignore'), 0600, 'w') do |f|
+      File.open(File.join(path, '.gitignore'), 'w', 0600, :encoding => 'utf-8') do |f|
         f << <<-GITIGNORE
 symlinkfile
     GITIGNORE
@@ -152,6 +156,10 @@ symlinkfile
         expect(target_exists?('gitignored.foo')).to eq true
       end
 
+      it "leaves UTF-8 files" do
+        expect(target_exists?("git\u16A0\u16C7\u16BB")).to eq true
+      end
+
       it "leaves directories" do
         expect(target_exists?('gitdirectory')).to eq true
       end
@@ -178,6 +186,10 @@ symlinkfile
         expect(target_exists?('gitignored.foo')).to eq false
       end
 
+      it "ignores UTF-8 files" do
+        expect(target_exists?("git\u16A0\u16C7\u16BB")).to eq false
+      end
+
       it "ignores directories" do
         expect(target_exists?('gitdirectory')).to eq true
       end
@@ -204,6 +216,10 @@ symlinkfile
         expect(target_exists?('pmtignored.foo')).to eq true
       end
 
+      it "leaves UTF-8 files" do
+        expect(target_exists?("pmt\u16A0\u16C7\u16BB")).to eq true
+      end
+
       it "leaves directories" do
         expect(target_exists?('pmtdirectory')).to eq true
       end
@@ -230,6 +246,10 @@ symlinkfile
         expect(target_exists?('pmtignored.foo')).to eq false
       end
 
+      it "ignores UTF-8 files" do
+        expect(target_exists?("pmt\u16A0\u16C7\u16BB")).to eq false
+      end
+
       it "ignores directories" do
         expect(target_exists?('pmtdirectory')).to eq true
       end
@@ -319,7 +339,7 @@ symlinkfile
       end
 
       it "give an error about symlinks" do
-        expect { builder.run }.to raise_error
+        expect { builder.run }.to raise_error(Puppet::ModuleTool::Errors::ModuleToolError, /Found symlinks/)
       end
     end
 
@@ -338,17 +358,24 @@ symlinkfile
   end
 
   context 'with metadata.json' do
+    # different UTF-8 widths
+    # 1-byte A
+    # 2-byte ۿ - http://www.fileformat.info/info/unicode/char/06ff/index.htm - 0xDB 0xBF / 219 191
+    # 3-byte ᚠ - http://www.fileformat.info/info/unicode/char/16A0/index.htm - 0xE1 0x9A 0xA0 / 225 154 160
+    # 4-byte 𠜎 - http://www.fileformat.info/info/unicode/char/2070E/index.htm - 0xF0 0xA0 0x9C 0x8E / 240 160 156 142
+    MIXED_UTF8 = "A\u06FF\u16A0\u{2070E}" # Aۿᚠ𠜎
+
     before :each do
       File.open(File.join(path, 'metadata.json'), 'w') do |f|
         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",
+          "summary" => "#{MIXED_UTF8}",
           "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
@@ -373,6 +400,14 @@ symlinkfile
         builder.run
       }.to raise_error Puppet::ModuleTool::Errors::ModuleToolError, /symlinks/i
     end
+
+    it "writes UTF-8 metdata correctly" do
+      # file is written initially in before block, then by builders write_json method
+      builder.run
+      metadata_path = File.join(path, 'metadata.json')
+      summary = JSON.parse(Puppet::FileSystem.read(metadata_path, :encoding => Encoding::UTF_8))["summary"]
+      expect(summary).to eq(MIXED_UTF8)
+    end
   end
 
   context 'with metadata.json containing checksums' do
@@ -381,12 +416,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/module_tool/applications/installer_spec.rb

@@ -4,6 +4,8 @@ require 'puppet_spec/module_tool/shared_functions'
 require 'puppet_spec/module_tool/stub_source'
 require 'semver'
 
+require 'tmpdir'
+
 describe Puppet::ModuleTool::Applications::Installer do
   include PuppetSpec::ModuleTool::SharedFunctions
   include PuppetSpec::Files
@@ -27,11 +29,18 @@ describe Puppet::ModuleTool::Applications::Installer do
   end
 
   before do
-    Semantic::Dependency.clear_sources
+    SemanticPuppet::Dependency.clear_sources
     installer = Puppet::ModuleTool::Applications::Installer.any_instance
     installer.stubs(:module_repository).returns(remote_source)
   end
 
+  if Puppet.features.microsoft_windows?
+    before :each do
+      Puppet.settings.stubs(:[])
+      Puppet.settings.stubs(:[]).with(:module_working_dir).returns(Dir.mktmpdir('installertmp'))
+    end
+  end
+
   def installer(modname, target_dir, options)
     Puppet::ModuleTool.set_option_defaults(options)
     Puppet::ModuleTool::Applications::Installer.new(modname, target_dir, options)
@@ -358,6 +367,6 @@ describe Puppet::ModuleTool::Applications::Installer do
         end
       end
     end
-
   end
+
 end

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

@@ -14,7 +14,8 @@ describe Puppet::ModuleTool::Applications::Unpacker do
   let(:working_dir) { tmpdir("working_dir") }
 
   before :each do
-    Puppet.settings[:module_working_dir] = working_dir
+    Puppet.settings.stubs(:[])
+    Puppet.settings.stubs(:[]).with(:module_working_dir).returns(working_dir)
   end
 
   it "should attempt to untar file to temporary location" do

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

@@ -3,6 +3,7 @@ require 'puppet/module_tool/applications'
 require 'puppet_spec/module_tool/shared_functions'
 require 'puppet_spec/module_tool/stub_source'
 require 'semver'
+require 'tmpdir'
 
 describe Puppet::ModuleTool::Applications::Upgrader do
   include PuppetSpec::ModuleTool::SharedFunctions
@@ -26,11 +27,18 @@ describe Puppet::ModuleTool::Applications::Upgrader do
   end
 
   before do
-    Semantic::Dependency.clear_sources
+    SemanticPuppet::Dependency.clear_sources
     installer = Puppet::ModuleTool::Applications::Upgrader.any_instance
     installer.stubs(:module_repository).returns(remote_source)
   end
 
+  if Puppet.features.microsoft_windows?
+    before :each do
+      Puppet.settings.stubs(:[])
+      Puppet.settings.stubs(:[]).with(:module_working_dir).returns(Dir.mktmpdir('upgradertmp'))
+    end
+  end
+
   def upgrader(name, options = {})
     Puppet::ModuleTool.set_option_defaults(options)
     Puppet::ModuleTool::Applications::Upgrader.new(name, options)

data/spec/unit/module_tool/installed_modules_spec.rb

@@ -19,21 +19,21 @@ describe Puppet::ModuleTool::InstalledModules do
   it 'works when given a semantic version' do
     mod = PuppetSpec::Modules.create('goodsemver', @modpath, :metadata => {:version => '1.2.3'})
     installed = described_class.new(@env)
-    expect(installed.modules["puppetlabs-#{mod.name}"].version).to eq(Semantic::Version.parse('1.2.3'))
+    expect(installed.modules["puppetlabs-#{mod.name}"].version).to eq(SemanticPuppet::Version.parse('1.2.3'))
   end
 
   it 'defaults when not given a semantic version' do
     mod = PuppetSpec::Modules.create('badsemver', @modpath, :metadata => {:version => 'banana'})
     Puppet.expects(:warning).with(regexp_matches(/Semantic Version/))
     installed = described_class.new(@env)
-    expect(installed.modules["puppetlabs-#{mod.name}"].version).to eq(Semantic::Version.parse('0.0.0'))
+    expect(installed.modules["puppetlabs-#{mod.name}"].version).to eq(SemanticPuppet::Version.parse('0.0.0'))
   end
 
   it 'defaults when not given a full semantic version' do
     mod = PuppetSpec::Modules.create('badsemver', @modpath, :metadata => {:version => '1.2'})
     Puppet.expects(:warning).with(regexp_matches(/Semantic Version/))
     installed = described_class.new(@env)
-    expect(installed.modules["puppetlabs-#{mod.name}"].version).to eq(Semantic::Version.parse('0.0.0'))
+    expect(installed.modules["puppetlabs-#{mod.name}"].version).to eq(SemanticPuppet::Version.parse('0.0.0'))
   end
 
   it 'still works if there is an invalid version in one of the modules' do
@@ -42,8 +42,8 @@ describe Puppet::ModuleTool::InstalledModules do
     mod3 = PuppetSpec::Modules.create('notquitesemver', @modpath, :metadata => {:version => '1.2'})
     Puppet.expects(:warning).with(regexp_matches(/Semantic Version/)).twice
     installed = described_class.new(@env)
-    expect(installed.modules["puppetlabs-#{mod1.name}"].version).to eq(Semantic::Version.parse('0.0.0'))
-    expect(installed.modules["puppetlabs-#{mod2.name}"].version).to eq(Semantic::Version.parse('1.2.3'))
-    expect(installed.modules["puppetlabs-#{mod3.name}"].version).to eq(Semantic::Version.parse('0.0.0'))
+    expect(installed.modules["puppetlabs-#{mod1.name}"].version).to eq(SemanticPuppet::Version.parse('0.0.0'))
+    expect(installed.modules["puppetlabs-#{mod2.name}"].version).to eq(SemanticPuppet::Version.parse('1.2.3'))
+    expect(installed.modules["puppetlabs-#{mod3.name}"].version).to eq(SemanticPuppet::Version.parse('0.0.0'))
   end
 end

data/spec/unit/module_tool/metadata_spec.rb

@@ -9,7 +9,7 @@ describe Puppet::ModuleTool::Metadata do
     subject { metadata }
 
     %w[ name version author summary license source project_page issues_url
-    dependencies dashed_name release_name description ].each do |prop|
+    dependencies dashed_name release_name description data_provider].each do |prop|
       describe "##{prop}" do
         it "responds to the property" do
           subject.send(prop)
@@ -224,6 +224,35 @@ describe Puppet::ModuleTool::Metadata do
         expect(subject.dependencies.size).to eq(1)
       end
     end
+
+    context 'with valid data_provider' do
+      let(:data) { {'data_provider' => 'the_name'} }
+
+      it 'validates the provider correctly' do
+        expect { subject }.not_to raise_error
+      end
+
+      it 'returns the provider' do
+        expect(subject.data_provider).to eq('the_name')
+      end
+    end
+
+    context 'with invalid data_provider' do
+      let(:data) { }
+
+      it "raises exception unless argument starts with a letter" do
+        expect { metadata.update('data_provider' => '_the_name') }.to raise_error(ArgumentError, /field 'data_provider' must begin with a letter/)
+        expect { metadata.update('data_provider' => '') }.to raise_error(ArgumentError, /field 'data_provider' must begin with a letter/)
+      end
+
+      it "raises exception if argument contains non-alphanumeric characters" do
+        expect { metadata.update('data_provider' => 'the::name') }.to raise_error(ArgumentError, /field 'data_provider' contains non-alphanumeric characters/)
+      end
+
+      it "raises exception unless argument is a string" do
+        expect { metadata.update('data_provider' => 23) }.to raise_error(ArgumentError, /field 'data_provider' must be a string/)
+      end
+    end
   end
 
   describe '#dashed_name' do
@@ -271,7 +300,7 @@ describe Puppet::ModuleTool::Metadata do
     subject { metadata.to_hash }
 
     it "contains the default set of keys" do
-      expect(subject.keys.sort).to eq(%w[ name version author summary license source issues_url project_page dependencies ].sort)
+      expect(subject.keys.sort).to eq(%w[ name version author summary license source issues_url project_page dependencies data_provider].sort)
     end
 
     describe "['license']" do

data/spec/unit/module_tool/tar/mini_spec.rb

@@ -20,7 +20,7 @@ describe Puppet::ModuleTool::Tar::Mini, :if => (Puppet.features.minitar? and Pup
     expect {
       minitar.unpack(sourcefile, destdir, 'uid')
     }.to raise_error(Puppet::ModuleTool::Errors::InvalidPathInPackageError,
-                     "Attempt to install file into \"/thefile\" under \"#{destdir}\"")
+                     "Attempt to install file with an invalid path into \"/thefile\" under \"#{destdir}\"")
   end
 
   it "does not allow a file to be written outside the destination directory" do
@@ -29,7 +29,7 @@ describe Puppet::ModuleTool::Tar::Mini, :if => (Puppet.features.minitar? and Pup
     expect {
       minitar.unpack(sourcefile, destdir, 'uid')
     }.to raise_error(Puppet::ModuleTool::Errors::InvalidPathInPackageError,
-                     "Attempt to install file into \"#{File.expand_path('/the/thefile')}\" under \"#{destdir}\"")
+                     "Attempt to install file with an invalid path into \"#{File.expand_path('/the/thefile')}\" under \"#{destdir}\"")
   end
 
   it "does not allow a directory to be written outside the destination directory" do
@@ -38,7 +38,7 @@ describe Puppet::ModuleTool::Tar::Mini, :if => (Puppet.features.minitar? and Pup
     expect {
       minitar.unpack(sourcefile, destdir, 'uid')
     }.to raise_error(Puppet::ModuleTool::Errors::InvalidPathInPackageError,
-                     "Attempt to install file into \"#{File.expand_path('/the/thedir')}\" under \"#{destdir}\"")
+                     "Attempt to install file with an invalid path into \"#{File.expand_path('/the/thedir')}\" under \"#{destdir}\"")
   end
 
   it "packs a tar file" do

data/spec/unit/module_tool_spec.rb

@@ -288,21 +288,21 @@ TREE
     it 'parses a dependency without a version range expression' do
       name, range, expr = subject.parse_module_dependency('source', 'name' => 'foo-bar')
       expect(name).to eql('foo-bar')
-      expect(range).to eql(Semantic::VersionRange.parse('>= 0.0.0'))
+      expect(range).to eql(SemanticPuppet::VersionRange.parse('>= 0.0.0'))
       expect(expr).to eql('>= 0.0.0')
     end
 
     it 'parses a dependency with a version range expression' do
       name, range, expr = subject.parse_module_dependency('source', 'name' => 'foo-bar', 'version_requirement' => '1.2.x')
       expect(name).to eql('foo-bar')
-      expect(range).to eql(Semantic::VersionRange.parse('1.2.x'))
+      expect(range).to eql(SemanticPuppet::VersionRange.parse('1.2.x'))
       expect(expr).to eql('1.2.x')
     end
 
     it 'does not raise an error on invalid version range expressions' do
       name, range, expr = subject.parse_module_dependency('source', 'name' => 'foo-bar', 'version_requirement' => 'nope')
       expect(name).to eql('foo-bar')
-      expect(range).to eql(Semantic::VersionRange::EMPTY_RANGE)
+      expect(range).to eql(SemanticPuppet::VersionRange::EMPTY_RANGE)
       expect(expr).to eql('nope')
     end
   end

data/spec/unit/network/auth_config_parser_spec.rb

@@ -4,6 +4,7 @@ require 'puppet/network/auth_config_parser'
 require 'puppet/network/authconfig'
 
 describe Puppet::Network::AuthConfigParser do
+  include PuppetSpec::Files
 
   let(:fake_authconfig) do
     "path ~ ^/catalog/([^/])\nmethod find\nallow *\n"
@@ -98,4 +99,19 @@ describe Puppet::Network::AuthConfigParser do
       described_class.new("path /certificates\nauthenticated yes").parse_rights
     end
   end
+
+  describe "when parsing rights from files" do
+    it "can read UTF-8" do
+      rune_path = "/\u16A0\u16C7\u16BB" # ᚠᛇᚻ
+      config = tmpfile('config')
+
+      File.open(config, 'w', :encoding => 'utf-8') do |file|
+        file.puts <<-EOF
+path #{rune_path}
+      EOF
+    end
+
+      expect(described_class.new_from_file(config).parse_rights[rune_path]).to be
+    end
+  end
 end