dima-jeweler 0.9.2 → 1.2.0

data/test/test_generator_mixins.rb

@@ -0,0 +1,18 @@
+require 'test_helper'
+
+class TestGeneratorMixins < Test::Unit::TestCase
+
+  [Jeweler::Generator::BaconMixin, Jeweler::Generator::MicronautMixin,
+   Jeweler::Generator::RspecMixin, Jeweler::Generator::ShouldaMixin,
+   Jeweler::Generator::TestunitMixin, Jeweler::Generator::MinitestMixin].each do |mixin|
+    context "#{mixin}" do
+      %w(default_task feature_support_require feature_support_extend
+         test_dir test_task test_pattern test_filename
+         test_helper_filename).each do |method|
+          should "define #{method}" do
+            assert mixin.method_defined?(method)
+          end
+       end
+    end
+  end
+end

data/test/test_helper.rb

@@ -1,10 +1,24 @@
 require 'test/unit'
 
 require 'rubygems'
-require 'shoulda'
-require 'ruby-debug'
-require 'rr'
-require 'output_catcher'
+begin
+  require 'ruby-debug'
+rescue LoadError
+end
+
+begin
+  require 'shoulda'
+  require 'rr'
+  require 'redgreen'
+rescue LoadError => e
+  puts "*" * 80
+  puts "Some dependencies needed to run tests were missing. Run the following command to find them:"
+  puts
+  puts "\trake development_dependencies:check"
+  puts "*" * 80
+  exit 1
+end
+
 require 'time'
 
 $LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
@@ -13,28 +27,34 @@ require 'jeweler'
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'shoulda_macros/jeweler_macros'
 
-# Use vendored gem because of limited gem availability on runcoderun
-# This is loosely based on 'vendor everything'.
-Dir[File.join(File.dirname(__FILE__), '..', 'vendor', 'gems', '**')].each do |dir|
-  lib = "#{dir}/lib"
-  $LOAD_PATH.unshift(lib) if File.directory?(lib)
+TMP_DIR = File.expand_path('../tmp', __FILE__)
+FIXTURE_DIR = File.expand_path('../fixtures', __FILE__)
+
+class RubyForgeStub
+  attr_accessor :userconfig, :autoconfig
+  def initialize
+    @userconfig = {}
+    @autoconfig = {}
+  end
 end
 
 class Test::Unit::TestCase
   include RR::Adapters::TestUnit unless include?(RR::Adapters::TestUnit)
 
-  def catch_out(&block)
-     OutputCatcher.catch_out do
-       block.call
-     end
+  def tmp_dir
+    TMP_DIR
   end
 
   def fixture_dir
-    File.join(File.dirname(__FILE__), 'fixtures', 'bar')
+    File.join(FIXTURE_DIR, 'bar')
   end
 
-  def tmp_dir
-    File.join(File.dirname(__FILE__), 'tmp')
+  def remove_tmpdir!
+    FileUtils.rm_rf(tmp_dir)
+  end
+
+  def create_tmpdir!
+    FileUtils.mkdir_p(tmp_dir)
   end
 
   def build_spec(*files)
@@ -46,6 +66,74 @@ class Test::Unit::TestCase
       s.description = "Simple and opinionated helper for creating Rubygem projects on GitHub"
       s.authors = ["Josh Nichols"]
       s.files = FileList[*files] unless files.empty?
+      s.version = '0.1.1'
     end
   end
+
+  def self.rubyforge_command_context(description, &block)
+    context description do
+      setup do
+        @command = eval(self.class.name.gsub(/::Test/, '::')).new
+
+        if @command.respond_to? :gemspec=
+          @gemspec = Object.new
+          @command.gemspec = @gemspec
+        end
+
+        if @command.respond_to? :gemspec_helper=
+          @gemspec_helper = Object.new
+          @command.gemspec_helper = @gemspec_helper
+        end
+
+        if @command.respond_to? :rubyforge=
+          @rubyforge = RubyForgeStub.new
+          @command.rubyforge = @rubyforge
+        end
+
+        if @command.respond_to? :output
+          @output = StringIO.new
+          @command.output = @output
+        end
+
+        if @command.respond_to? :repo
+          @repo = Object.new
+          @command.repo = @repo 
+        end
+      end
+
+      context "", &block
+    end
+  end
+
+  def self.build_command_context(description, &block)
+    context description do
+      setup do
+
+        @repo           = Object.new
+        @version_helper = Object.new
+        @gemspec        = Object.new
+        @commit         = Object.new
+        @version        = Object.new
+        @output         = Object.new
+        @base_dir       = Object.new
+        @gemspec_helper = Object.new
+        @rubyforge      = Object.new
+
+        @jeweler        = Object.new
+
+        stub(@jeweler).repo           { @repo }
+        stub(@jeweler).version_helper { @version_helper }
+        stub(@jeweler).gemspec        { @gemspec }
+        stub(@jeweler).commit         { @commit }
+        stub(@jeweler).version        { @version }
+        stub(@jeweler).output         { @output }
+        stub(@jeweler).gemspec_helper { @gemspec_helper }
+        stub(@jeweler).base_dir       { @base_dir }
+        stub(@jeweler).rubyforge    { @rubyforge }
+      end
+
+      context "", &block
+    end
+
+  end
 end

data/test/test_jeweler.rb

@@ -2,135 +2,173 @@ require 'test_helper'
 
 class TestJeweler < Test::Unit::TestCase
 
-  def setup
-    @now = Time.now
-    stub(Time).now { @now }
+  def build_jeweler(base_dir = nil)
+    base_dir ||= non_git_dir_path
+    FileUtils.mkdir_p base_dir
 
-    FileUtils.rm_rf("#{File.dirname(__FILE__)}/tmp")
+    Jeweler.new(build_spec, base_dir)
   end
 
-  def teardown
-    FileUtils.rm_rf("#{File.dirname(__FILE__)}/tmp")
+  def git_dir_path
+    File.join(tmp_dir, 'git')
   end
 
-  context "Initializing jewewler in a blank directory" do
-    setup do
-      FileUtils.mkdir_p(tmp_dir)
-      @jeweler = Jeweler.new(build_spec, tmp_dir)
-    end
+  def non_git_dir_path
+    File.join(tmp_dir, 'nongit')
+  end
 
-    should "not create a VERSION.yml" do
-      assert ! File.exists?(File.join(tmp_dir, 'VERSION.yml'))
+  def build_git_dir
+
+    FileUtils.mkdir_p git_dir_path
+    Dir.chdir git_dir_path do
+      Git.init
     end
   end
 
+  def build_non_git_dir
+    FileUtils.mkdir_p non_git_dir_path
+  end
 
-  context "A Jeweler with a VERSION.yml" do
-    setup do
-      FileUtils.cp_r(fixture_dir, tmp_dir)
-      
-      @jeweler = Jeweler.new(build_spec, tmp_dir)
-      @jeweler.output = StringIO.new
+  should "raise an error if a nil gemspec is given" do
+    assert_raises Jeweler::GemspecError do
+      Jeweler.new(nil)
     end
+  end
 
-    should_have_major_version 1
-    should_have_minor_version 5
-    should_have_patch_version 2
-    should_be_version '1.5.2'
+  should "know if it is in a git repo" do
+    build_git_dir
 
-    context "bumping the patch version" do
-      setup do
-        @jeweler.bump_patch_version 
-      end
-      should_bump_version 1, 5, 3
-    end
+    assert build_jeweler(git_dir_path).in_git_repo?
+  end
 
-    context "bumping the minor version" do
-      setup do
-        @jeweler.bump_minor_version
-      end
+  should "know if it is not in a git repo" do
+    build_non_git_dir
 
-      should_bump_version 1, 6, 0
-    end
+    jeweler = build_jeweler(non_git_dir_path)
+    assert ! jeweler.in_git_repo?, "jeweler doesn't know that #{jeweler.base_dir} is not a git repository"
+  end
 
-    context "bumping the major version" do
-      setup do
-        @jeweler.bump_major_version
-      end
+  should "build and run write gemspec command when writing gemspec" do
+    jeweler = build_jeweler
 
-      should_bump_version 2, 0, 0
-    end
+    command = Object.new
+    mock(command).run
 
-    should "should populate gemspec's files" do
-      assert ! @jeweler.gemspec.files.empty?
-    end
+    mock(Jeweler::Commands::WriteGemspec).build_for(jeweler) { command }
 
-    context "with standard 'files' specified" do
-      setup do
-        @alt_jeweler = Jeweler.new(build_spec("[A-Z]*.*", "{bin,generators,lib,test,spec}/**/*"), tmp_dir)
-      end
-      
-      should "have the same files as when no 'files' are specified" do
-        assert_equal @jeweler.gemspec.files, @alt_jeweler.gemspec.files
-      end
-    end
+    jeweler.write_gemspec
+  end
 
-    context "gemsepc's rdoc" do
-      should 'have be enabled' do
-        assert @jeweler.gemspec.has_rdoc
-      end
+  should "build and run validate gemspec command when validating gemspec" do
+    jeweler = build_jeweler
 
-      should 'do inline source' do
-        assert @jeweler.gemspec.rdoc_options.include?('--inline-source')
-      end
+    command = Object.new
+    mock(command).run
 
-      should 'be utf-8' do
-        assert @jeweler.gemspec.rdoc_options.include?('--charset=UTF-8')
-      end
+    mock(Jeweler::Commands::ValidateGemspec).build_for(jeweler) { command }
 
-    end
+    jeweler.validate_gemspec
+  end
 
-    context "writing the gemspec" do
-      setup do
-        @jeweler.write_gemspec
-        @output = @jeweler.output.string
-      end
+  should "build and run build gem command when building gem" do
+    jeweler = build_jeweler
 
-      should "create bar.gemspec" do
-        assert File.exists?(File.join(tmp_dir, 'bar.gemspec'))
-      end
+    command = Object.new
+    mock(command).run
 
-      should "have created a valid gemspec" do
-        assert @jeweler.valid_gemspec?
-      end
+    mock(Jeweler::Commands::BuildGem).build_for(jeweler) { command }
 
-      should "output the name of the gemspec" do
-        assert_match 'bar.gemspec', @output
-      end
+    jeweler.build_gem
+  end
 
-      context "re-reading the gemspec" do
-        setup do
-          gemspec_path = File.join(tmp_dir, 'bar.gemspec')
-          data = File.read(gemspec_path)
+  should "build and run build gem command when installing gem" do
+    jeweler = build_jeweler
 
-          @parsed_spec = eval("$SAFE = 3\n#{data}", binding, gemspec_path)
-        end
+    command = Object.new
+    mock(command).run
 
-        should "have version 1.5.2" do
-          assert_equal '1.5.2', @parsed_spec.version.version
-        end
+    mock(Jeweler::Commands::InstallGem).build_for(jeweler) { command }
 
-        should "have date filled in" do
-          assert_equal Time.local(@now.year, @now.month, @now.day), @parsed_spec.date
-        end
-      end
-    end
+    jeweler.install_gem
   end
 
-  should "raise an exception when created with a nil gemspec" do
-    assert_raises Jeweler::GemspecError do
-      @jeweler = Jeweler.new(nil, tmp_dir)
-    end
+  should "build and run bump major version command when bumping major version" do
+    jeweler = build_jeweler
+
+    command = Object.new
+    mock(command).run
+
+    mock(Jeweler::Commands::Version::BumpMajor).build_for(jeweler) { command }
+
+    jeweler.bump_major_version
+  end
+
+  should "build and run bump minor version command when bumping minor version" do
+    jeweler = build_jeweler
+
+    command = Object.new
+    mock(command).run
+
+    mock(Jeweler::Commands::Version::BumpMinor).build_for(jeweler) { command }
+
+    jeweler.bump_minor_version
+  end
+
+  should "build and run write version command when writing version" do
+    jeweler = build_jeweler
+
+    command = Object.new
+    mock(command).run
+    mock(command).major=(1)
+    mock(command).minor=(5)
+    mock(command).patch=(2)
+
+    mock(Jeweler::Commands::Version::Write).build_for(jeweler) { command }
+
+    jeweler.write_version(1, 5, 2)
+  end
+
+  should "build and run release command when running release" do
+    jeweler = build_jeweler
+
+    command = Object.new
+    mock(command).run
+
+    mock(Jeweler::Commands::Release).build_for(jeweler) { command }
+
+    jeweler.release
+  end
+
+  should "build and run release to rubyforge command when running release to rubyforge" do
+    jeweler = build_jeweler
+
+    command = Object.new
+    mock(command).run
+
+    mock(Jeweler::Commands::ReleaseToRubyforge).build_for(jeweler) { command }
+
+    jeweler.release_gem_to_rubyforge
+  end
+
+
+  should "respond to gemspec_helper" do
+    assert_respond_to build_jeweler, :gemspec_helper
+  end
+
+  should "respond to version_helper" do
+    assert_respond_to build_jeweler, :version_helper
+  end
+
+  should "respond to repo" do
+    assert_respond_to build_jeweler, :repo
+  end
+
+  should "respond to commit" do
+    assert_respond_to build_jeweler, :commit
+  end
+
+  should "respond to rubyforge" do
+    assert_respond_to build_jeweler, :rubyforge
   end
 
 end

data/test/test_options.rb

@@ -8,6 +8,12 @@ class TestOptions < Test::Unit::TestCase
     end
   end
 
+  def self.should_have_docmentation_framework(documentation_framework)
+    should "use #{documentation_framework} for documentation" do
+      assert_equal documentation_framework.to_sym, @options[:documentation_framework]
+    end
+  end
+
   def setup_options(*arguments)
     @options = Jeweler::Generator::Options.new(arguments)
   end
@@ -22,6 +28,7 @@ class TestOptions < Test::Unit::TestCase
   context "default options" do
     setup { setup_options }
     should_have_testing_framework :shoulda
+    should_have_docmentation_framework :rdoc
     should 'not create repository' do
       assert ! @options[:create_repo]
     end
@@ -57,18 +64,50 @@ class TestOptions < Test::Unit::TestCase
     end
   end
 
+  for_options '--reek' do
+    should 'enable reek' do
+      assert_equal true, @options[:use_reek]
+    end
+  end
+
+  for_options '--roodi' do
+    should 'enable roodi' do
+      assert_equal true, @options[:use_roodi]
+    end
+  end
+
   for_options '--create-repo' do
     should 'create repository' do
       assert @options[:create_repo]
     end
   end
 
+  for_options '--rubyforge' do
+    should 'enable rubyforge' do
+      assert @options[:rubyforge]
+    end
+  end
+
+  for_options '--rdoc' do
+    should_have_docmentation_framework :rdoc
+  end
+
+  for_options '--yard' do
+    should_have_docmentation_framework :yard
+  end
+
   for_options '--summary', 'zomg so awesome' do
     should 'have summary zomg so awesome' do
       assert_equal 'zomg so awesome', @options[:summary]
     end
   end
 
+  for_options '--description', 'Descriptive' do
+    should 'have description Descriptive' do
+      assert_equal 'Descriptive', @options[:description]
+    end
+  end
+
   for_options '--directory', 'foo' do
     should 'have directory foo' do
       assert_equal 'foo', @options[:directory]
@@ -87,4 +126,24 @@ class TestOptions < Test::Unit::TestCase
     end
   end
 
+  for_options '--zomg-invalid' do
+    should 'be an invalid argument' do
+      assert @options[:invalid_argument]
+    end
+  end
+
+  context "merging options" do
+    should "take options from each" do
+      options = Jeweler::Generator::Options.new(["--rspec"]).
+        merge Jeweler::Generator::Options.new(["--create-repo"])
+      assert_equal :rspec, options[:testing_framework]
+      assert options[:create_repo]
+    end
+
+    should "shadow options" do
+      options = Jeweler::Generator::Options.new(["--bacon"]).
+        merge Jeweler::Generator::Options.new(["--rspec"])
+      assert_equal :rspec, options[:testing_framework]
+    end
+  end
 end