gohanlonllc-jeweler 0.11.1.20090513153819

data/test/test_generator.rb

@@ -0,0 +1,154 @@
+require 'test_helper'
+
+class TestGenerator < Test::Unit::TestCase
+  def build_generator(testing_framework = nil, options = {})
+    stub.instance_of(Git::Lib).parse_config '~/.gitconfig' do
+      {'user.name' => 'John Doe', 'user.email' => 'john@example.com', 'github.user' => 'johndoe', 'github.token' => 'yyz'}
+    end
+
+    options[:testing_framework] = testing_framework
+    Jeweler::Generator.new('the-perfect-gem', options)
+  end
+
+  context "initialize" do
+    should "raise error if nil repo name given" do
+      assert_raise Jeweler::NoGitHubRepoNameGiven do
+        Jeweler::Generator.new(nil)
+      end
+    end
+
+    should "raise error if blank repo name given" do
+      assert_raise Jeweler::NoGitHubRepoNameGiven do
+        Jeweler::Generator.new("")
+      end
+    end
+
+    should "have shoulda as default framework" do
+      assert_equal :shoulda, build_generator.testing_framework
+    end
+
+    should "have repository name as default target dir" do
+      assert_equal 'the-perfect-gem', build_generator.target_dir
+    end
+
+    should "have TODO as default summary" do
+      assert_equal "TODO", build_generator.summary
+    end
+
+    should "not create repo by default" do
+      assert ! build_generator.should_create_repo
+    end
+
+    should "not use cucumber by default" do
+      assert ! build_generator.should_use_cucumber
+    end
+
+    should "raise error for invalid testing frameworks" do
+      assert_raise ArgumentError do
+        build_generator(:zomg_invalid)
+      end
+    end
+  end
+
+  should "have the correct git remote" do
+    assert_equal 'git@github.com:johndoe/the-perfect-gem.git', build_generator.git_remote
+  end
+
+  should "have the correct project homepage" do
+    assert_equal 'http://github.com/johndoe/the-perfect-gem', build_generator.project_homepage
+  end
+
+  should "have the correct constant name" do
+    assert_equal "ThePerfectGem", build_generator.constant_name
+  end
+
+  should "have the correct file name prefix" do
+    assert_equal "the_perfect_gem", build_generator.file_name_prefix
+  end
+
+  should "have the correct require name" do
+    assert_equal "the-perfect-gem", build_generator.require_name
+  end
+
+  should "have the correct lib file name" do
+    assert_equal "the-perfect-gem.rb", build_generator.lib_filename
+  end
+
+  def self.should_have_generator_attribute(attribute, value)
+    should "have #{value} for #{attribute}" do
+      assert_equal value, build_generator(@framework).send(attribute)
+    end
+  end
+
+  context "shoulda" do
+    setup { @framework = :shoulda }
+    should_have_generator_attribute :test_task, 'test'
+    should_have_generator_attribute :test_dir, 'test'
+    should_have_generator_attribute :default_task, 'test'
+    should_have_generator_attribute :feature_support_require, 'test/unit/assertions'
+    should_have_generator_attribute :feature_support_extend, 'Test::Unit::Assertions'
+    should_have_generator_attribute :test_pattern, 'test/**/*_test.rb'
+    should_have_generator_attribute :test_filename, 'the-perfect-gem_test.rb'
+    should_have_generator_attribute :test_helper_filename, 'test_helper.rb'
+  end
+
+  context "testunit" do
+    setup { @framework = :testunit }
+    should_have_generator_attribute :test_task, 'test'
+    should_have_generator_attribute :test_dir, 'test'
+    should_have_generator_attribute :default_task, 'test'
+    should_have_generator_attribute :feature_support_require, 'test/unit/assertions'
+    should_have_generator_attribute :feature_support_extend, 'Test::Unit::Assertions'
+    should_have_generator_attribute :test_pattern, 'test/**/*_test.rb'
+    should_have_generator_attribute :test_filename, 'the-perfect-gem_test.rb'
+    should_have_generator_attribute :test_helper_filename, 'test_helper.rb'
+  end
+
+  context "minitest" do
+    setup { @framework = :minitest }
+    should_have_generator_attribute :test_task, 'test'
+    should_have_generator_attribute :test_dir, 'test'
+    should_have_generator_attribute :default_task, 'test'
+    should_have_generator_attribute :feature_support_require, 'mini/test'
+    should_have_generator_attribute :feature_support_extend, 'Mini::Test::Assertions'
+    should_have_generator_attribute :test_pattern, 'test/**/*_test.rb'
+    should_have_generator_attribute :test_filename, 'the-perfect-gem_test.rb'
+    should_have_generator_attribute :test_helper_filename, 'test_helper.rb'
+  end
+
+  context "bacon" do
+    setup { @framework = :bacon }
+    should_have_generator_attribute :test_task, 'spec'
+    should_have_generator_attribute :test_dir, 'spec'
+    should_have_generator_attribute :default_task, 'spec'
+    should_have_generator_attribute :feature_support_require, 'test/unit/assertions'
+    should_have_generator_attribute :feature_support_extend, 'Test::Unit::Assertions'
+    should_have_generator_attribute :test_pattern, 'spec/**/*_spec.rb'
+    should_have_generator_attribute :test_filename, 'the-perfect-gem_spec.rb'
+    should_have_generator_attribute :test_helper_filename, 'spec_helper.rb'
+  end
+
+  context "rspec" do
+    setup { @framework = :rspec }
+    should_have_generator_attribute :test_task, 'spec'
+    should_have_generator_attribute :test_dir, 'spec'
+    should_have_generator_attribute :default_task, 'spec'
+    should_have_generator_attribute :feature_support_require, 'spec/expectations'
+    should_have_generator_attribute :feature_support_extend, nil
+    should_have_generator_attribute :test_pattern, 'spec/**/*_spec.rb'
+    should_have_generator_attribute :test_filename, 'the-perfect-gem_spec.rb'
+    should_have_generator_attribute :test_helper_filename, 'spec_helper.rb'
+  end
+
+  context "micronaut" do
+    setup { @framework = :micronaut }
+    should_have_generator_attribute :test_task, 'examples'
+    should_have_generator_attribute :test_dir, 'examples'
+    should_have_generator_attribute :default_task, 'examples'
+    should_have_generator_attribute :feature_support_require, 'micronaut/expectations'
+    should_have_generator_attribute :feature_support_extend, 'Micronaut::Matchers'
+    should_have_generator_attribute :test_pattern, 'examples/**/*_example.rb'
+    should_have_generator_attribute :test_filename, 'the-perfect-gem_example.rb'
+    should_have_generator_attribute :test_helper_filename, 'example_helper.rb'
+  end
+end

data/test/test_generator_initialization.rb

@@ -0,0 +1,113 @@
+require 'test_helper'
+
+class TestGeneratorInitialization < Test::Unit::TestCase
+  def setup
+    @project_name = 'the-perfect-gem'
+    @git_name = 'foo'
+    @git_email = 'bar@example.com'
+    @github_user = 'technicalpickles'
+    @github_token = 'zomgtoken'
+  end
+
+  def stub_git_config(options = {})
+    stub.instance_of(Git::Lib).parse_config('~/.gitconfig') { options }
+  end
+
+  context "given a nil github repo name" do
+    setup do
+      stub_git_config
+
+      @block = lambda {  }
+    end
+
+    should 'raise NoGithubRepoNameGiven' do
+      assert_raise Jeweler::NoGitHubRepoNameGiven do
+        Jeweler::Generator.new(nil)
+      end
+    end
+  end
+
+  context "without git user's name set" do
+    setup do
+      stub_git_config 'user.email' => @git_email
+    end
+
+    should 'raise an NoGitUserName' do
+      assert_raise Jeweler::NoGitUserName do
+        Jeweler::Generator.new(@project_name)
+      end
+    end
+  end
+
+  context "without git user's email set" do
+    setup do
+      stub_git_config 'user.name' => @git_name
+    end
+
+    should 'raise NoGitUserName' do
+      assert_raise Jeweler::NoGitUserEmail do
+        Jeweler::Generator.new(@project_name)
+      end
+    end
+  end
+
+  context "without github username set" do
+    setup do
+      stub_git_config 'user.email' => @git_email, 'user.name' => @git_name
+    end
+
+    should 'raise NotGitHubUser' do
+      assert_raise Jeweler::NoGitHubUser do
+        Jeweler::Generator.new(@project_name)
+      end
+    end
+  end
+  
+  context "without github token set" do
+    setup do
+      stub_git_config 'user.name' => @git_name, 'user.email' => @git_email, 'github.user' => @github_user
+    end
+
+    should 'raise NoGitHubToken if creating repo' do
+      assert_raise Jeweler::NoGitHubToken do
+        Jeweler::Generator.new(@project_name, :create_repo => true)
+      end
+    end
+  end
+  
+  context "with valid git user configuration" do
+    setup do
+      stub_git_config 'user.name' => @git_name, 'user.email' => @git_email, 'github.user' => @github_user, 'github.token' => @github_token
+    end
+
+    context "for technicalpickle's the-perfect-gem repository" do
+      setup do
+        @generator = Jeweler::Generator.new(@project_name)
+      end
+
+      should "assign user's name from git config" do
+        assert_equal @git_name, @generator.user_name
+      end
+
+      should "assign email from git config" do
+        assert_equal @git_email, @generator.user_email
+      end
+
+      should "assign github remote" do
+        assert_equal 'git@github.com:technicalpickles/the-perfect-gem.git', @generator.git_remote
+      end
+
+      should "assign github username from git config" do
+        assert_equal @github_user, @generator.github_username
+      end
+
+      should "determine project name as the-perfect-gem" do
+        assert_equal @project_name, @generator.project_name
+      end
+
+      should "determine target directory as the same as the github repository name" do
+        assert_equal @generator.project_name, @generator.target_dir
+      end
+    end
+  end
+end

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

@@ -0,0 +1,133 @@
+# 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)
+end
+
+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')
+require 'jeweler'
+
+$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
+
+require 'output_catcher'
+
+class Test::Unit::TestCase
+  include RR::Adapters::TestUnit unless include?(RR::Adapters::TestUnit)
+
+  def tmp_dir
+    TMP_DIR
+  end
+
+  def fixture_dir
+    File.join(FIXTURE_DIR, 'bar')
+  end
+
+  def remove_tmpdir!
+    FileUtils.rm_rf(tmp_dir)
+  end
+
+  def create_tmpdir!
+    FileUtils.mkdir_p(tmp_dir)
+  end
+
+  def build_spec(*files)
+    Gem::Specification.new do |s|
+      s.name = "bar"
+      s.summary = "Simple and opinionated helper for creating Rubygem projects on GitHub"
+      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"]
+      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

@@ -0,0 +1,174 @@
+require 'test_helper'
+
+class TestJeweler < Test::Unit::TestCase
+
+  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 git_dir_path
+    File.join(tmp_dir, 'git')
+  end
+
+  def non_git_dir_path
+    File.join(tmp_dir, 'nongit')
+  end
+
+  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
+
+  should "raise an error if a nil gemspec is given" do
+    assert_raises Jeweler::GemspecError do
+      Jeweler.new(nil)
+    end
+  end
+
+  should "know if it is in a git repo" do
+    build_git_dir
+
+    assert build_jeweler(git_dir_path).in_git_repo?
+  end
+
+  should "know if it is not in a git repo" do
+    build_non_git_dir
+
+    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
+
+  should "build and run write gemspec command when writing gemspec" do
+    jeweler = build_jeweler
+
+    command = Object.new
+    mock(command).run
+
+    mock(Jeweler::Commands::WriteGemspec).build_for(jeweler) { command }
+
+    jeweler.write_gemspec
+  end
+
+  should "build and run validate gemspec command when validating gemspec" do
+    jeweler = build_jeweler
+
+    command = Object.new
+    mock(command).run
+
+    mock(Jeweler::Commands::ValidateGemspec).build_for(jeweler) { command }
+
+    jeweler.validate_gemspec
+  end
+
+  should "build and run build gem command when building gem" do
+    jeweler = build_jeweler
+
+    command = Object.new
+    mock(command).run
+
+    mock(Jeweler::Commands::BuildGem).build_for(jeweler) { command }
+
+    jeweler.build_gem
+  end
+
+  should "build and run build gem command when installing gem" do
+    jeweler = build_jeweler
+
+    command = Object.new
+    mock(command).run
+
+    mock(Jeweler::Commands::InstallGem).build_for(jeweler) { command }
+
+    jeweler.install_gem
+  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