r10k 2.0.3 → 2.1.0

data/spec/unit/puppet_forge/connection/connection_failure_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-require 'shared/puppet_forge/connection/connection_failure'
-
-describe PuppetForge::Connection::ConnectionFailure do
-
-  subject do
-    Faraday.new('https://my-site.url/some-path') do |builder|
-      builder.use(:connection_failure)
-
-      builder.adapter :test do |stub|
-        stub.get('/connectfail') { raise Faraday::ConnectionFailed.new(SocketError.new("getaddrinfo: Name or service not known"), :hi) }
-      end
-    end
-  end
-
-  it "includes the base URL in the error message" do
-    expect {
-      subject.get('/connectfail')
-    }.to raise_error(Faraday::ConnectionFailed, "Unable to connect to https://my-site.url: getaddrinfo: Name or service not known")
-  end
-
-  it "includes the proxy host in the error message when set" do
-    subject.proxy('https://some-unreachable.proxy:3128')
-    expect {
-      subject.get('/connectfail')
-    }.to raise_error(Faraday::ConnectionFailed, "Unable to connect to https://my-site.url (using proxy https://some-unreachable.proxy:3128): getaddrinfo: Name or service not known")
-  end
-end

data/spec/unit/puppet_forge/connection_spec.rb

@@ -1,41 +0,0 @@
-require 'shared/puppet_forge/connection'
-
-describe PuppetForge::Connection do
-
-  let(:extended) { Object.new.extend(described_class) }
-
-  describe 'creating a new connection' do
-
-    let(:faraday_stubs) { Faraday::Adapter::Test::Stubs.new }
-
-    subject { extended.make_connection('https://some.site/url', [:test, faraday_stubs]) }
-
-    it 'parses response bodies with a JSON content-type into a hash' do
-      faraday_stubs.get('/json') { [200, {'Content-Type' => 'application/json'}, '{"hello": "world"}'] }
-      expect(subject.get('/json').body).to eq('hello' => 'world')
-    end
-
-    it 'returns the response body as-is when the content-type is not JSON' do
-      faraday_stubs.get('/binary') { [200, {'Content-Type' => 'application/octet-stream'}, 'I am a big bucket of binary data'] }
-      expect(subject.get('/binary').body).to eq('I am a big bucket of binary data')
-    end
-
-    it 'raises errors when the request has an error status code' do
-      faraday_stubs.get('/error') { [503, {}, "The server caught fire and cannot service your request right now"] }
-
-      expect {
-        subject.get('/error')
-      }.to raise_error(Faraday::ClientError, "the server responded with status 503")
-    end
-
-    context 'when an authorization value is provided' do
-      before(:each) do
-        allow(described_class).to receive(:authorization).and_return("auth-test value")
-      end
-
-      it 'sets authorization header on requests' do
-        expect(subject.headers).to include(:authorization => "auth-test value")
-      end
-    end
-  end
-end

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

@@ -1,87 +0,0 @@
-require 'shared/puppet_forge/tar/mini'
-require 'shared/puppet_forge/error'
-
-
-describe PuppetForge::Tar::Mini do
-  let(:entry_class) do
-    Class.new do
-      attr_accessor :typeflag, :name
-      def initialize(name, typeflag)
-        @name = name
-        @typeflag = typeflag
-      end
-    end
-  end
-  let(:sourcefile) { '/the/module.tar.gz' }
-  let(:destdir)    { File.expand_path '/the/dest/dir' }
-  let(:sourcedir)  { '/the/src/dir' }
-  let(:destfile)   { '/the/dest/file.tar.gz' }
-  let(:minitar)    { described_class.new }
-  let(:tarfile_contents) { [entry_class.new('file', '0'), \
-                            entry_class.new('symlink', '2'), \
-                            entry_class.new('invalid', 'F')] }
-
-  it "unpacks a tar file" do
-    unpacks_the_entry(:file_start, 'thefile')
-
-    minitar.unpack(sourcefile, destdir)
-  end
-
-  it "does not allow an absolute path" do
-    unpacks_the_entry(:file_start, '/thefile')
-
-    expect {
-      minitar.unpack(sourcefile, destdir)
-    }.to raise_error(PuppetForge::InvalidPathInPackageError,
-                     "Attempt to install file into \"/thefile\" under \"#{destdir}\"")
-  end
-
-  it "does not allow a file to be written outside the destination directory" do
-    unpacks_the_entry(:file_start, '../../thefile')
-
-    expect {
-      minitar.unpack(sourcefile, destdir)
-    }.to raise_error(PuppetForge::InvalidPathInPackageError,
-                     "Attempt to install file into \"#{File.expand_path('/the/thefile')}\" under \"#{destdir}\"")
-  end
-
-  it "does not allow a directory to be written outside the destination directory" do
-    unpacks_the_entry(:dir, '../../thedir')
-
-    expect {
-      minitar.unpack(sourcefile, destdir)
-    }.to raise_error(PuppetForge::InvalidPathInPackageError,
-                     "Attempt to install file into \"#{File.expand_path('/the/thedir')}\" under \"#{destdir}\"")
-  end
-
-  it "packs a tar file" do
-    writer = double('GzipWriter')
-
-    expect(Zlib::GzipWriter).to receive(:open).with(destfile).and_yield(writer)
-    expect(Archive::Tar::Minitar).to receive(:pack).with(sourcedir, writer)
-
-    minitar.pack(sourcedir, destfile)
-  end
-
-  it "returns filenames in a tar separated into correct categories" do
-    reader = double('GzipReader')
-
-    expect(Zlib::GzipReader).to receive(:open).with(sourcefile).and_yield(reader)
-    expect(Archive::Tar::Minitar).to receive(:open).with(reader).and_return(tarfile_contents)
-    expect(Archive::Tar::Minitar).to receive(:unpack).with(reader, destdir, ['file']).and_yield(:file_start, 'thefile', nil)
-    
-    file_lists = minitar.unpack(sourcefile, destdir)
-
-    expect(file_lists[:valid]).to eq(['file'])
-    expect(file_lists[:invalid]).to eq(['invalid'])
-    expect(file_lists[:symlinks]).to eq(['symlink'])
-  end
-
-  def unpacks_the_entry(type, name)
-    reader = double('GzipReader')
-
-    expect(Zlib::GzipReader).to receive(:open).with(sourcefile).and_yield(reader)
-    expect(minitar).to receive(:validate_files).with(reader).and_return({:valid => [name]})
-    expect(Archive::Tar::Minitar).to receive(:unpack).with(reader, destdir, [name]).and_yield(type, name, nil)
-  end
-end

data/spec/unit/puppet_forge/tar_spec.rb

@@ -1,9 +0,0 @@
-require 'shared/puppet_forge/tar'
-
-describe PuppetForge::Tar do
-
-  it "returns an instance of minitar" do
-    expect(described_class.instance).to be_a_kind_of PuppetForge::Tar::Mini
-  end
-
-end

data/spec/unit/puppet_forge/unpacker_spec.rb

@@ -1,59 +0,0 @@
-require 'json'
-require 'tmpdir'
-require 'shared/puppet_forge/unpacker'
-
-describe PuppetForge::Unpacker do
-
-  let(:source)      { Dir.mktmpdir("source") }
-  let(:target)      { Dir.mktmpdir("unpacker") }
-  let(:module_name) { 'myusername-mytarball' }
-  let(:filename)    { Dir.mktmpdir("module") + "/module.tar.gz" }
-  let(:working_dir) { Dir.mktmpdir("working_dir") }
-  let(:trash_dir)   { Dir.mktmpdir("trash_dir") }
-
-  it "attempts to untar file to temporary location" do
-
-    minitar = double('PuppetForge::Tar::Mini')
-
-    expect(minitar).to receive(:unpack).with(filename, anything()) do |src, dest|
-      FileUtils.mkdir(File.join(dest, 'extractedmodule'))
-      File.open(File.join(dest, 'extractedmodule', 'metadata.json'), 'w+') do |file|
-        file.puts JSON.generate('name' => module_name, 'version' => '1.0.0')
-      end
-      true
-    end
-
-    expect(PuppetForge::Tar).to receive(:instance).and_return(minitar)
-    PuppetForge::Unpacker.unpack(filename, target, trash_dir)
-    expect(File).to be_directory(target)
-  end
-
-  it "returns the appropriate categories of the contents of the tar file from the tar implementation" do
-
-    minitar = double('PuppetForge::Tar::Mini')
-
-    expect(minitar).to receive(:unpack).with(filename, anything()) do |src, dest|
-      FileUtils.mkdir(File.join(dest, 'extractedmodule'))
-      File.open(File.join(dest, 'extractedmodule', 'metadata.json'), 'w+') do |file|
-        file.puts JSON.generate('name' => module_name, 'version' => '1.0.0')
-      end
-      { :valid => [File.join('extractedmodule', 'metadata.json')], :invalid => [], :symlinks => [] }
-    end
-
-    expect(PuppetForge::Tar).to receive(:instance).and_return(minitar)
-    file_lists = PuppetForge::Unpacker.unpack(filename, target, trash_dir)
-    expect(file_lists).to eq({:valid=>["extractedmodule/metadata.json"], :invalid=>[], :symlinks=>[]})
-    expect(File).to be_directory(target)
-  end
-
-  it "attempts to set the ownership of a target dir to a source dir's owner" do
-
-    source_path = Pathname.new(source)
-    target_path = Pathname.new(target)
-
-    expect(FileUtils).to receive(:chown_R).with(source_path.stat.uid, source_path.stat.gid, target_path)
-
-    PuppetForge::Unpacker.harmonize_ownership(source_path, target_path)
-  end
-
-end

data/spec/unit/puppet_forge/v3/module_release_spec.rb

@@ -1,83 +0,0 @@
-require 'shared/puppet_forge/v3/module_release'
-
-describe PuppetForge::V3::ModuleRelease do
-
-  subject { described_class.new('username-modulename', '3.1.4') }
-
-  let(:faraday_stubs) { Faraday::Adapter::Test::Stubs.new }
-
-  let(:conn) do
-    Faraday.new do |builder|
-      builder.response(:raise_error)
-      builder.adapter :test, faraday_stubs
-    end
-  end
-
-  before do
-    subject.conn = conn
-  end
-
-  it "creates a slug from the full_name and version" do
-    expect(subject.slug).to eq 'username-modulename-3.1.4'
-  end
-
-
-  describe '#data' do
-    it 'returns the body of the response' do
-      faraday_stubs.get('/v3/releases/username-modulename-3.1.4') { [200, {}, {'metadata' => 'yep'}] }
-      expect(subject.data).to eq('metadata' => 'yep')
-    end
-
-    it 'raises an error if the module release does not exist' do
-      faraday_stubs.get('/v3/releases/username-modulename-3.1.4') { [404, {}, {'metadata' => 'yep'}] }
-      expect {
-        subject.data
-      }.to raise_error(PuppetForge::ModuleReleaseNotFound, /The module release username-modulename-3\.1\.4 does not exist/)
-    end
-  end
-
-  describe '#download' do
-    it 'downloads the file to the provided path' do
-      faraday_stubs.get('/v3/files/username-modulename-3.1.4.tar.gz') { [200, {}, "I'm a file!"] }
-
-      path = Pathname.new('/some/path')
-      io   = instance_double('IO')
-
-      expect(path).to receive(:open).with('wb').and_yield io
-      expect(io).to receive(:write).with("I'm a file!")
-
-      subject.download(path)
-    end
-
-    it 'raises an error if the module release does not exist' do
-      faraday_stubs.get('/v3/files/username-modulename-3.1.4.tar.gz') { [404, {}, 'not found'] }
-      expect {
-        subject.download(Pathname.new('/some/path'))
-      }.to raise_error(PuppetForge::ModuleReleaseNotFound, /The module release username-modulename-3\.1\.4 does not exist/)
-    end
-  end
-
-  describe '#verify' do
-    let(:digest) { instance_double('Digest::MD5') }
-
-    let(:path) { Pathname.new('/some/path') }
-
-    it "returns without error when the checksum matches" do
-      expect(Digest::MD5).to receive(:file).with(path).and_return(digest)
-      expect(digest).to receive(:hexdigest).and_return('823fe0a11fc0ef23a5853e2791880c9b')
-      expect(subject).to receive(:data).and_return('file_md5' => '823fe0a11fc0ef23a5853e2791880c9b')
-
-      subject.verify(path)
-    end
-
-    it "raises an error when the checksum doesn't match" do
-      expect(Digest::MD5).to receive(:file).with(path).and_return(digest)
-      expect(digest).to receive(:hexdigest).and_return('00000000000000000000000000000000')
-      expect(subject).to receive(:data).and_return('file_md5' => '823fe0a11fc0ef23a5853e2791880c9b')
-
-      expect {
-        subject.verify(path)
-      }.to raise_error(PuppetForge::V3::ModuleRelease::ChecksumMismatch, 'Expected /some/path checksum to be 823fe0a11fc0ef23a5853e2791880c9b, got 00000000000000000000000000000000')
-    end
-  end
-end

data/spec/unit/puppet_forge/v3/module_spec.rb

@@ -1,75 +0,0 @@
-require 'shared/puppet_forge/v3/module'
-
-describe PuppetForge::V3::Module do
-  subject { described_class.new('authorname-modulename') }
-
-  let(:faraday_stubs) { Faraday::Adapter::Test::Stubs.new }
-
-  let(:conn) do
-    Faraday.new do |builder|
-      builder.response(:raise_error)
-      builder.adapter :test, faraday_stubs
-    end
-  end
-
-  before do
-    subject.conn = conn
-  end
-
-  let(:releases_without_deletions) do
-      {"releases" => [
-          {"version" => "1.0.1"},
-          {"version" => "1.0.0"},
-          {"version" => "0.9.0"}
-        ]
-      }
-  end
-
-  let(:releases_with_deletions) do
-    {"releases" => [
-        {"version" => "0.4.0", "deleted_at" => "some point"},
-        {"version" => "0.3.0"}
-      ]
-    }
-  end
-
-  describe '#release' do
-    it 'creates a release object for the module with the given version' do
-      release = subject.release('3.1.4')
-      expect(release.slug).to eq 'authorname-modulename-3.1.4'
-    end
-
-    it 'passes along the module connection object' do
-      conn = Object.new
-      subject.conn = conn
-      release = subject.release('3.1.4')
-      expect(release.conn).to eq conn
-    end
-  end
-
-  describe '#versions' do
-    it "returns all module release versions" do
-      faraday_stubs.get('/v3/modules/authorname-modulename') { [200, {}, releases_without_deletions] }
-      expect(subject.versions).to eq ["0.9.0", "1.0.0", "1.0.1"]
-    end
-
-    it "ignores deleted releases" do
-      faraday_stubs.get('/v3/modules/authorname-modulename') { [200, {}, releases_with_deletions] }
-      expect(subject.versions).to eq ["0.3.0"]
-    end
-
-    it "raises an error when the module does not exist" do
-      faraday_stubs.get('/v3/modules/authorname-modulename') { [404, {}, ''] }
-      expect {
-        subject.versions
-      }.to raise_error(PuppetForge::ModuleNotFound, /The module authorname-modulename does not exist/)
-    end
-  end
-
-  describe '#latest_version' do
-    it "returns the most recent version" do
-      faraday_stubs.get('/v3/modules/authorname-modulename') { [200, {}, releases_without_deletions] }
-      expect(subject.latest_version).to eq '1.0.1'
-    end
-  end
-end