namelessjon-jeweler 0.7.2 → 1.0.1

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,15 +1,3 @@
-require 'test/unit'
-
-require 'rubygems'
-gem 'thoughtbot-shoulda'
-require 'shoulda'
-gem 'ruby-debug'
-require 'ruby-debug'
-gem 'mocha'
-require 'mocha'
-
-require File.dirname(__FILE__) + '/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|
@@ -17,36 +5,55 @@ Dir[File.join(File.dirname(__FILE__), '..', 'vendor', 'gems', '**')].each do |di
   $LOAD_PATH.unshift(lib) if File.directory?(lib)
 end
 
-require 'output_catcher'
+require 'test/unit'
+
+require 'rubygems'
+require 'shoulda'
+begin
+  require 'ruby-debug'
+rescue LoadError
+end
+
+require 'rr'
+require 'redgreen'
 require 'time'
 
 $LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
-$LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'jeweler'
 
-# Fake out FileList from Rake
-class FileList
-  def self.[](*args)
-    TMP_DIR.entries - ['.','..','.DS_STORE']
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'shoulda_macros/jeweler_macros'
+
+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
 
-TMP_DIR = File.join(File.dirname(__FILE__), 'tmp')
-FileUtils.rm_f(TMP_DIR) # GAH, dirty hax. Somewhere isn't tearing up correctly, so do some cleanup first
+require 'output_catcher'
 
 class Test::Unit::TestCase
-  def catch_out(&block)
-     OutputCatcher.catch_out do
-       block.call
-     end
+  include RR::Adapters::TestUnit unless include?(RR::Adapters::TestUnit)
+
+  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)
@@ -56,8 +63,71 @@ class Test::Unit::TestCase
       s.email = "josh@technicalpickles.com"
       s.homepage = "http://github.com/technicalpickles/jeweler"
       s.description = "Simple and opinionated helper for creating Rubygem projects on GitHub"
-      s.authors = ["Josh Nichols", "Dan Croak"]
+      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
+      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

@@ -1,133 +1,174 @@
-require File.dirname(__FILE__) + '/test_helper'
+require 'test_helper'
 
 class TestJeweler < Test::Unit::TestCase
 
-  def setup
-    @now = Time.now
-    Time.stubs(:now).returns(@now)
-    FileUtils.rm_rf("#{File.dirname(__FILE__)}/tmp")
+  def build_jeweler(base_dir = nil)
+    base_dir ||= non_git_dir_path
+    FileUtils.mkdir_p base_dir
+
+    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 "A jeweler without a VERSION.yml" 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
+
+  def build_git_dir
 
-    should "not have VERSION.yml" do
-      assert ! File.exists?(File.join(tmp_dir, 'VERSION.yml'))
+    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)
+  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
-        @output = catch_out { @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
-        @output = catch_out { @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
-        @output = catch_out { @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 find 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
-        @output = catch_out { @jeweler.write_gemspec }
-      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

@@ -0,0 +1,116 @@
+require 'test_helper'
+
+class TestOptions < Test::Unit::TestCase
+
+  def self.should_have_testing_framework(testing_framework)
+    should "use #{testing_framework} for testing" do
+      assert_equal testing_framework.to_sym, @options[:testing_framework]
+    end
+  end
+
+  def setup_options(*arguments)
+    @options = Jeweler::Generator::Options.new(arguments)
+  end
+
+  def self.for_options(*options)
+    context options.join(' ') do
+      setup { setup_options *options }
+      yield
+    end
+  end
+
+  context "default options" do
+    setup { setup_options }
+    should_have_testing_framework :shoulda
+    should 'not create repository' do
+      assert ! @options[:create_repo]
+    end
+  end
+
+  for_options '--shoulda' do
+    should_have_testing_framework :shoulda
+  end
+
+  for_options "--bacon" do
+    should_have_testing_framework :bacon
+  end
+
+  for_options "--testunit" do
+    should_have_testing_framework :testunit
+  end
+
+  for_options '--minitest' do
+    should_have_testing_framework :minitest
+  end
+
+  for_options '--rspec' do
+    should_have_testing_framework :rspec
+  end
+
+  for_options '--micronaut' do
+    should_have_testing_framework :micronaut
+  end
+
+  for_options '--cucumber' do
+    should 'enable cucumber' do
+      assert_equal true, @options[:use_cucumber]
+    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 '--summary', 'zomg so awesome' do
+    should 'have summary zomg so awesome' do
+      assert_equal 'zomg so awesome', @options[:summary]
+    end
+  end
+
+  for_options '--directory', 'foo' do
+    should 'have directory foo' do
+      assert_equal 'foo', @options[:directory]
+    end
+  end
+
+  for_options '--help' do
+    should 'show help' do
+      assert @options[:show_help]
+    end
+  end
+
+  for_options '-h' do
+    should 'show help' do
+      assert @options[:show_help]
+    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