nex3-github 0.1.2 → 0.1.3

data/spec/extensions_spec.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+describe "When calling #try" do
+  specify "objects should return themselves" do
+    obj = 1; obj.try.should equal(obj)
+    obj = "foo"; obj.try.should equal(obj)
+    obj = { :foo => "bar" }; obj.try.should equal(obj)
+  end
+
+  specify "objects should behave as if #try wasn't called" do
+    "foo".try.size.should == 3
+    { :foo => :bar }.try.fetch(:foo).should == :bar
+  end
+
+  specify "nil should return the singleton NilClass::NilProxy" do
+    nil.try.should equal(NilClass::NilProxy)
+  end
+
+  specify "nil should ignore any calls made past #try" do
+    nil.try.size.should == nil
+    nil.try.sdlfj.should == nil
+  end
+
+  specify "classes should respond just like objects" do
+    String.try.should equal(String)
+  end
+end
+
+describe "When calling #tap" do
+  specify "objects should behave like Ruby 1.9's #tap" do
+    obj = "foo"
+    obj.tap { |obj| obj.size.should == 3 }.should equal(obj)
+  end
+end

data/spec/github_spec.rb

@@ -0,0 +1,51 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "GitHub.parse_options" do
+  it "should parse --bare options" do
+    args = ["--bare", "--test"]
+    GitHub.parse_options(args).should == {:bare => true, :test => true}
+    args.should == []
+  end
+
+  it "should parse options intermixed with non-options" do
+    args = ["text", "--bare", "more text", "--option", "--foo"]
+    GitHub.parse_options(args).should == {:bare => true, :option => true, :foo => true}
+    args.should == ["text", "more text"]
+  end
+
+  it "should parse --foo=bar style options" do
+    args = ["--foo=bar", "--bare"]
+    GitHub.parse_options(args).should == {:bare => true, :foo => "bar"}
+    args.should == []
+  end
+
+  it "should stop parsing options at --" do
+    args = ["text", "--bare", "--", "--foo"]
+    GitHub.parse_options(args).should == {:bare => true}
+    args.should == ["text", "--foo"]
+  end
+
+  it "should handle duplicate options" do
+    args = ["text", "--foo=bar", "--bare", "--foo=baz"]
+    GitHub.parse_options(args).should == {:foo => "baz", :bare => true}
+    args.should == ["text"]
+  end
+
+  it "should handle duplicate --bare options surrounding --" do
+    args = ["text", "--bare", "--", "--bare"]
+    GitHub.parse_options(args).should == {:bare => true}
+    args.should == ["text", "--bare"]
+  end
+
+  it "should handle no options" do
+    args = ["text", "more text"]
+    GitHub.parse_options(args).should == {}
+    args.should == ["text", "more text"]
+  end
+
+  it "should handle no args" do
+    args = []
+    GitHub.parse_options(args).should == {}
+    args.should == []
+  end
+end

data/spec/helper_spec.rb

@@ -0,0 +1,188 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+class HelperRunner
+  def initialize(parent, name)
+    @parent = parent
+    @name = name
+  end
+
+  def run(&block)
+    self.instance_eval(&block)
+  end
+
+  def it(str, &block)
+    @parent.send :it, "#{@name} #{str}", &block
+  end
+  alias specify it
+end
+
+describe GitHub::Helper do
+  include SetupMethods
+
+  def self.helper(name, &block)
+    HelperRunner.new(self, name).run(&block)
+  end
+
+  before(:each) do
+    @helper = GitHub::Helper.new
+  end
+
+  helper :owner do
+    it "should return repo owner" do
+      setup_url_for :origin, "hacker"
+      @helper.owner.should == "hacker"
+    end
+  end
+
+  helper :private_url_for do
+    it "should return ssh-style url" do
+      setup_url_for :origin, "user", "merb-core"
+      @helper.private_url_for("wycats").should == "git@github.com:wycats/merb-core.git"
+    end
+  end
+
+  helper :project do
+    it "should return project-awesome" do
+      setup_url_for :origin, "user", "project-awesome"
+      @helper.project.should == "project-awesome"
+    end
+
+    it "should exit due to missing origin" do
+      @helper.should_receive(:url_for).twice.with(:origin).and_return("")
+      STDERR.should_receive(:puts).with("Error: missing remote 'origin'")
+      lambda { @helper.project }.should raise_error(SystemExit)
+    end
+
+    it "should exit due to non-github origin" do
+      @helper.should_receive(:url_for).twice.with(:origin).and_return("home:path/to/repo.git")
+      STDERR.should_receive(:puts).with("Error: remote 'origin' is not a github URL")
+      lambda { @helper.project }.should raise_error(SystemExit)
+    end
+  end
+
+  helper :public_url_for do
+    it "should return git:// URL" do
+      setup_url_for :origin, "user", "merb-core"
+      @helper.public_url_for("wycats").should == "git://github.com/wycats/merb-core.git"
+    end
+  end
+
+  helper :repo_for do
+    it "should return mephisto.git" do
+      setup_url_for :mojombo, "mojombo", "mephisto"
+      @helper.repo_for(:mojombo).should == "mephisto.git"
+    end
+  end
+
+  helper :user_and_repo_from do
+    it "should parse a git:// url" do
+      @helper.user_and_repo_from("git://github.com/defunkt/github.git").should == ["defunkt", "github.git"]
+    end
+
+    it "should parse a ssh-based url" do
+      @helper.user_and_repo_from("git@github.com:mojombo/god.git").should == ["mojombo", "god.git"]
+    end
+
+    it "should parse a non-standard ssh-based url" do
+      @helper.user_and_repo_from("ssh://git@github.com:mojombo/god.git").should == ["mojombo", "god.git"]
+      @helper.user_and_repo_from("github.com:mojombo/god.git").should == ["mojombo", "god.git"]
+      @helper.user_and_repo_from("ssh://github.com:mojombo/god.git").should == ["mojombo", "god.git"]
+    end
+
+    it "should return nothing for other urls" do
+      @helper.user_and_repo_from("home:path/to/repo.git").should == nil
+    end
+
+    it "should return nothing for invalid git:// urls" do
+      @helper.user_and_repo_from("git://github.com/foo").should == nil
+    end
+
+    it "should return nothing for invalid ssh-based urls" do
+      @helper.user_and_repo_from("git@github.com:kballard").should == nil
+      @helper.user_and_repo_from("git@github.com:kballard/test/repo.git").should == nil
+      @helper.user_and_repo_from("ssh://git@github.com:kballard").should == nil
+      @helper.user_and_repo_from("github.com:kballard").should == nil
+      @helper.user_and_repo_from("ssh://github.com:kballard").should == nil
+    end
+  end
+
+  helper :user_for do
+    it "should return defunkt" do
+      setup_url_for :origin, "defunkt"
+      @helper.user_for(:origin).should == "defunkt"
+    end
+  end
+
+  helper :url_for do
+    it "should call out to the shell" do
+      @helper.should_receive(:`).with("git config --get remote.origin.url").and_return "git://github.com/user/project.git\n"
+      @helper.url_for(:origin).should == "git://github.com/user/project.git"
+    end
+  end
+
+  helper :remotes do
+    it "should return a list of remotes" do
+      @helper.should_receive(:`).with('git config --get-regexp \'^remote\.(.+)\.url$\'').and_return <<-EOF
+remote.origin.url git@github.com:kballard/github-gem.git
+remote.defunkt.url git://github.com/defunkt/github-gem.git
+remote.nex3.url git://github.com/nex3/github-gem.git
+      EOF
+      @helper.remotes.should == {
+        :origin => "git@github.com:kballard/github-gem.git",
+        :defunkt => "git://github.com/defunkt/github-gem.git",
+        :nex3 => "git://github.com/nex3/github-gem.git"
+      }
+    end
+  end
+
+  helper :tracking do
+    it "should return a list of remote/user_or_url pairs" do
+      @helper.should_receive(:remotes).and_return({
+        :origin => "git@github.com:kballard/github-gem.git",
+        :defunkt => "git://github.com/defunkt/github-gem.git",
+        :external => "server:path/to/github-gem.git"
+      })
+      @helper.tracking.should == {
+        :origin => "kballard",
+        :defunkt => "defunkt",
+        :external => "server:path/to/github-gem.git"
+      }
+    end
+  end
+
+  helper :tracking? do
+    it "should return whether the user is tracked" do
+      @helper.should_receive(:tracking).any_number_of_times.and_return({
+        :origin => "kballard",
+        :defunkt => "defunkt",
+        :external => "server:path/to/github-gem.git"
+      })
+      @helper.tracking?("kballard").should == true
+      @helper.tracking?("defunkt").should == true
+      @helper.tracking?("nex3").should == false
+    end
+  end
+
+  helper :user_and_branch do
+    it "should return owner and branch for unqualified branches" do
+      setup_url_for
+      @helper.should_receive(:`).with("git rev-parse --symbolic-full-name HEAD").and_return "refs/heads/master"
+      @helper.user_and_branch.should == ["user", "master"]
+    end
+
+    it "should return user and branch for user/branch-style branches" do
+      @helper.should_receive(:`).with("git rev-parse --symbolic-full-name HEAD").and_return "refs/heads/defunkt/wip"
+      @helper.user_and_branch.should == ["defunkt", "wip"]
+    end
+  end
+
+  helper :open do
+    it "should launch the URL" do
+      Launchy::Browser.next_instance.tap do |browser|
+        browser.should_receive(:my_os_family).any_number_of_times.and_return :windows # avoid forking
+        browser.should_receive(:system).with("/usr/bin/open http://www.google.com")
+      end
+      @helper.open "http://www.google.com"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -3,7 +3,131 @@ require 'spec'
 
 require File.dirname(__FILE__) + '/../lib/github'
 
-module GitHub
-  load 'helpers.rb'
-  load 'commands.rb'
-end
+class Module
+  def metaclass
+    class << self;self;end
+  end
+end
+
+class Spec::NextInstanceProxy
+  def initialize
+    @deferred = []
+  end
+
+  def method_missing(sym, *args)
+    proxy = Spec::NextInstanceProxy.new
+    @deferred << [sym, args, proxy]
+    proxy
+  end
+
+  def should_receive(*args)
+    method_missing(:should_receive, *args)
+  end
+  alias stub! should_receive
+
+  def invoke(obj)
+    @deferred.each do |(sym, args, proxy)|
+      result = obj.send(sym, *args)
+      proxy.invoke(result)
+    end
+  end
+end
+
+class Class
+  def next_instance
+    meth = metaclass.instance_method(:new)
+    proxy = Spec::NextInstanceProxy.new
+    metaclass.send :define_method, :new do |*args|
+      instance = meth.bind(self).call(*args)
+      proxy.invoke(instance)
+      metaclass.send :define_method, :new, meth
+      instance
+    end
+    proxy
+  end
+end
+
+module Spec::Example::ExampleGroupSubclassMethods
+  def add_guard(klass, name, is_class = false)
+    guarded = nil # define variable now for scoping
+    target = (is_class ? klass.metaclass : klass)
+    sep = (is_class ? "." : "#")
+    target.class_eval do
+      guarded = instance_method(name)
+      define_method name do |*args|
+        raise "Testing guards violated: Cannot call #{klass}#{sep}#{name}"
+      end
+    end
+    @guards ||= []
+    @guards << [klass, name, is_class, guarded]
+  end
+
+  def add_class_guard(klass, name)
+    add_guard(klass, name, true)
+  end
+
+  def unguard(klass, name, is_class = false)
+    row = @guards.find { |(k,n,i)| k == klass and n == name and i == is_class }
+    raise "#{klass}#{is_class ? "." : "#"}#{name} is not guarded" if row.nil?
+    (is_class ? klass.metaclass : klass).class_eval do
+      define_method name, row.last
+    end
+    @guards.delete row
+  end
+
+  def class_unguard(klass, name)
+    unguard(klass, name, true)
+  end
+
+  def unguard_all
+    @guards ||= []
+    @guards.each do |klass, name, is_class, guarded|
+      (is_class ? klass.metaclass : klass).class_eval do
+        define_method name, guarded
+      end
+    end
+    @guards.clear
+  end
+end
+
+# prevent the use of `` in tests
+Spec::Runner.configure do |configuration|
+  # load this here so it's covered by the `` guard
+  configuration.prepend_before(:all) do
+    module GitHub
+      load 'helpers.rb'
+      load 'commands.rb'
+    end
+  end
+
+  configuration.prepend_before(:all) do
+    self.class.send :include, Spec::Example::ExampleGroupSubclassMethods
+  end
+
+  configuration.prepend_before(:each) do
+    add_guard Kernel, :`
+    add_guard Kernel, :system
+    add_guard Kernel, :fork
+    add_guard Kernel, :exec
+    add_class_guard Process, :fork
+  end
+
+  configuration.append_after(:each) do
+    unguard_all
+  end
+end
+
+# include this in any example group that defines @helper
+module SetupMethods
+  def setup_user_and_branch(user = :user, branch = :master)
+    @helper.should_receive(:user_and_branch).any_number_of_times.and_return([user, branch])
+  end
+
+  def setup_url_for(remote = :origin, user = nil, project = :project)
+    if user.nil?
+      user = remote
+      user = "user" if remote == :origin
+    end
+    @helper.should_receive(:url_for).any_number_of_times.with(remote).and_return("git://github.com/#{user}/#{project}.git")
+  end
+end

data/spec/ui_spec.rb

@@ -0,0 +1,406 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "github" do
+  # -- home --
+  specify "home should open the project home page" do
+    running :home do
+      setup_url_for
+      @helper.should_receive(:open).once.with("https://github.com/user/project/tree/master")
+    end
+  end
+
+  specify "home defunkt should open the home page of defunkt's fork" do
+    running :home, "defunkt" do
+      setup_url_for
+      @helper.should_receive(:open).once.with("https://github.com/defunkt/project/tree/master")
+    end
+  end
+
+  # -- browse --
+  specify "browse should open the project home page with the current branch" do
+    running :browse do
+      setup_url_for
+      setup_user_and_branch("user", "test-branch")
+      @helper.should_receive(:open).once.with("https://github.com/user/project/tree/test-branch")
+    end
+  end
+
+  specify "browse pending should open the project home page with the 'pending' branch" do
+    running :browse, "pending" do
+      setup_url_for
+      setup_user_and_branch("user", "test-branch")
+      @helper.should_receive(:open).once.with("https://github.com/user/project/tree/pending")
+    end
+  end
+
+  specify "browse defunkt pending should open the home page of defunkt's fork with the 'pending' branch" do
+    running :browse, "defunkt", "pending" do
+      setup_url_for
+      @helper.should_receive(:open).once.with("https://github.com/defunkt/project/tree/pending")
+    end
+  end
+
+  specify "browse defunkt/pending should open the home page of defunkt's fork with the 'pending' branch" do
+    running :browse, "defunkt/pending" do
+      setup_url_for
+      @helper.should_receive(:open).once.with("https://github.com/defunkt/project/tree/pending")
+    end
+  end
+
+  # -- network --
+  specify "network should open the network page for this repo" do
+    running :network do
+      setup_url_for
+      @helper.should_receive(:open).once.with("https://github.com/user/project/network")
+    end
+  end
+
+  specify "network defunkt should open the network page for defunkt's fork" do
+    running :network, "defunkt" do
+      setup_url_for
+      @helper.should_receive(:open).once.with("https://github.com/defunkt/project/network")
+    end
+  end
+
+  # -- info --
+  specify "info should show info for this project" do
+    running :info do
+      setup_url_for
+      setup_remote(:origin, :user => "user", :ssh => true)
+      setup_remote(:defunkt)
+      setup_remote(:external, :url => "home:/path/to/project.git")
+      stdout.should == <<-EOF
+== Info for project
+You are user
+Currently tracking:
+ - user (as origin)
+ - defunkt (as defunkt)
+ - home:/path/to/project.git (as external)
+EOF
+    end
+  end
+
+  # -- track --
+  specify "track defunkt should track a new remote for defunkt" do
+    running :track, "defunkt" do
+      setup_url_for
+      @helper.should_receive(:tracking?).with("defunkt").once.and_return(false)
+      @command.should_receive(:git).with("remote add defunkt git://github.com/defunkt/project.git").once
+    end
+  end
+
+  specify "track --private defunkt should track a new remove for defunkt using ssh" do
+    running :track, "--private", "defunkt" do
+      setup_url_for
+      @helper.should_receive(:tracking?).with("defunkt").once.and_return(false)
+      @command.should_receive(:git).with("remote add defunkt git@github.com:defunkt/project.git").once
+    end
+  end
+
+  specify "track defunkt should die if the defunkt remote exists" do
+    running :track, "defunkt" do
+      setup_url_for
+      @helper.should_receive(:tracking?).with("defunkt").once.and_return(true)
+      @command.should_receive(:die).with("Already tracking defunkt").and_return { raise "Died" }
+      self.should raise_error("Died")
+    end
+  end
+
+  specify "track should die with no args" do
+    running :track do
+      @command.should_receive(:die).with("Specify a user to track").and_return { raise "Died" }
+      self.should raise_error("Died")
+    end
+  end
+
+  # -- pull --
+  specify "pull should die with no args" do
+    running :pull do
+      @command.should_receive(:die).with("Specify a user to pull from").and_return { raise "Died" }
+      self.should raise_error("Died")
+    end
+  end
+
+  specify "pull defunkt should start tracking defunkt if they're not already tracked" do
+    running :pull, "defunkt" do
+      setup_remote(:origin, :user => "user", :ssh => true)
+      setup_remote(:external, :url => "home:/path/to/project.git")
+      GitHub.should_receive(:invoke).with(:track, "defunkt").and_return { raise "Tracked" }
+      self.should raise_error("Tracked")
+    end
+  end
+
+  specify "pull defunkt should create defunkt/master and pull from the defunkt remote" do
+    running :pull, "defunkt" do
+      setup_remote(:defunkt)
+      @command.should_receive(:git).with("checkout -b defunkt/master").ordered.and_return do
+        mock("checkout -b defunkt/master").tap { |m| m.stub!(:error?) }
+      end
+      @command.should_receive(:git_exec).with("pull defunkt master").ordered
+      stdout.should == "Switching to defunkt/master"
+    end
+  end
+
+  specify "pull defunkt should switch to pre-existing defunkt/master and pull from the defunkt remote" do
+    running :pull, "defunkt" do
+      setup_remote(:defunkt)
+      @command.should_receive(:git).with("checkout -b defunkt/master").ordered.and_return do
+        mock("checkout -b defunkt/master").tap { |m| m.should_receive(:error?) { true } }
+      end
+      @command.should_receive(:git).with("checkout defunkt/master").ordered
+      @command.should_receive(:git_exec).with("pull defunkt master").ordered
+      stdout.should == "Switching to defunkt/master"
+    end
+  end
+
+  specify "pull defunkt wip should create defunkt/wip and pull from wip branch on defunkt remote" do
+    running :pull, "defunkt", "wip" do
+      setup_remote(:defunkt)
+      @command.should_receive(:git).with("checkout -b defunkt/wip").ordered.and_return do
+        mock("checkout -b defunkt/wip").tap { |m| m.stub!(:error?) }
+      end
+      @command.should_receive(:git_exec).with("pull defunkt wip").ordered
+      stdout.should == "Switching to defunkt/wip"
+    end
+  end
+
+  specify "pull defunkt/wip should switch to pre-existing defunkt/wip and pull from wip branch on defunkt remote" do
+    running :pull, "defunkt/wip" do
+      setup_remote(:defunkt)
+      @command.should_receive(:git).with("checkout -b defunkt/wip").ordered.and_return do
+        mock("checkout -b defunkt/wip").tap { |m| m.should_receive(:error?) { true } }
+      end
+      @command.should_receive(:git).with("checkout defunkt/wip").ordered
+      @command.should_receive(:git_exec).with("pull defunkt wip").ordered
+      stdout.should == "Switching to defunkt/wip"
+    end
+  end
+
+  specify "pull --merge defunkt should pull from defunkt remote into current branch" do
+    running :pull, "--merge", "defunkt" do
+      setup_remote(:defunkt)
+      @command.should_receive(:git_exec).with("pull defunkt master")
+    end
+  end
+
+  # -- clone --
+  specify "clone should die with no args" do
+    running :clone do
+      @command.should_receive(:die).with("Specify a user to pull from").and_return { raise "Died" }
+      self.should raise_error("Died")
+    end
+  end
+
+  specify "clone should die with just one arg" do
+    running :clone, "user" do
+      @command.should_receive(:die).with("Specify a repo to pull from").and_return { raise "Died" }
+      self.should raise_error("Died")
+    end
+  end
+
+  specify "clone defunkt github-gem should clone the repo" do
+    running :clone, "defunkt", "github-gem" do
+      @command.should_receive(:git_exec).with("clone git://github.com/defunkt/github-gem.git")
+    end
+  end
+
+  specify "clone --ssh defunkt github-gem should clone the repo using the private URL" do
+    running :clone, "--ssh", "defunkt", "github-gem" do
+      @command.should_receive(:git_exec).with("clone git@github.com:defunkt/github-gem.git")
+    end
+  end
+
+  specify "clone defunkt github-gem repo should clone the repo into the dir 'repo'" do
+    running :clone, "defunkt", "github-gem", "repo" do
+      @command.should_receive(:git_exec).with("clone git://github.com/defunkt/github-gem.git repo")
+    end
+  end
+
+  specify "clone --ssh defunkt github-gem repo should clone the repo using the private URL into the dir 'repo'" do
+    running :clone, "--ssh", "defunkt", "github-gem", "repo" do
+      @command.should_receive(:git_exec).with("clone git@github.com:defunkt/github-gem.git repo")
+    end
+  end
+
+  # -- pull-request --
+  specify "pull-request should die with no args" do
+    running :'pull-request' do
+      setup_url_for
+      @command.should_receive(:die).with("Specify a user for the pull request").and_return { raise "Died" }
+      self.should raise_error("Died")
+    end
+  end
+
+  specify "pull-request user should track user if untracked" do
+    running :'pull-request', "user" do
+      setup_url_for
+      setup_remote :origin, :user => "kballard"
+      setup_remote :defunkt
+      GitHub.should_receive(:invoke).with(:track, "user").and_return { raise "Tracked" }
+      self.should raise_error("Tracked")
+    end
+  end
+
+  specify "pull-request user/branch should generate a pull request" do
+    running :'pull-request', "user/branch" do
+      setup_url_for
+      setup_remote :origin, :user => "kballard"
+      setup_remote :user
+      @command.should_receive(:git_exec).with("request-pull user/branch origin")
+    end
+  end
+
+  specify "pull-request user should generate a pull request with branch master" do
+    running :'pull-request', "user" do
+      setup_url_for
+      setup_remote :origin, :user => "kballard"
+      setup_remote :user
+      @command.should_receive(:git_exec).with("request-pull user/master origin")
+    end
+  end
+
+  specify "pull-request user branch should generate a pull request" do
+    running:'pull-request', "user", "branch" do
+      setup_url_for
+      setup_remote :origin, :user => "kballard"
+      setup_remote :user
+      @command.should_receive(:git_exec).with("request-pull user/branch origin")
+    end
+  end
+
+  # -- default --
+  specify "should print the default message" do
+    running :default do
+      GitHub.should_receive(:descriptions).any_number_of_times.and_return({
+        "home" => "Open the home page",
+        "track" => "Track a new repo",
+        "browse" => "Browse the github page for this branch",
+        "command" => "description"
+      })
+      GitHub.should_receive(:flag_descriptions).any_number_of_times.and_return({
+        "home" => {:flag => "Flag description"},
+        "track" => {:flag1 => "Flag one", :flag2 => "Flag two"},
+        "browse" => {},
+        "command" => {}
+      })
+      @command.should_receive(:puts).with("Usage: github command <space separated arguments>", '').ordered
+      @command.should_receive(:puts).with("Available commands:", '').ordered
+      @command.should_receive(:puts).with("  home    => Open the home page")
+      @command.should_receive(:puts).with("           --flag: Flag description")
+      @command.should_receive(:puts).with("  track   => Track a new repo")
+      @command.should_receive(:puts).with("           --flag1: Flag one")
+      @command.should_receive(:puts).with("           --flag2: Flag two")
+      @command.should_receive(:puts).with("  browse  => Browse the github page for this branch")
+      @command.should_receive(:puts).with("  command => description")
+      @command.should_receive(:puts).with()
+    end
+  end
+
+  # -----------------
+
+  def running(cmd, *args, &block)
+    Runner.new(self, cmd, *args, &block).run
+  end
+
+  class Runner
+    include SetupMethods
+
+    def initialize(parent, cmd, *args, &block)
+      @cmd_name = cmd.to_s
+      @command = GitHub.commands[cmd.to_s]
+      @helper = @command.helper
+      @args = args
+      @block = block
+      @parent = parent
+    end
+
+    def run
+      self.instance_eval &@block
+      mock_remotes unless @remotes.nil?
+      GitHub.should_receive(:load).with("commands.rb")
+      GitHub.should_receive(:load).with("helpers.rb")
+      args = @args.clone
+      GitHub.parse_options(args) # strip out the flags
+      GitHub.should_receive(:invoke).with(@cmd_name, *args).and_return do
+        GitHub.send(GitHub.send(:__mock_proxy).send(:munge, :invoke), @cmd_name, *args)
+      end
+      invoke = lambda { GitHub.activate([@cmd_name, *@args]) }
+      if @expected_result
+        expectation, result = @expected_result
+        case result
+        when Spec::Matchers::RaiseError, Spec::Matchers::Change, Spec::Matchers::ThrowSymbol
+          invoke.send expectation, result
+        else
+          invoke.call.send expectation, result
+        end
+      else
+        invoke.call
+      end
+      @stdout_mock.invoke unless @stdout_mock.nil?
+    end
+
+    def setup_remote(remote, options = {:user => nil, :project => "project"})
+      @remotes ||= {}
+      user = options[:user] || remote
+      project = options[:project]
+      ssh = options[:ssh]
+      url = options[:url]
+      if url
+        @remotes[remote.to_sym] = url
+      elsif ssh
+        @remotes[remote.to_sym] = "git@github.com:#{user}/#{project}.git"
+      else
+        @remotes[remote.to_sym] = "git://github.com/#{user}/#{project}.git"
+      end
+    end
+
+    def mock_remotes()
+      @helper.should_receive(:remotes).any_number_of_times.and_return(@remotes)
+    end
+
+    def should(result)
+      @expected_result = [:should, result]
+    end
+
+    def should_not(result)
+      @expected_result = [:should_not, result]
+    end
+
+    def stdout
+      if @stdout_mock.nil?
+        output = ""
+        @stdout_mock = DeferredMock.new(output)
+        STDOUT.should_receive(:write).any_number_of_times do |str|
+          output << str
+        end
+      end
+      @stdout_mock
+    end
+
+    class DeferredMock
+      def initialize(obj = nil)
+        @obj = obj
+        @calls = []
+      end
+
+      def invoke(obj = nil)
+        obj ||= @obj
+        @calls.each do |sym, args|
+          obj.send sym, *args
+        end
+      end
+
+      def should(*args)
+        @calls << [:should, args]
+      end
+
+      def should_not(*args)
+        @calls << [:should_not, args]
+      end
+    end
+
+    def method_missing(sym, *args)
+      @parent.send sym, *args
+    end
+  end
+end