cartage 1.2 → 2.0.rc1

data/test/minitest_config.rb

@@ -1,4 +1,4 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
 gem 'minitest'
 require 'minitest/autorun'
@@ -6,68 +6,6 @@ require 'minitest/pretty_diff'
 require 'minitest/focus'
 require 'minitest/moar'
 require 'minitest/bisect'
+require 'minitest-bonus-assertions'
 
-require 'cartage'
-
-module Minitest::ENVStub
-  def stub_env env, options = {}, *block_args, &block
-    mock = lambda { |key|
-      env.fetch(key) { |k|
-        if options[:passthrough]
-          ENV.send(:"__minitest_stub__[]", k)
-        else
-          nil
-        end
-      }
-    }
-
-    if defined? Minitest::Moar::Stubbing
-      stub ENV, :[], mock, *block_args, &block
-    else
-      ENV.stub :[], mock, *block_args, &block
-    end
-  end
-
-  def stub_cartage_repo_url value = nil, &block
-    instance_stub Cartage, :repo_url,
-      -> { value || 'git://host/repo-url.git' }, &block
-  end
-
-  def stub_backticks value
-    Kernel.send(:alias_method, :__stub_backticks__, :`)
-    Kernel.send(:define_method, :`) { |*| value }
-    yield
-  ensure
-    Kernel.send(:undef_method, :`)
-    Kernel.send(:alias_method, :`, :__stub_backticks__)
-    Kernel.send(:undef_method, :__stub_backticks__)
-  end
-
-  def stub_file_open_for_write expected, string_io = StringIO.new
-    mfile = File.singleton_class
-    mfile.send(:alias_method, :__stub_open__, :open)
-
-    fopen = ->(*, &block) {
-      if block
-        block.call(string_io)
-      else
-        string_io
-      end
-    }
-
-    mfile.send(:define_method, :open, &fopen)
-    yield
-    actual = String.new(string_io.string)
-  ensure
-    mfile.send(:undef_method, :open)
-    mfile.send(:alias_method, :open, :__stub_open__)
-    mfile.send(:undef_method, :__stub_open__)
-    assert_equal expected, actual
-  end
-
-  def stub_pathname_expand_path value, &block
-    instance_stub Pathname, :expand_path, Pathname(value), &block
-  end
-
-  Minitest::Test.send(:include, self)
-end
+require 'cartage/minitest'

data/test/test_cartage.rb

@@ -1,161 +1,218 @@
+# frozen_string_literal: true
+
 require 'minitest_config'
 
 describe Cartage do
-  before do
-    @cartage = Cartage.new
+  let(:config) { nil }
+  let(:cartage) { Cartage.new(config) }
+
+  describe '#initialize' do
+    it 'loads an empty configuration when created without a config' do
+      assert_equal Cartage::Config.new, cartage.config
+    end
   end
 
-  describe '#name' do
+  describe '#name, #name=' do
     it 'defaults to #default_name' do
       stub_cartage_repo_url do
-        assert_equal 'repo-url', @cartage.name
-        assert_equal @cartage.default_name, @cartage.name
+        assert_equal 'repo-url', cartage.name
+        assert_equal cartage.default_name, cartage.name
       end
     end
 
     it 'can be overridden' do
       stub_cartage_repo_url do
-        @cartage.name = 'xyz'
-        assert_equal 'xyz', @cartage.name
+        cartage.name = 'xyz'
+        assert_equal 'xyz', cartage.name
       end
     end
   end
 
-  describe '#root_path' do
+  describe '#root_path, #root_path=' do
     it 'defaults to #default_root_path' do
-      stub_backticks '/x/y/z' do
-        assert_equal Pathname('/x/y/z'), @cartage.root_path
-        assert_equal @cartage.default_root_path, @cartage.root_path
+      stub_cartage_repo_url do
+        stub_backticks '/x/y/z' do
+          assert_equal Pathname('/x/y/z'), cartage.root_path
+          assert_equal cartage.default_root_path, cartage.root_path
+        end
       end
     end
 
     it 'can be overridden and creates a Pathname' do
       stub_cartage_repo_url do
-        @cartage.root_path = '/a/b/c'
-        assert_equal Pathname('/a/b/c'), @cartage.root_path
+        cartage.root_path = '/a/b/c'
+        assert_equal Pathname('/a/b/c'), cartage.root_path
       end
     end
 
     it 'expands the created Pathname' do
       stub_cartage_repo_url do
-        @cartage.root_path = '/a/b/../c'
-        assert_equal Pathname('/a/c'), @cartage.root_path
+        cartage.root_path = '/a/b/../c'
+        assert_equal Pathname('/a/c'), cartage.root_path
       end
     end
   end
 
-  describe '#timestamp' do
+  describe '#timestamp, #timestamp=' do
     it 'defaults to #now.utc.strftime("%Y%m%d%H%M%S")' do
-      stub Time, :now, -> { Time.new(2014, 12, 31, 23, 59, 59, "+00:00") } do
-        assert_equal '20141231235959', @cartage.timestamp
-        assert_equal @cartage.default_timestamp, @cartage.timestamp
+      stub Time, :now, -> { Time.new(2014, 12, 31, 23, 59, 59, '+00:00') } do
+        assert_equal '20141231235959', cartage.timestamp
+        assert_equal cartage.default_timestamp, cartage.timestamp
       end
     end
 
     it 'does no validation of assigned values' do
-      @cartage.timestamp = 'not a timestamp'
-      assert_equal 'not a timestamp', @cartage.timestamp
+      cartage.timestamp = 'not a timestamp'
+      assert_equal 'not a timestamp', cartage.timestamp
+    end
+  end
+
+  describe '#target, #target=' do
+    it 'defaults to tmp/ as a Pathname' do
+      assert_equal Pathname('tmp'), cartage.target
+      assert_equal cartage.default_target, cartage.target
+    end
+
+    it 'it converts the assigned value into a pathname' do
+      cartage.target = '/a/b/c'
+      assert_equal Pathname('/a/b/c'), cartage.target
     end
   end
 
-  describe '#without_groups' do
-    it 'defaults to %w(development test)' do
-      assert_equal %w(development test), @cartage.without_groups
-      assert_equal @cartage.default_without_groups, @cartage.without_groups
+  describe '#compression, #compression=' do
+    it 'defaults to :bzip2' do
+      assert_equal :bzip2, cartage.compression
+    end
+
+    it 'accepts bzip2, none, and gzip as valid values' do
+      candidates = %i(bzip2 none gzip)
+      candidates += candidates.map(&:to_s)
+      candidates.each { |candidate|
+        cartage.compression = candidate
+        assert_equal candidate, cartage.compression
+      }
+    end
+
+    it 'fails if given an unknown type' do
+      assert_raises_with_message ArgumentError, 'Invalid compression type nil' do
+        cartage.compression = nil
+      end
+      assert_raises_with_message ArgumentError, 'Invalid compression type 3' do
+        cartage.compression = 3
+      end
+      assert_raises_with_message ArgumentError, 'Invalid compression type "foo"' do
+        cartage.compression = 'foo'
+      end
+    end
+
+    it 'affects #tar_compression_extension' do
+      assert_equal '.bz2', cartage.tar_compression_extension
+
+      cartage.compression = 'none'
+      assert_equal '', cartage.tar_compression_extension
+
+      cartage.compression = 'gzip'
+      assert_equal '.gz', cartage.tar_compression_extension
     end
 
-    it 'wraps arrays correctly' do
-      @cartage.without_groups = 'dit'
-      assert_equal %w(dit), @cartage.without_groups
+    it 'affects #tar_compression_flag' do
+      assert_equal 'j', cartage.tar_compression_flag
+
+      cartage.compression = 'none'
+      assert_equal '', cartage.tar_compression_flag
+
+      cartage.compression = 'gzip'
+      assert_equal 'z', cartage.tar_compression_flag
     end
   end
 
-  describe '#base_config' do
-    it 'defaults to an empty OpenStruct' do
-      assert_equal OpenStruct.new, @cartage.base_config
-      assert_equal @cartage.default_base_config, @cartage.base_config
-      refute_same @cartage.default_base_config, @cartage.base_config
+  describe '#dependency_cache, #dependency_cache_path, #dependency_cache_path=' do
+    it 'defaults to #tmp_path{,/dependency-cache.tar.bz2}' do
+      assert_equal cartage.tmp_path, cartage.dependency_cache_path
+      assert_equal cartage.tmp_path.join('dependency-cache.tar.bz2'),
+        cartage.dependency_cache
+    end
+
+    it 'is affected by the compression setting' do
+      cartage.compression = 'none'
+      assert_equal cartage.tmp_path.join('dependency-cache.tar'),
+        cartage.dependency_cache
+
+      cartage.compression = 'gzip'
+      assert_equal cartage.tmp_path.join('dependency-cache.tar.gz'),
+        cartage.dependency_cache
+    end
+
+    it 'becomes a Pathname' do
+      cartage.dependency_cache_path = 'foo'
+      assert_equal Pathname('foo').expand_path, cartage.dependency_cache_path
+      assert_equal Pathname('foo/dependency-cache.tar.bz2').expand_path,
+        cartage.dependency_cache
     end
   end
 
   describe '#config' do
-    before do
-      data = {
+    let(:data) {
+      {
+        release_hashref: '12345',
         x: 1,
         plugins: {
           test: {
             x: 2
           }
         },
-        development: {
-          x: 3,
-          plugins: {
-            test: {
-              x: 4
-            }
+        commands: {
+          test: {
+            x: 3
           }
         }
       }
+    }
+    let(:config) { Cartage::Config.new(Cartage::Config.send(:ostructify, data)) }
 
-      @config = Cartage::Config.new(Cartage::Config.send(:ostructify, data))
-
-      @cartage.environment = :development
-      @cartage.base_config = @config
-    end
-
-    it 'knows the subset for "development"' do
-      assert_equal @config.development, @cartage.config
+    it 'knows the plugin "test"' do
+      assert_equal config.plugins.test, cartage.config(for_plugin: :test)
     end
 
-    it 'knows the subset for the "test" plugin in "development"' do
-      assert_equal @config.development.plugins.test,
-        @cartage.config(for_plugin: 'test')
+    it 'knows the command "test"' do
+      assert_equal config.commands.test, cartage.config(for_command: :test)
     end
 
-    it 'knows the subset "test" plugin without environment' do
-      assert_equal @config.plugins.test,
-        @cartage.config(with_environment: false, for_plugin: :test)
+    it 'knows the whole config' do
+      assert_equal config, cartage.config
     end
 
-    it 'knows the whole config without environment' do
-      assert_equal @config, @cartage.config(with_environment: false)
+    it 'fails with an error when asking for plugin and command together' do
+      exception = assert_raises ArgumentError do
+        cartage.config(for_plugin: :test, for_command: :test)
+      end
+      assert_match(/Cannot get config/, exception.message)
     end
   end
 
-  describe '#bundle_cache' do
-    def assert_bundle_cache_equal(path)
-      path     = Pathname(path).join('vendor-bundle.tar.bz2')
-      expected = Pathname(".").join(path)
-
-      instance_stub Pathname, :expand_path, expected do
-        yield if block_given?
-        assert_equal expected, @cartage.bundle_cache
-      end
+  describe '#dependency_cache' do
+    def assert_dependency_cache_equal(path)
+      yield if block_given?
+      assert_equal Pathname('.').join(path).expand_path, cartage.dependency_cache
     end
 
-    it 'defaults to "tmp/vendor-bundle.tar.bz2"' do
-      assert_bundle_cache_equal 'tmp/vendor-bundle.tar.bz2'
+    it 'defaults to "tmp/dependency-cache.tar.bz2"' do
+      assert_dependency_cache_equal 'tmp/dependency-cache.tar.bz2'
     end
 
-    it 'can be overridden' do
-      assert_bundle_cache_equal 'tmp/vendor-bundle.tar.bz2'
-      assert_bundle_cache_equal 'tmpx/vendor-bundle.tar.bz2' do
-        @cartage.bundle_cache 'tmpx'
+    it 'can be overridden through #dependency_cache_path=' do
+      assert_dependency_cache_equal 'tmp/dependency-cache.tar.bz2'
+      assert_dependency_cache_equal 'tmpx/dependency-cache.tar.bz2' do
+        cartage.dependency_cache_path = 'tmpx'
       end
     end
   end
 
   describe '#release_hashref' do
     it 'returns the current hashref' do
-      stub_backticks '12345' do
-        assert_equal '12345', @cartage.release_hashref
-      end
-    end
-
-    it 'saves the hashref to a file with save_to:' do
-      stub_backticks '54321' do
-        stub_file_open_for_write '54321' do
-          @cartage.release_hashref(save_to: 'x')
+      stub_cartage_repo_url do
+        stub_backticks '12345' do
+          assert_equal '12345', cartage.release_hashref
         end
       end
     end
@@ -177,85 +234,172 @@ describe Cartage do
       origin
       stub_backticks origin do
         assert_equal 'git@github.com:KineticCafe/cartage.git',
-          @cartage.repo_url
+          cartage.repo_url
       end
     end
   end
 
-  describe '#final_tarball, #final_release_hashref' do
+  describe 'computed paths' do
     before do
-      @cartage.name = 'test'
-      @cartage.timestamp = 'value'
-      @cartage.instance_variable_set(:@root_path, Pathname('source'))
+      cartage.root_path = '/a/b/c'
+      cartage.name = 'test'
+      cartage.timestamp = 'value'
+    end
+
+    it '#tmp_path is #root_path/tmp' do
+      assert_equal Pathname('/a/b/c/tmp'), cartage.tmp_path
     end
 
-    it 'sets the final tarball name correctly' do
-      assert_equal Pathname('source/tmp/test-value.tar.bz2'),
-        @cartage.final_tarball
+    it '#work_path is #tmp_path/#name' do
+      assert_equal Pathname('/a/b/c/tmp/test'), cartage.work_path
     end
 
-    it 'sets the final release hashref name correctly' do
-      assert_equal Pathname('source/tmp/test-value-release-hashref.txt'),
-        @cartage.final_release_hashref
+    it '#final_name is #tmp_path/#name-#timestamp' do
+      assert_equal Pathname('/a/b/c/tmp/test-value'), cartage.final_name
+    end
+
+    # it '#build_tarball.final_tarball is #final_name.tar#compression_extension' do
+    #   assert_equal Pathname('/a/b/c/tmp/test-value.tar.bz2'),
+    #     cartage.build_tarball.final_tarball
+    #
+    #   cartage.compression = 'none'
+    #   assert_equal Pathname('/a/b/c/tmp/test-value.tar'),
+    #     cartage.build_tarball.final_tarball
+    #
+    #   cartage.compression = 'gzip'
+    #   assert_equal Pathname('/a/b/c/tmp/test-value.tar.gz'),
+    #     cartage.build_tarball.final_tarball
+    # end
+
+    it '#final_release_metadata_json is #final_name-release-metadata.json' do
+      assert_equal Pathname('/a/b/c/tmp/test-value-release-metadata.json'),
+        cartage.final_release_metadata_json
     end
   end
 
   describe '#display' do
     it 'does not display a message if not verbose' do
-      @cartage.verbose = false
+      cartage.verbose = false
       assert_silent do
-        @cartage.display 'hello'
+        cartage.display 'hello'
       end
     end
 
     it 'displays a message if verbose' do
-      @cartage.verbose = true
+      cartage.verbose = true
       assert_output "hello\n" do
-        @cartage.display 'hello'
+        cartage.display 'hello'
       end
     end
 
     it 'does not display a message if verbose and quiet' do
-      @cartage.verbose = true
-      @cartage.quiet = true
+      cartage.verbose = true
+      cartage.quiet = true
       assert_silent do
-        @cartage.display 'hello'
+        cartage.display 'hello'
       end
     end
   end
 
-  describe '#run (private)' do
+  describe '#run' do
     before do
       @command = %w(echo yes)
     end
 
     it 'displays the output if not verbose and not quiet' do
       assert_output "yes\n" do
-        @cartage.send(:run, @command)
+        cartage.send(:run, @command)
       end
     end
 
     it 'displays the command and output if verbose and not quiet' do
-      @cartage.verbose = true
+      cartage.verbose = true
       assert_output "echo yes\nyes\n" do
-        @cartage.send(:run, @command)
+        cartage.send(:run, @command)
       end
     end
 
     it 'displays nothing if quiet' do
-      @cartage.verbose = true
-      @cartage.quiet = true
+      cartage.verbose = true
+      cartage.quiet = true
       assert_silent do
-        @cartage.send(:run, @command)
+        cartage.send(:run, @command)
       end
     end
 
     it 'raises an exception on error' do
-      @cartage.quiet = true
+      cartage.quiet = true
       ex = assert_raises StandardError do
-        @cartage.send(:run, %w(false))
+        cartage.send(:run, %w(false))
       end
-      assert_equal %Q(Error running 'false'), ex.message
+      assert_equal "Error running 'false'", ex.message
+    end
+  end
+
+  describe '#release_metadata' do
+    it 'has the structure we want' do
+      stub_cartage_repo_url do
+        cartage.send(:release_hashref=, '12345')
+        cartage.timestamp = 3
+
+        expected = {
+          package: {
+            name: 'repo-url',
+            repo: {
+              type: 'git',
+              url: 'git://host/repo-url.git'
+            },
+            hashref: '12345',
+            timestamp: 3
+          }
+        }
+
+        assert_equal expected, cartage.release_metadata
+      end
+    end
+  end
+
+  describe '#build_package' do
+    def disable_unsafe_method(*names, &block)
+      block ||= -> {}
+      names.each { |name| cartage.define_singleton_method name, &block }
+    end
+
+    before do
+      disable_unsafe_method :prepare_work_area, :restore_modified_files,
+        :save_release_metadata, :extract_dependency_cache
+      disable_unsafe_method :create_dependency_cache, &->(_) {}
+    end
+
+    it 'requests :vendor_dependencies and :vendor_dependencies#path' do
+      disable_unsafe_method :request_build_package
+
+      verify_request = ->(f) { assert_equal :vendor_dependencies, f }
+      verify_request_map = ->(f, m) {
+        assert_equal :vendor_dependencies, f
+        assert_equal :path, m
+        []
+      }
+
+      instance_stub Cartage::Plugins, :request, verify_request do
+        instance_stub Cartage::Plugins, :request_map, verify_request_map do
+          cartage.build_package
+        end
+      end
+    end
+
+    it 'requests :pre_build_package, :build_package, and :post_build_package' do
+      disable_unsafe_method :vendor_dependencies
+
+      requests = %i(pre_build_package build_package post_build_package)
+
+      verify_request = ->(f) { assert_equal requests.shift, f }
+
+      instance_stub Cartage::Plugins, :request, verify_request do
+        cartage.build_package
+      end
+
+      assert_empty requests
     end
   end
 end