akabei 0.1.0

data/spec/akabei/builder_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+require 'akabei/builder'
+require 'akabei/signer'
+
+describe Akabei::Builder do
+  let(:builder) { described_class.new }
+  let(:pkgdest) { test_dest('packages').tap(&:mkpath) }
+  let(:package_dir) { test_dest('nkf').tap(&:mkpath) }
+  let(:pkgname) { 'nkf-2.1.3-1' }
+  let(:arch) { 'x86_64' }
+  let(:src_fname) { 'nkf-2.1.3.tar.gz' }
+  let(:pkg_fname) { "#{pkgname}-#{arch}.pkg.tar.xz" }
+  let(:log_build_fname) { "#{pkgname}-#{arch}-build.log" }
+  let(:log_package_fname) { "#{pkgname}-#{arch}-package.log" }
+  let(:srcpkg_fname) { "#{pkgname}.src.tar.gz" }
+
+  before do
+    builder.pkgdest = pkgdest
+  end
+
+  describe '#build_package' do
+    let(:chroot) { double('ChrootTree') }
+
+    before do
+      expect(chroot).to receive(:makechrootpkg).once.with(package_dir.to_s, anything) { |dir, env|
+        expect(env[:SRCDEST]).to be_directory
+        expect(env[:PKGDEST]).to be_directory
+        expect(env[:LOGDEST]).to be_directory
+
+        env[:PKGDEST].join(pkg_fname).open('w') {}
+        env[:SRCDEST].join(src_fname).open('w') {}
+        env[:LOGDEST].join(log_build_fname).open('w') {}
+        env[:LOGDEST].join(log_package_fname).open('w') {}
+      }
+    end
+
+    it 'executes makechrootpkg' do
+      packages = builder.build_package(package_dir, chroot)
+      expect(packages.size).to eq(1)
+      package = packages.first
+      expect(package.path).to eq(pkgdest.join(pkg_fname))
+      expect(package.path).to be_readable
+    end
+
+    context 'with signer' do
+      let(:signer) { double('Signer') }
+
+      before do
+        builder.signer = signer
+      end
+
+      it 'creates a detached signature' do
+        expect(signer).to receive(:detach_sign).once { |path|
+          File.open("#{path}.sig", 'w') {}
+        }
+
+        packages = builder.build_package(package_dir, chroot)
+        expect(packages.size).to eq(1)
+        package = packages.first
+        expect(pkgdest.join("#{pkg_fname}.sig")).to be_readable
+      end
+
+      it "doesn't leave packages if signing failed" do
+        expect(signer).to receive(:detach_sign).once.and_raise(Akabei::Signer::InvalidSignature.new(double('path'), double('from')))
+
+        expect { builder.build_package(package_dir, chroot) }.to raise_error(Akabei::Signer::InvalidSignature)
+        expect(pkgdest.join(pkg_fname)).to_not be_readable
+      end
+    end
+
+    context 'with srcdest' do
+      let(:dest) { test_dest('sources').tap(&:mkpath) }
+
+      before do
+        builder.srcdest = dest
+      end
+
+      it 'stores sources' do
+        builder.build_package(package_dir, chroot)
+        expect(dest.join(src_fname)).to be_readable
+      end
+    end
+
+    context 'with logdest' do
+      let(:dest) { test_dest('logs').tap(&:mkpath) }
+
+      before do
+        builder.logdest = dest
+      end
+
+      it 'stores logs' do
+        builder.build_package(package_dir, chroot)
+        expect(dest.join(log_build_fname)).to be_readable
+        expect(dest.join(log_package_fname)).to be_readable
+      end
+    end
+  end
+
+  describe '#with_source_package' do
+    before do
+      expect(builder).to receive(:system).once.with(any_args) { |env, makepkg, source, opts|
+        srcdest = Pathname.new(env['SRCDEST'])
+        srcpkgdest = Pathname.new(env['SRCPKGDEST'])
+        builddir = Pathname.new(env['BUILDDIR'])
+        expect(srcdest).to be_directory
+        expect(srcpkgdest).to be_directory
+        expect(builddir).to be_directory
+
+        expect(makepkg).to eq('makepkg')
+        expect(source).to eq('--source')
+        expect(opts[:chdir]).to eq(package_dir)
+
+        # Simulate `makepkg --source`
+        srcdest.join(src_fname).open('w') {}
+        srcpkgdest.join(srcpkg_fname).open('w') { |f| f.write('AKABEI SPEC') }
+        builddir.join('nkf').mkpath
+        Pathname.new(opts[:chdir]).join(srcpkg_fname).make_symlink(srcpkgdest.join(srcpkg_fname))
+        true
+      }
+    end
+
+    it 'creates only source package' do
+      builder.with_source_package(package_dir) do |srcpkg|
+        expect(srcpkg).to be_readable
+        expect(srcpkg.read).to eq('AKABEI SPEC')
+      end
+    end
+  end
+end

data/spec/akabei/chroot_tree_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+require 'akabei/chroot_tree'
+
+describe Akabei::ChrootTree do
+  let(:arch) { 'x86_64' }
+  let(:chroot_root) { Pathname.new('/tmp') }
+  let(:chroot) { described_class.new(chroot_root, arch) }
+
+  describe '#with_chroot' do
+    let(:action) { double('some action') }
+
+    before do
+      allow(chroot).to receive(:execute) { nil }
+      expect(action).to receive(:call).once
+    end
+
+    context 'without root' do
+      let(:chroot_root) { nil }
+
+      it 'creates a temporary chroot' do
+        expect(chroot).to receive(:mkarchroot).once
+        expect(Dir).to receive(:mktmpdir).once.and_call_original
+
+        chroot.with_chroot { action.call }
+      end
+    end
+
+    context 'with root' do
+      it 'uses given root' do
+        expect(Dir).to_not receive(:mktmpdir)
+        expect(chroot).to receive(:execute).once.with(any_args) { |*args|
+          expect(args[0]).to eq('mkarchroot')
+          expect(args[1]).to eq(chroot_root.join('root').to_s)
+        }
+
+        chroot.with_chroot { action.call }
+      end
+    end
+
+    it 'respects makepkg_config' do
+      path = '/path/to/makepkg.conf'
+      chroot.makepkg_config = path
+      expect(chroot).to receive(:execute).once.with(any_args) { |*args|
+        expect(args[0]).to eq('mkarchroot')
+        expect(args.each_cons(2)).to include(['-M', path])
+      }
+
+      chroot.with_chroot { action.call }
+    end
+
+    it 'respects pacman_config' do
+      path = '/path/to/pacman.conf'
+      chroot.pacman_config = path
+      expect(chroot).to receive(:execute).once.with(any_args) { |*args|
+        expect(args[0]).to eq('mkarchroot')
+        expect(args.each_cons(2)).to include(['-C', path])
+      }
+
+      chroot.with_chroot { action.call }
+    end
+  end
+
+  describe '#execute' do
+    let(:command) { %w[rm -rf /] }
+    let(:opts) { { chdir: '/' } }
+
+    it 'calls sudo and setarch' do
+      expect(chroot).to receive(:system).once.with(any_args) { |*args|
+        expect(args).to eq(%W[sudo setarch #{arch}] + command + [opts])
+      }
+
+      stdout = capture_stdout do
+        chroot.execute(*command + [opts])
+      end
+      expect(stdout).to include('rm -rf /')
+    end
+
+    context 'with :env keyword' do
+      let(:key) { :FOO }
+      let(:value) { 'BAR' }
+
+      it 'calls sudo, setarch and env' do
+        expect(chroot).to receive(:system).once.with(any_args) { |*args|
+          expected_opts = opts.dup
+          expected_opts.delete(:env)
+          expect(args).to eq(%W[sudo setarch #{arch} env #{key}=#{value}] + command + [expected_opts])
+        }.and_return(true)
+
+        opts.merge!(env: { key => value })
+        stdout = capture_stdout do
+          chroot.execute(*command, opts)
+        end
+        expect(stdout).to include('rm -rf /')
+        expect(opts).to have_key(:env)
+      end
+
+      context 'with command failure' do
+        before do
+          allow(chroot).to receive(:system).and_return(false)
+        end
+
+        it 'raises an error' do
+          expect { capture_stdout { chroot.execute(command + [opts]) } }.to raise_error(Akabei::ChrootTree::CommandFailed)
+        end
+      end
+    end
+  end
+end

data/spec/akabei/cli_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+require 'akabei/cli'
+
+describe Akabei::CLI do
+end

data/spec/akabei/package_entry_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+require 'akabei/package_entry'
+
+describe Akabei::PackageEntry do
+  let(:entry) { described_class.new }
+
+  describe '#write_desc' do
+    it 'writes desc attributes' do
+      entry.add('name', 'akabei')
+      entry.add('desc', 'Custom repository manager for ArchLinux pacman')
+      entry.add('depends', 'ruby')
+
+      io = StringIO.new
+      entry.write_desc(io)
+      expect(io.string).to include('akabei')
+      expect(io.string).to include('pacman')
+      expect(io.string).to_not include('ruby')
+    end
+
+    it 'rejects multiple descs' do
+      entry.add('desc', 'Custom repository manager for ArchLinux pacman')
+      expect { entry.add('desc', 'Awful repository manager') }.to raise_error(Akabei::Error)
+      expect(entry.desc).not_to include('Awful')
+    end
+
+    it 'rejects unknown attribute' do
+      expect { entry.add('akabei', 'akabei') }.to raise_error(Akabei::Error)
+    end
+  end
+
+  describe '#write_depends' do
+    it 'writes depends attributes' do
+      entry.add('name', 'akabei')
+      entry.add('depends', 'ruby')
+      entry.add('makedepends', 'gcc')
+      entry.add('makedepends', 'rubygems')
+
+      io = StringIO.new
+      entry.write_depends(io)
+      expect(io.string).not_to include('akabei')
+      expect(io.string).to include('ruby')
+      expect(io.string).to include('gcc')
+      expect(io.string).to include('rubygems')
+    end
+  end
+
+  describe '#write_files' do
+    it 'writes files attribute' do
+      entry.add('name', 'gcc')
+      entry.add('files', '/usr/bin/gcov')
+      entry.add('files', '/usr/bin/g++')
+
+      io = StringIO.new
+      entry.write_files(io)
+      expect(io.string).to_not include('gcc')
+      expect(io.string).to include('gcov')
+      expect(io.string).to include('g++')
+    end
+
+    it 'warns if files is empty' do
+      entry.add('name', 'gcc')
+      entry.add('depends', 'glibc')
+
+      io = StringIO.new
+      stderr = capture_stderr { entry.write_files(io) }
+      expect(io.string).to be_empty
+      expect(stderr).to include('empty')
+    end
+  end
+end

data/spec/akabei/package_info_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+require 'akabei/package'
+
+describe Akabei::PackageInfo do
+  describe '.parse' do
+    it 'parses .PKGINFO' do
+      pkginfo = described_class.parse(test_input('ruby.PKGINFO').read)
+      expect(pkginfo.pkgver).to eq('2.1.0-2')
+      expect(pkginfo.pkgbase).to eq('ruby')
+      expect(pkginfo.provides).to match_array(%w[rake rubygems])
+      expect(pkginfo.group).to eq([])
+
+      pkginfo = described_class.parse(test_input('nkf.PKGINFO').read)
+      expect(pkginfo.pkgbase).to be_nil
+    end
+  end
+end

data/spec/akabei/package_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'akabei/package'
+
+describe Akabei::Package do
+  let(:package) { described_class.new(pkg_path) }
+  let(:pkg_path) { test_input('nkf-2.1.3-1-x86_64.pkg.tar.xz') }
+
+  describe '#pkginfo' do
+    it 'returns PackageInfo' do
+      pkginfo = package.pkginfo
+      expect(package.db_name).to eq('nkf-2.1.3-1')
+    end
+
+    context "when pkg_path doesn't exist" do
+      let(:pkg_path) { test_dest('does_not_exist.pkg.tar.xz') }
+
+      it 'raises an error' do
+        expect { package.pkginfo }.to raise_error(Archive::Error)
+      end
+    end
+
+    context 'with invalid archive' do
+      let(:pkg_path) { test_input('nkf.tar.gz') }
+
+      it 'raises an error' do
+        expect { package.pkginfo }.to raise_error(Akabei::Error)
+      end
+    end
+  end
+
+  describe '#to_entry' do
+    it 'returns PackageEntry' do
+      entry = package.to_entry
+      expect(entry.sha256sum).to eq('8543fc47ce33a24bc6c0670b045f4b0381dff1472df895879e9a2cf86835a57b')
+      expect(entry.pgpsig).to be_nil
+    end
+
+    context 'with detached signature file' do
+      let(:pkg_path) { test_dest('nkf.pkg.tar.xz') }
+      let(:signature) { 'SOME SIGNATURE' }
+
+      before do
+        FileUtils.cp(test_input('nkf-2.1.3-1-x86_64.pkg.tar.xz'), pkg_path)
+        File.open("#{pkg_path}.sig", 'w') { |f| f.write(signature) }
+      end
+
+      it 'returns PackageEntry with pgpsig' do
+        entry = package.to_entry
+        expect(entry.sha256sum).to eq('8543fc47ce33a24bc6c0670b045f4b0381dff1472df895879e9a2cf86835a57b')
+        expect(entry.pgpsig).to eq(Base64.strict_encode64(signature))
+      end
+    end
+  end
+end

data/spec/akabei/repository_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+require 'akabei/repository'
+require 'akabei/signer'
+
+describe Akabei::Repository do
+  let(:repo) { described_class.new }
+  let(:db_path) { test_input('test.db') }
+
+  describe '#load' do
+    context 'without database' do
+      let(:db_path) { test_dest('repo.db') }
+
+      it 'does nothing' do
+        repo.load(db_path)
+        expect(repo.count).to eq(0)
+      end
+    end
+
+    context 'with valid database' do
+      it 'loads package entries' do
+        repo.load(db_path)
+        entry = repo['htop-vi']
+        expect(entry).to_not be_nil
+        expect(entry.files).to be_empty
+      end
+    end
+
+    context 'with invalid database' do
+      let(:db_path) { test_input('abs.tar.gz') }
+
+      it 'raises an error' do
+        expect { repo.load(db_path) }.to raise_error(Akabei::Error)
+      end
+    end
+
+    context 'with signer' do
+      let(:signer) { double('Signer') }
+      let(:db_path) { test_dest('test.db') }
+      let(:sig_path) { test_dest("test.db.sig") }
+
+      before do
+        repo.signer = signer
+      end
+
+      it 'skips verification if signature is absent' do
+        expect { repo.load(db_path) }.to_not raise_error
+      end
+
+      context 'with signature' do
+        before do
+          FileUtils.cp(test_input('test.db'), db_path)
+          sig_path.open('w') {}
+        end
+
+        it 'loads package entries if the signature is valid' do
+          expect(signer).to receive(:verify!).with(db_path)
+          repo.load(db_path)
+          expect(repo['htop-vi']).not_to be_nil
+        end
+
+        it 'raises an error if the signature is invalid' do
+          expect(signer).to receive(:verify!).with(db_path).and_raise(Akabei::Signer::InvalidSignature.new(double('path'), double('from')))
+          expect { repo.load(db_path) }.to raise_error(Akabei::Signer::InvalidSignature)
+          expect(repo.count).to eq(0)
+        end
+      end
+    end
+
+    context 'with files' do
+      let(:db_path) { test_input('test.files') }
+
+      it 'loads package entries with files' do
+        repo.load(db_path)
+        entry = repo['htop-vi']
+        expect(entry.files).to_not be_empty
+      end
+    end
+  end
+
+  describe '#add' do
+    it 'adds an entry' do
+      package = double('package')
+      entry = double('entry')
+      allow(package).to receive(:db_name).and_return('nkf-2.1.3-1')
+      expect(package).to receive(:to_entry).and_return(entry)
+      allow(entry).to receive(:name).and_return('nkf')
+
+      repo.add(package)
+      expect(repo['nkf']).to eql(entry)
+    end
+  end
+
+  describe '#remove' do
+    before do
+      repo.load(db_path)
+    end
+
+    context 'with entry present' do
+      it 'removes the package entry' do
+        expect { repo.remove('htop-vi') }.to change { repo.count }.by(-1)
+      end
+    end
+
+    context 'with package absent' do
+      it 'does nothing' do
+        expect { repo.remove('nkf') }.not_to change { repo.count }
+      end
+    end
+  end
+
+  describe '#save' do
+    let(:dest_path) { test_dest('test.db') }
+
+    before do
+      repo.load(db_path)
+    end
+
+    it 'stores repository database' do
+      repo.save(dest_path)
+      expect(dest_path).to be_readable
+      new_repo = described_class.load(dest_path)
+      expect(repo).to eq(new_repo)
+    end
+
+    context 'with signer' do
+      let(:signer) { double('Signer') }
+
+      before do
+        repo.signer = signer
+      end
+
+      it 'stores repository database and sign it' do
+        expect(signer).to receive(:detach_sign).once.with(dest_path) { |path|
+          File.open("#{path}.sig", 'w') {}
+        }
+
+        repo.save(dest_path)
+        expect(Pathname.new("#{dest_path}.sig")).to be_readable
+      end
+    end
+
+    context 'with include_files' do
+      let(:db_path) { test_input('test.files') }
+
+      before do
+        repo.include_files = true
+      end
+
+      it 'stores repository database' do
+        repo.save(dest_path)
+        new_repo = described_class.load(dest_path)
+        new_repo.include_files = true
+        expect(repo).to eq(new_repo)
+      end
+    end
+  end
+end