cartage 1.2 → 2.0.rc1

data/test/test_cartage_build_tarball.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'minitest_config'
+
+describe 'Cartage::BuildTarball' do
+  let(:config) {
+    Cartage::Config.new(
+      root_path: '/a/b/c',
+      name: 'test',
+      timestamp: 'value'
+    )
+  }
+  let(:cartage) {
+    Cartage.new(config)
+  }
+  let(:subject) { cartage.build_tarball }
+
+  it '#build_package requests :pre_build_tarball and :post_build_tarball' do
+    requests = %i(pre_build_tarball post_build_tarball)
+
+    verify_request = ->(f) { assert_equal requests.shift, f }
+    verify_run = ->(c) {
+      assert_equal [
+        'tar',
+        'cfj',
+        '/a/b/c/tmp/test-value.tar.bz2',
+        '-C',
+        '/a/b/c/tmp',
+        'test'
+      ], c
+    }
+
+    instance_stub Cartage::Plugins, :request, verify_request do
+      instance_stub Cartage, :run, verify_run do
+        subject.build_package
+      end
+    end
+
+    assert_empty requests
+  end
+
+  describe '#package_name is dependent on Cartage configuration' do
+    it 'is .tar.bz2 when compression is :bzip2' do
+      assert_equal Pathname('/a/b/c/tmp/test-value.tar.bz2'), subject.package_name
+    end
+
+    it 'is .tar when compression is :none' do
+      cartage.compression = 'none'
+      assert_equal Pathname('/a/b/c/tmp/test-value.tar'), subject.package_name
+    end
+
+    it 'is .tar.gz when compression is :gzip' do
+      cartage.compression = 'gzip'
+      assert_equal Pathname('/a/b/c/tmp/test-value.tar.gz'), subject.package_name
+    end
+  end
+end

data/test/test_cartage_config.rb

@@ -1,47 +1,119 @@
+# frozen_string_literal: true
+
 require 'minitest_config'
 require 'cartage/config'
 
 describe Cartage::Config do
-  before do
-    @data = {
-      "x" => 1,
-      "arr" => %w(a b c),
-      "plugins" => {
-        "test" => {
-          "x" => 2
-        }
-      },
-      "development" => {
-        "x" => 3,
-        "plugins" => {
-          "test" => OpenStruct.new("x" => 4)
+  let(:data) {
+    {
+      'x' => 1,
+      'arr' => %w(a b c),
+      'commands' => {},
+      'plugins' => {
+        'test' => {
+          'x' => 2
         }
       }
     }
+  }
+  let(:odata) { Cartage::Config.send(:ostructify, data) }
+  let(:config) { Cartage::Config.new(odata) }
+  let(:hdata) { Marshal.load(Marshal.dump(data)) }
+
+  describe 'load' do
+    def watch_pathname_exist
+      mpname = Pathname.singleton_class
+      mpname.send(:define_method, :exist_tries, -> { @exist_tries ||= [] })
+
+      Pathname.send(:alias_method, :__stub_exist__?, :exist?)
+      Pathname.send(:define_method, :exist?, -> { !(self.class.exist_tries << to_s) })
+
+      yield
+    ensure
+      mpname.send(:undef_method, :exist_tries)
+      Pathname.send(:undef_method, :exist?)
+      Pathname.send(:alias_method, :exist?, :__stub_exist__?)
+      Pathname.send(:undef_method, :__stub_exist__?)
+    end
+
+    def ignore_pathname_expand_path
+      Pathname.send(:alias_method, :__stub_expand_path__, :expand_path)
+      Pathname.send(:define_method, :expand_path, -> { self })
+
+      yield
+    ensure
+      Pathname.send(:undef_method, :expand_path)
+      Pathname.send(:alias_method, :expand_path, :__stub_expand_path__)
+      Pathname.send(:undef_method, :__stub_expand_path__)
+    end
+
+    it 'looks for default files when given :default' do
+      watch_pathname_exist do
+        ignore_pathname_expand_path do
+          Cartage::Config.load(:default)
+          assert_equal Cartage::Config::DEFAULT_CONFIG_FILES, Pathname.exist_tries
+        end
+      end
+    end
 
-    @odata = Cartage::Config.send(:ostructify, @data)
-    @config = Cartage::Config.new(@odata)
-    @hdata = Marshal.load(Marshal.dump(@data))
-    @hdata['development']['plugins']['test'] = { "x" => 4 }
+    it 'fails if the file does not exist' do
+      instance_stub Pathname, :exist?, -> { false } do
+        assert_raises_with_message ArgumentError,
+          'Configuration file foo does not exist.' do
+          Cartage::Config.load('foo')
+        end
+      end
+    end
+
+    it 'loads the file if it exists' do
+      instance_stub Pathname, :read, -> { '{ faked: true }' } do
+        instance_stub Pathname, :exist?, -> { true } do
+          expected = {
+            faked: true,
+            commands: OpenStruct.new,
+            plugins: OpenStruct.new
+          }
+          assert_equal expected,
+            Cartage::Config.load('foo').instance_variable_get(:@table)
+        end
+      end
+    end
+
+    it 'uses a default configuration if there is no default config file' do
+      expected = {
+        commands: OpenStruct.new,
+        plugins: OpenStruct.new
+      }
+      assert_equal expected,
+        Cartage::Config.load(:default).instance_variable_get(:@table)
+    end
   end
 
-  describe '#ostructify (private)' do
-    it 'converts hash structures correctly' do
-      expected = OpenStruct.new(x: 1)
-      expected.arr = %w(a b c)
-      expected.plugins = OpenStruct.new
-      expected.plugins.test = OpenStruct.new(x: 2)
-      expected.development = OpenStruct.new(x: 3)
-      expected.development.plugins = OpenStruct.new
-      expected.development.plugins.test = OpenStruct.new(x: 4)
+  describe 'import' do
+    it 'reads a file if it exists' do
+      stub File, :exist?, ->(_) { true } do
+        stub File, :read, ->(_) { 'faked' } do
+          assert_equal 'faked', Cartage::Config.import('foo')
+        end
+      end
+    end
 
-      assert_equal expected, @odata
+    it 'returns nil if the file does not exist' do
+      stub File, :exist?, ->(_) { false } do
+        assert_nil Cartage::Config.import('foo')
+      end
     end
   end
 
   describe '#to_h' do
     it 'completely converts a Config object to hash' do
-      assert_equal @hdata, @config.to_h
+      assert_equal hdata, config.to_h
+    end
+  end
+
+  describe '#to_yaml' do
+    it 'overrides the OpenStruct implementation' do
+      assert_equal hdata.to_yaml, config.to_yaml
     end
   end
 end

data/test/test_cartage_core.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require 'minitest_config'
+
+describe Cartage::Core do
+  let(:subject) {
+    Class.new.tap do |klass|
+      klass.class_eval do
+        extend Cartage::Core
+
+        class << self
+          public :attr_reader_with_default
+          public :attr_writer_with_transform
+          public :attr_accessor_with_default
+        end
+      end
+    end
+  }
+  let(:object) { subject.new }
+
+  describe 'attr_reader_with_default' do
+    it 'fails without a default' do
+      assert_raises_with_message ArgumentError, 'No default provided.' do
+        subject.attr_reader_with_default :answer
+      end
+    end
+
+    it 'fails with too many defaults' do
+      assert_raises_with_message ArgumentError, 'Too many defaults provided.' do
+        subject.attr_reader_with_default :answer, 42, &-> { 42 }
+      end
+    end
+
+    it 'defines default and reader methods when given a value' do
+      subject.attr_reader_with_default :answer, 42
+      assert_respond_to object, :answer
+      assert_equal 42, object.answer
+
+      assert_respond_to object, :default_answer
+      assert_equal 42, object.default_answer
+    end
+
+    it 'defines default and reader methods when given a block' do
+      subject.attr_reader_with_default :answer do
+        42
+      end
+
+      assert_respond_to object, :answer
+      assert_equal 42, object.answer
+
+      assert_respond_to object, :default_answer
+      assert_equal 42, object.default_answer
+    end
+
+    it 'memoizes the default value' do
+      subject.attr_reader_with_default :favourite_colour, 'blue'
+      assert_same object.default_favourite_colour, object.default_favourite_colour
+    end
+  end
+
+  describe 'attr_writer_with_transform' do
+    it 'fails without a transform' do
+      assert_raises_with_message ArgumentError, 'No transform provided.' do
+        subject.attr_writer_with_transform :answer
+      end
+    end
+
+    it 'fails with too many transforms' do
+      assert_raises_with_message ArgumentError, 'Too many transforms provided.' do
+        subject.attr_writer_with_transform :answer, 42, &-> { 42 }
+      end
+    end
+
+    it 'fails if the transform is not callable' do
+      assert_raises_with_message ArgumentError, 'Transform is not callable.' do
+        subject.attr_writer_with_transform :answer, 42
+      end
+    end
+
+    it 'defines a writer method when given a symbol' do
+      subject.attr_writer_with_transform :answer, :to_s
+      assert_respond_to object, :answer=
+      object.answer = 42
+      assert_equal '42', object.instance_variable_get(:"@answer")
+    end
+
+    it 'defines a writer method when given a callable' do
+      subject.attr_writer_with_transform :answer, ->(v) { v.to_s }
+      assert_respond_to object, :answer=
+      object.answer = 42
+      assert_equal '42', object.instance_variable_get(:"@answer")
+    end
+
+    it 'defines a writer method when given a block' do
+      subject.attr_writer_with_transform :answer do |v|
+        String(v)
+      end
+      assert_respond_to object, :answer=
+      object.answer = 42
+      assert_equal '42', object.instance_variable_get(:"@answer")
+    end
+  end
+
+  describe 'attr_accessor_with_default' do
+    it 'fails without a default' do
+      assert_raises_with_message ArgumentError, 'No default provided.' do
+        subject.attr_accessor_with_default :answer
+      end
+    end
+
+    it 'defines a default, reader, and writer methods when given a value' do
+      subject.attr_accessor_with_default :answer, default: 42
+
+      assert_respond_to object, :answer
+      assert_respond_to object, :default_answer
+      assert_respond_to object, :answer=
+
+      object.answer = 21
+      assert_equal 21, object.answer
+      assert_equal 42, object.default_answer
+    end
+
+    it 'defines a default, reader, and writer methods when given a block' do
+      subject.attr_accessor_with_default :answer do
+        42
+      end
+
+      assert_respond_to object, :answer
+      assert_respond_to object, :default_answer
+      assert_respond_to object, :answer=
+
+      object.answer = 21
+      assert_equal 21, object.answer
+      assert_equal 42, object.default_answer
+    end
+
+    it 'memoizes the default value' do
+      subject.attr_accessor_with_default :favourite_colour, default: 'blue'
+      assert_same object.favourite_colour, object.favourite_colour
+    end
+
+    it 'fails if transform is not callable' do
+      assert_raises_with_message ArgumentError, 'Transform is not callable.' do
+        subject.attr_accessor_with_default :answer, default: 42, transform: 42
+      end
+    end
+
+    it 'accepts a symbol for transform' do
+      subject.attr_accessor_with_default :answer, default: 42, transform: :to_s
+
+      assert_respond_to object, :answer
+      assert_respond_to object, :default_answer
+      assert_respond_to object, :answer=
+
+      assert_equal 42, object.answer
+      object.answer = 21
+      assert_equal '21', object.answer
+    end
+
+    it 'accepts a callable for transform' do
+      subject.attr_accessor_with_default :answer,
+        default: 42, transform: ->(v) { v.to_s }
+      assert_respond_to object, :answer
+      assert_respond_to object, :default_answer
+      assert_respond_to object, :answer=
+
+      assert_equal 42, object.answer
+      object.answer = 21
+      assert_equal '21', object.answer
+    end
+  end
+end

data/test/test_cartage_manifest.rb

@@ -1,22 +1,243 @@
+# frozen_string_literal: true
+
 require 'minitest_config'
-require 'cartage/plugin'
-require 'cartage/command'
-require 'cartage/manifest'
 
-describe Cartage::Manifest do
+describe 'Cartage::Manifest' do
+  let(:cartage) { Cartage.new }
+  let(:manifest) { cartage.manifest }
+  let(:manifest_contents) { %w(bin/build bin/cartage lib/cartage.rb spec/cartage.rb) }
+  let(:expected_tmpfile) { %W(foo/bin/build\n foo/bin/cartage\n foo/lib/cartage.rb\n) }
+
   before do
-    @cartage = Cartage.new
-    @manifest = Cartage::Manifest.new(@cartage)
+    cartage
+  end
+
+  def stub_slugignore_file(exists: true, contents: nil)
+    ignore_file = manifest.send(:slugignore_file)
+    stub ignore_file, :exist?, -> { exists } do
+      if contents
+        stub ignore_file, :readlines, -> { contents } do
+          yield
+        end
+      else
+        yield
+      end
+    end
+  end
+
+  def stub_ignore_file(exists: true, contents: nil)
+    ignore_file = manifest.send(:ignore_file)
+    stub ignore_file, :exist?, -> { exists } do
+      if contents
+        stub ignore_file, :readlines, -> { contents } do
+          yield ignore_file
+        end
+      else
+        yield ignore_file
+      end
+    end
+  end
+
+  def stub_manifest_file(exists: true, contents: nil)
+    manifest_file = manifest.send(:manifest_file)
+    stub manifest_file, :exist?, -> { exists } do
+      if contents
+        stub manifest_file, :readlines, -> { contents } do
+          yield
+        end
+      else
+        yield
+      end
+    end
+  end
+
+  describe '#resolve' do
+    it 'fails if there is no manifest_file' do
+      stub_manifest_file exists: false do
+        ex = assert_raises Cartage::Manifest::MissingError do
+          manifest.resolve
+        end
+        assert_match(/cannot create/, ex.message)
+      end
+    end
+
+    it 'fails if there is no block given' do
+      stub_manifest_file do
+        assert_raises_with_message ArgumentError, 'A block is required.' do
+          manifest.resolve
+        end
+      end
+    end
+
+    it 'fails if the manifest is empty' do
+      stub_manifest_file contents: [] do
+        assert_raises_with_message RuntimeError, 'Manifest.txt is empty.' do
+          manifest.resolve {}
+        end
+      end
+    end
+
+    it 'yields the name of a tempfile with the manifest contents' do
+      stub_ignore_file contents: [] do
+        stub_manifest_file contents: manifest_contents do
+          manifest.resolve(Pathname('foo')) { |name|
+            assert_match(/Manifest\./, name)
+            assert_equal (expected_tmpfile << "foo/spec/cartage.rb\n"),
+              Pathname(name).readlines
+          }
+        end
+      end
+    end
+
+    it 'prunes out ignored files from a specified cartignore' do
+      stub_ignore_file contents: %w(spec/) do
+        stub_manifest_file contents: manifest_contents do
+          manifest.resolve(Pathname('foo')) { |name|
+            assert_equal expected_tmpfile, Pathname(name).readlines
+          }
+        end
+      end
+    end
+
+    it 'prunes out ignored files from a specified slugignore' do
+      stub_ignore_file exists: false do
+        stub_slugignore_file contents: %w(spec/) do
+          stub_manifest_file contents: manifest_contents do
+            manifest.resolve(Pathname('foo')) { |name|
+              assert_equal expected_tmpfile, Pathname(name).readlines
+            }
+          end
+        end
+      end
+    end
+
+    it 'prunes out ignored files from the default cartignore' do
+      stub_ignore_file exists: false do
+        stub_slugignore_file exists: false do
+          stub_manifest_file contents: manifest_contents do
+            manifest.resolve(Pathname('foo')) { |name|
+              assert_equal expected_tmpfile.reject { |v| v =~ /build/ },
+                Pathname(name).readlines
+            }
+          end
+        end
+      end
+    end
+
+    it 'prunes out ignored files with a leading slash' do
+      stub_ignore_file contents: %w(/spec) do
+        stub_manifest_file contents: manifest_contents do
+          manifest.resolve(Pathname('foo')) { |name|
+            assert_equal expected_tmpfile, Pathname(name).readlines
+          }
+        end
+      end
+    end
+  end
+
+  describe '#generate' do
+    it 'is created with sorted and unique filenames' do
+      assert_pathname_write "a\nb\nc\n" do
+        stub_backticks %w(b a a a b c).join("\n") do
+          manifest.generate
+        end
+      end
+    end
   end
 
-  describe '#create_file_list' do
-    it 'only sets unique files' do
-      files = %w(a a a b c).join("\n")
-      expected = %w(a b c).join("\n") + "\n"
+  describe '#check' do
+    it 'fails if there is no manifest_file' do
+      stub_manifest_file exists: false do
+        ex = assert_raises Cartage::Manifest::MissingError do
+          manifest.check
+        end
+        assert_match(/cannot create/, ex.message)
+      end
+    end
+
+    it 'compares the current files against the manifest' do
+      begin
+        sysc = ->(*args) { IO.popen(args) { |diff| puts diff.read } }
+
+        assert_output(/^\+d/) do
+          instance_stub Kernel, :system, sysc do
+            stub_backticks %w(a b c).join("\n") do
+              manifest.instance_variable_set(:@manifest_file, Pathname('Manifest.test'))
+              manifest.generate
+            end
+
+            stub_backticks %w(a b c d).join("\n") do
+              manifest.check
+            end
+          end
+        end
+      ensure
+        file = manifest.send(:manifest_file)
+        file.unlink if file.to_s.end_with?('Manifest.test')
+      end
+    end
+  end
+
+  describe '#install_default_ignore' do
+    before do
+      cartage.verbose = true
+    end
+
+    it 'does nothing if the ignore file exists without overwrite or merge' do
+      assert_output ".cartignore already exists, skipping...\n" do
+        stub_ignore_file do |ignore_file|
+          stub ignore_file, :write, ->(_) {} do
+            manifest.install_default_ignore
+          end
+
+          refute_instance_called ignore_file.class, :write
+        end
+      end
+    end
+
+    def ignore_file_writer(expected = nil)
+      case expected
+      when Regexp
+        ->(actual) { assert_match expected, actual }
+      when String
+        ->(actual) { assert_equal expected, actual }
+      when nil
+        ->(_) {}
+      end
+    end
+
+    it 'merges if mode is merge' do
+      stub_ignore_file contents: %w(xyz/) do |ignore_file|
+        stub ignore_file, :write, ignore_file_writer(%r{^xyz/.*vendor/bundle/$}m) do
+          assert_output "Merging .cartignore...\n" do
+            manifest.install_default_ignore(mode: 'merge')
+          end
+
+          assert_instance_called ignore_file.class, :write
+        end
+      end
+    end
+
+    it 'merges if mode is merge and ignore file is empty' do
+      stub_ignore_file contents: [] do |ignore_file|
+        stub ignore_file, :write, ignore_file_writer(%r{^# Some .*vendor/bundle/$}m) do
+          assert_output "Merging .cartignore...\n" do
+            manifest.install_default_ignore(mode: 'merge')
+          end
+
+          assert_instance_called ignore_file.class, :write
+        end
+      end
+    end
+
+    it 'forces when mode is force' do
+      stub_ignore_file contents: %w(xyz/) do |ignore_file|
+        stub ignore_file, :write, ignore_file_writer(%r{^# Some .*vendor/bundle/$}m) do
+          assert_output "Creating .cartignore...\n" do
+            manifest.install_default_ignore(mode: 'force')
+          end
 
-      stub_file_open_for_write expected do
-        stub_backticks files do
-          @manifest.send :create_file_list, 'x'
+          assert_instance_called ignore_file.class, :write
         end
       end
     end