terminitor 0.0.5 → 0.1.0

data/test/abstract_core_test.rb

@@ -0,0 +1,79 @@
+require File.expand_path('../teststrap', __FILE__)
+
+context "AbstractCore" do
+
+  context "setup!" do
+    setup do
+      any_instance_of(Terminitor::AbstractCore) do |core|
+        stub(core).load_termfile('/path/to')  { { :setup => ['ls','ok'] } }
+        mock(core).active_window  { true }.times 3
+      end
+    end
+    setup { @core = Terminitor::AbstractCore.new('/path/to') }
+    setup { mock(@core).execute_command("cd #{Dir.pwd}", :in => true)}
+    setup { mock(@core).execute_command('ls', :in => true) }
+    setup { mock(@core).execute_command('ok', :in => true) }
+    asserts("ok") { @core.setup! }
+  end
+
+  context "process!" do
+    context "without default" do
+      setup do
+        any_instance_of(Terminitor::AbstractCore) do |core|
+          stub(core).load_termfile('/path/to')  { {:windows => {'tab1' => ['ls', 'ok'], 'default' => [] } } }
+        end
+      end
+      setup { @core = Terminitor::AbstractCore.new('/path/to') }
+      setup { mock(@core).run_in_window(['ls', 'ok']) }
+      asserts("ok") { @core.process! }
+    end
+
+    context "with default" do
+      setup do
+        any_instance_of(Terminitor::AbstractCore) do |core|
+          stub(core).load_termfile('/path/to')  { {:windows => {'tab1' => ['ls', 'ok'], 'default' => ['echo'] } } }
+        end
+      end
+      setup { @core = Terminitor::AbstractCore.new('/path/to') }
+      setup { mock(@core).run_in_window(['echo'], :default => true) }
+      setup { mock(@core).run_in_window(['ls', 'ok']) }
+      asserts("ok") { @core.process! }
+    end
+
+  end
+
+  context "run_in_window" do
+    setup do
+      any_instance_of(Terminitor::AbstractCore) do |core|
+        stub(core).load_termfile('/path/to')  { true }
+      end
+      @core = Terminitor::AbstractCore.new('/path/to')
+    end
+
+    context "with default" do
+      setup { mock(@core).open_window { true  } }
+      setup { mock(@core).open_tab    { true  } }
+      setup { mock(@core).execute_command('ls', :in => true)  }
+      setup { mock(@core).execute_command('ok', :in => true)  }
+      asserts("ok") { @core.run_in_window('tab' => ['ls','ok']) }
+    end
+
+    context "without default" do
+      setup { mock(@core).open_tab { true  } }
+      setup { mock(@core).execute_command('ls', :in => true)  }
+      setup { mock(@core).execute_command('ok', :in => true)  }
+      asserts("ok") { @core.run_in_window({'tab' => ['ls','ok']}, :default => true) }
+    end
+
+
+    context "with working_dir" do
+      setup { stub(Dir).pwd { '/tmp/path' } }
+      setup { mock(@core).execute_command("cd \"/tmp/path\"", :in => '/tmp/path')  }
+      setup { mock(@core).execute_command('ls', :in => '/tmp/path')  }
+      asserts("ok") { @core.run_in_window({'tab' => ['ls']}) }
+    end
+  end
+
+
+
+end

data/test/cli_test.rb

@@ -0,0 +1,121 @@
+require File.expand_path('../teststrap', __FILE__)
+
+context "Terminitor" do
+  setup     { @yaml = File.read(File.expand_path('../fixtures/foo.yml', __FILE__)) }
+  setup     { @template = File.read(File.expand_path('../../lib/templates/example.yml.tt', __FILE__)) }
+  setup     { FakeFS.activate! }
+  setup     { FileUtils.mkdir_p(File.join(ENV["HOME"],'.terminitor')) }
+  teardown  { FakeFS.deactivate! }
+
+  context "help" do
+    setup { capture(:stdout) { Terminitor::Cli.start(['-h']) } }
+    asserts_topic.matches   %r{start PROJECT_NAME}
+    asserts_topic.matches   %r{init}
+    asserts_topic.matches   %r{edit PROJECT_NAME}
+  end
+
+  context "list" do
+    setup { @path = "#{ENV['HOME']}/.terminitor/" }
+    setup { File.open(File.join(@path,'foo.yml'),"w") { |f| f.puts @template } }
+    setup { File.open(File.join(@path,'bar.yml'),"w") { |f| f.puts @template } }
+    setup { capture(:stdout) { Terminitor::Cli.start(['list']) } }
+    asserts_topic.matches %r{foo - COMMENT OF SCRIPT HERE}
+    asserts_topic.matches %r{bar - COMMENT OF SCRIPT HERE}
+  end
+
+  context "init" do
+    setup { capture(:stdout) { Terminitor::Cli.start(['init']) } }
+    asserts("creates .terminitor") { File.exists?("#{ENV['HOME']}/.terminitor") }
+  end
+
+  context "edit" do
+    setup     { FakeFS.deactivate! }
+    setup     { `rm -rf #{ENV['HOME']}/.terminitor/test_foo_bar2.yml`}
+    setup     { `rm -rf #{ENV['HOME']}/.terminitor/test_foo_bar2.term`}
+    teardown  { `rm -rf /tmp/sample_project` }
+    teardown  { `rm -rf #{ENV['HOME']}/.terminitor/test_foo_bar2.yml`}
+    teardown  { `rm -rf #{ENV['HOME']}/.terminitor/test_foo_bar2.term`}
+    context "for project" do
+      context "for yaml" do
+        setup { mock.instance_of(Terminitor::Cli).open_in_editor("#{ENV['HOME']}/.terminitor/test_foo_bar2.yml",nil) { true }.once }
+        setup { capture(:stdout) { Terminitor::Cli.start(['edit','test_foo_bar2', '-s=yml']) } }
+        asserts_topic.matches %r{create}
+        asserts_topic.matches %r{test_foo_bar2.yml}
+        asserts("has term template") { File.read(File.join(ENV['HOME'],'.terminitor','test_foo_bar2.yml')) }.matches %r{- tab1}
+      end
+
+      context "for term" do
+        setup { mock.instance_of(Terminitor::Cli).open_in_editor("#{ENV['HOME']}/.terminitor/test_foo_bar2.term",nil) { true }.once }
+        setup { capture(:stdout) { Terminitor::Cli.start(['edit','test_foo_bar2', '-s=term']) } }
+        asserts_topic.matches %r{create}
+        asserts_topic.matches %r{test_foo_bar2.term}
+        asserts("has term template") { File.read(File.join(ENV['HOME'],'.terminitor','test_foo_bar2.term')) }.matches %r{setup}
+      end
+
+    end
+
+    context "for Termfile" do
+      setup { mock.instance_of(Terminitor::Cli).open_in_editor("/tmp/sample_project/Termfile",nil) { true }.once }
+      setup { capture(:stdout) { Terminitor::Cli.start(['edit','-s=yml','-r=/tmp/sample_project']) } }
+      asserts_topic.matches %r{create}
+      asserts_topic.matches %r{Termfile}
+      asserts("has term template") { File.read('/tmp/sample_project/Termfile') }.matches %r{setup}
+    end
+
+    context "for editor flag" do
+      setup { FileUtils.mkdir_p('/tmp/sample_project')  }
+      setup { mock.instance_of(Terminitor::Cli).open_in_editor('/tmp/sample_project/Termfile','nano') { true }.once }
+      asserts("runs nano") { capture(:stdout) { Terminitor::Cli.start(['edit','-r=/tmp/sample_project','-c=nano']) } }
+    end
+
+  end
+
+  context "create" do
+    setup { mock.instance_of(Terminitor::Cli).invoke(:edit, [], 'root' => '/tmp/sample_project') { true }.once }
+    asserts('calls open') { capture(:stdout) { Terminitor::Cli.start(['create','-r=/tmp/sample_project']) }   }
+  end
+
+
+  context "open" do
+    setup { mock.instance_of(Terminitor::Cli).invoke(:edit, [""], {'syntax' => 'term', 'root' => '/tmp/sample_project'}) { true }.once }
+    setup { capture(:stdout) { Terminitor::Cli.start(['open','-r=/tmp/sample_project']) } }
+    asserts_topic.matches %r{'open' is now deprecated. Please use 'edit' instead}
+  end
+
+  context "delete" do
+    context "directory Termfile" do
+      setup { FileUtils.mkdir_p('/tmp/sample_project') }
+      setup { FileUtils.touch("/tmp/sample_project/Termfile") }
+      setup { capture(:stdout) { Terminitor::Cli.start(['delete',"-r=/tmp/sample_project"]) } }
+      asserts("Termfile") { File.exists?("/tmp/sample_project/Termfile") }.not!
+    end
+
+    context "for yaml" do
+      setup { FileUtils.touch("#{ENV['HOME']}/.terminitor/delete_this.yml") }
+      setup { capture(:stdout) { Terminitor::Cli.start(['delete','delete_this', '-s=yml']) } }
+      asserts(" script") { File.exists?("#{ENV['HOME']}/.terminitor/delete_this.yml") }.not!
+    end
+
+    context "for term" do
+      setup { FileUtils.touch("#{ENV['HOME']}/.terminitor/delete_this.term") }
+      setup { capture(:stdout) { Terminitor::Cli.start(['delete','delete_this']) } }
+      asserts("script") { File.exists?("#{ENV['HOME']}/.terminitor/delete_this.term") }.not!
+    end
+  end
+
+  context "setup" do
+    setup { mock.instance_of(Terminitor::Cli).execute_core(:setup!,'project') {true } }
+    asserts("calls execute_core") { Terminitor::Cli.start(['setup','project']) }
+  end
+
+
+  context "start" do
+    setup { mock.instance_of(Terminitor::Cli).execute_core(:process!,'project') {true } }
+    asserts("calls execute_core") { Terminitor::Cli.start(['start','project']) }
+  end
+  
+  context "fetch" do
+    setup { mock.instance_of(Terminitor::Cli).fetch_repo('achiu','terminitor', 'root' => '.', 'setup' => true) { true } }
+    asserts("run setup in project dir") { capture(:stdout) { Terminitor::Cli.start(['fetch','achiu','terminitor'])} }
+  end
+end

data/test/cores/konsole_core_test.rb

@@ -0,0 +1,56 @@
+require File.expand_path('../../teststrap',__FILE__)
+if platform?('linux')
+  require 'dbus'
+  context "KonsoleCore" do
+    # Stub out the initialization
+    setup do
+      bus = Object.new
+      @konsole_service = Object.new
+      @konsole = Object.new
+      mock(DBus::SessionBus).instance { bus }
+      mock(bus).service("org.kde.konsole") { @konsole_service }
+      any_instance_of(Terminitor::KonsoleCore) do |core|
+        stub(core).get_konsole { @konsole }
+        stub(core).load_termfile('/path/to')  { true }
+      end
+    end
+    setup { @konsole_core = Terminitor::KonsoleCore.new('/path/to') }
+
+    context "open_tab" do
+      setup do
+        mock(@konsole).newSession { 1 }
+        session_object = { "org.kde.konsole.Session" => Object.new }
+        mock(@konsole_service).object("/Sessions/1") { session_object }
+        mock(session_object).introspect { true }
+      end
+      asserts("returns last tab") { @konsole_core.open_tab }
+    end
+
+    context "open_window" do
+      setup do
+        mock(@konsole).currentSession { 2 }
+        session_object = { "org.kde.konsole.Session" => Object.new }
+        mock(@konsole_service).object("/Sessions/2") { session_object }
+        mock(session_object).introspect { true }
+      end
+      asserts("returns last tab") { @konsole_core.open_window }
+    end
+
+    context "execute_command" do
+      @tab = Object.new
+      context "carriage return missing" do
+        setup do
+          mock(@tab).sendText("hasta\n") { true }
+        end
+        asserts("executes command") { @konsole_core.execute_command('hasta', :in => @tab) }
+      end
+
+      context "carriage return present" do
+        setup do
+          mock(@tab).sendText("hasta\n") { true }
+        end
+        asserts("executes command") { @konsole_core.execute_command("hasta\n", :in => @tab) }
+      end
+    end
+  end
+end

data/test/cores/mac_core_test.rb

@@ -0,0 +1,84 @@
+require File.expand_path('../../teststrap',__FILE__)
+
+if platform?("darwin") # Only run test if it's darwin
+  context "MacCore" do
+    # Stub out the initialization
+    setup do
+      terminal = Object.new
+      stub(terminal).windows { true }
+      any_instance_of(Terminitor::MacCore) do |core|
+        stub(core).app('Terminal')            { terminal  }
+        stub(core).load_termfile('/path/to')  { true      }
+      end
+    end
+    setup { @mac_core = Terminitor::MacCore.new('/path/to') }
+
+    context "terminal_process" do
+      setup do
+        process = Object.new
+        mock(process).application_processes   { { "Terminal.app" => true }  }
+        mock(@mac_core).app('System Events')  { process                     }
+      end
+      asserts("calls System Events") { @mac_core.terminal_process }
+    end
+
+    context "open_tab" do
+      setup do
+        process = Object.new
+        mock(process).keystroke('t', :using => :command_down)
+        mock(@mac_core).return_last_tab   { true    }
+        mock(@mac_core).terminal_process  { process }
+      end
+      asserts("returns last tab") { @mac_core.open_tab }
+    end
+
+    context "open_window" do
+      setup do
+        process = Object.new
+        mock(process).keystroke('n', :using => :command_down)
+        mock(@mac_core).return_last_tab   { true    }
+        mock(@mac_core).terminal_process  { process }
+      end
+      asserts("returns last tab") { @mac_core.open_window }
+    end
+
+    context "return_last_tab" do
+      setup do
+        window = Object.new
+        tab    = Object.new
+        mock(tab).get     { true  }
+        mock(window).tabs { [tab] }
+        mock(@mac_core).active_window { window }
+      end
+      asserts("returns tab") { @mac_core.return_last_tab }
+    end
+
+    context "execute_command" do
+      setup do
+        window = Object.new
+        mock(window).do_script("hasta", :in => :la_vista) { true }
+        mock(@mac_core).active_window { window }
+      end
+      asserts("baby") { @mac_core.execute_command('hasta', :in => :la_vista) }
+    end
+
+    context "active_window" do
+      setup do
+        terminal, windows, window, app_object = 4.times.collect { Object.new } # holy mother of somebody.
+        stub(app_object).get      { {:frontmost => true}  }
+        stub(window).properties_  { app_object            }
+        stub(windows).get         { [window]              }  
+        stub(terminal).windows    { windows               }
+        any_instance_of(Terminitor::MacCore) do |core|
+          stub(core).app('Terminal')            { terminal  }
+          stub(core).load_termfile('/path/to')  { true      }
+        end
+      end
+      asserts("gives me window") { Terminitor::MacCore.new('/path/to').active_window }
+    end
+  end
+else
+  context "MacCore" do
+    puts "Nothing to do, you are not on OSX"
+  end
+end

data/test/dsl_test.rb

@@ -0,0 +1,15 @@
+require File.expand_path('../teststrap', __FILE__)
+
+context "Dsl" do
+  setup { @path = File.expand_path('../fixtures/bar.term', __FILE__)}
+  setup { @yaml = Terminitor::Dsl.new(@path) }
+  asserts_topic.assigns :setup
+  asserts_topic.assigns :windows
+  asserts_topic.assigns :_context
+
+  context "to_hash" do
+    setup { @yaml.to_hash }
+    asserts_topic.equivalent_to(:setup=>["echo \"setup\""], :windows=>{"window1"=>{"named tab"=>["echo 'named tab'", "ls"], "tab0"=>["echo 'first tab'", "echo 'of window'"]}, "default"=>{"tab0"=>["echo 'default'", "echo 'default tab'"]}})
+  end
+
+end

data/test/fixtures/bar.term

@@ -0,0 +1,16 @@
+# you can make as many tabs as you wish...
+# tab names are actually arbitrary at this point too.
+
+setup 'echo "setup"'
+
+tab "echo 'default'", "echo 'default tab'"
+
+window do
+  tab "echo 'first tab'", "echo 'of window'"
+  
+  tab "named tab" do
+    run "echo 'named tab'"
+    run "ls"
+  end
+end
+

data/test/fixtures/foo.term

@@ -0,0 +1,21 @@
+setup do
+  run "echo 'setup'"
+end
+
+window "first window" do
+  run "echo 'first window"
+end
+
+window "second window" do
+  tab 'first tab' do
+    run "echo 'second window'"
+  end
+  
+  tab(:second_tab) { run "echo 'second_tab'" }
+
+end
+
+# runs on last instantiated window
+tab do
+  run "echo 'tab'"
+end

data/test/fixtures/foo.yml

@@ -1,3 +1,4 @@
+# Foo.yml
 # you can make as many tabs as you wish...
 # tab names are actually arbitrary at this point too.
 ---

data/test/runner_test.rb

@@ -0,0 +1,234 @@
+require File.expand_path('../teststrap', __FILE__)
+
+class TestRunner
+  include Terminitor::Runner
+  def say(caption); puts caption; end
+end
+
+class TestObject
+  attr_accessor :test_item
+  def initialize(test_item); @test_item = test_item; end
+  def windows; [@test_item]; end
+end
+
+class TestItem
+  def do_script(prompt,hash); true; end
+  def get; true; end
+  def keystroke(prompt,hash); true; end
+end
+
+context "Runner" do
+  setup     { @yaml = File.read(File.expand_path('../fixtures/foo.yml', __FILE__)) }
+  setup     { @template = File.read(File.expand_path('../../lib/templates/example.yml.tt', __FILE__)) }
+  setup     { @test_runner = TestRunner.new }
+  setup     { FakeFS.activate! }
+  teardown  { FakeFS.deactivate! }
+
+
+  context "find_core" do
+    context "for Darwin" do
+      setup { @test_runner.find_core('darwin') }
+      asserts_topic.equals Terminitor::MacCore
+    end
+
+    if platform?('linux') # TODO Gotta be a better way.
+      context "for KDE" do
+        setup { @test_runner.find_core('linux') }
+        asserts_topic.equals Terminitor::KonsoleCore
+      end
+    end
+  end
+
+  context "open_in_editor" do
+    context "using $EDITOR" do
+      setup { ENV['EDITOR'] = 'mate' }
+      setup { mock(@test_runner).system("mate /tmp/sample_project/foo.yml").returns {true}.once       }
+      asserts("calls") { capture(:stdout) { @test_runner.open_in_editor("/tmp/sample_project/foo.yml") } }
+    end
+
+    context "using $TERM_EDITOR" do
+      setup { ENV['TERM_EDITOR'] = 'vim'  }
+      setup { ENV['EDITOR'] = 'jack'      }
+      setup { mock(@test_runner).system("vim /tmp/sample_project/foo.yml").returns {true}.once       }
+      asserts("calls") { capture(:stdout) { @test_runner.open_in_editor("/tmp/sample_project/foo.yml")}  }
+    end
+
+    context "without any editor" do
+      setup { ENV['TERM_EDITOR'] = nil  }
+      setup { ENV['EDITOR'] = nil       }
+      setup { mock(@test_runner).system("open /tmp/sample_project/foo.yml").returns {true}.once       }
+      setup { capture(:stdout) { @test_runner.open_in_editor("/tmp/sample_project/foo.yml")}  }
+      asserts_topic.matches %r{please set}
+    end
+
+    context "accepts an editor" do
+      setup { ENV['TERM_EDITOR'] = 'vim'  }
+      setup { ENV['EDITOR'] = 'jack'      }
+      setup { mock(@test_runner).system("nano /tmp/sample_project/foo.yml").returns {true}.once          }
+      asserts("calls") { capture(:stdout) { @test_runner.open_in_editor("/tmp/sample_project/foo.yml","nano")} }
+    end
+
+  end
+
+  context "resolve_path" do
+    setup { FileUtils.mkdir_p(File.join(ENV['HOME'],'.terminitor')) }
+
+    context "with yaml" do
+      setup { FileUtils.touch(File.join(ENV['HOME'],'.terminitor','test.yml'))  }
+      setup { @test_runner.resolve_path('test') }
+      asserts_topic.equals File.join(ENV['HOME'],'.terminitor','test.yml')
+    end
+
+    context "with term" do
+      setup { FileUtils.touch(File.join(ENV['HOME'],'.terminitor','test.term')) }
+      setup { FileUtils.rm(File.join(ENV['HOME'],'.terminitor','test.yml'))     }
+      setup { @test_runner.resolve_path('test') }
+      asserts_topic.equals File.join(ENV['HOME'],'.terminitor','test.term')
+    end
+
+    context "with Termfile" do
+      setup { FileUtils.rm(File.join(ENV['HOME'],'.terminitor','test.yml'))   }
+      setup { FileUtils.rm(File.join(ENV['HOME'],'.terminitor','test.term'))  }
+      setup { FileUtils.touch("Termfile") }
+      setup { mock(@test_runner).options { {:root => '.'} }  }
+      setup { @test_runner.resolve_path("") }
+      asserts_topic.equals "./Termfile"
+    end
+
+    context "with nothing" do
+      setup { FileUtils.rm(File.join(ENV['HOME'],'.terminitor','test.yml'))   }
+      setup { FileUtils.rm(File.join(ENV['HOME'],'.terminitor','test.term'))  }
+      setup { FileUtils.rm("Termfile") }
+
+      context "with a project" do
+        setup { @test_runner.resolve_path('hey') }
+        asserts_topic.nil
+      end
+
+      context "without a project" do
+        setup { mock(@test_runner).options { {:root => '.'} }  }
+        setup { @test_runner.resolve_path("") }
+        asserts_topic.nil
+      end
+    end
+
+  end
+
+  context "config_path" do
+    context "for yaml" do
+      setup { @test_runner.config_path('test',:yml) }
+      asserts_topic.equals File.join(ENV['HOME'],'.terminitor','test.yml')
+    end
+
+    context "for term" do
+      setup { @test_runner.config_path('test', :term) }
+      asserts_topic.equals File.join(ENV['HOME'],'.terminitor', 'test.term')
+    end
+
+    context "for Termfile" do
+      setup { mock(@test_runner).options { {:root => '/tmp'} } }
+      setup { @test_runner.config_path("") }
+      asserts_topic.equals "/tmp/Termfile"
+    end
+
+  end
+
+  context "grab_comment_for_file" do
+    setup { File.open('foo.yml','w') { |f| f.puts @yaml } }
+    setup { @test_runner.grab_comment_for_file('foo.yml') }
+    asserts_topic.matches %r{- Foo.yml}
+  end
+
+  context "return_error_message" do
+    context "with project" do
+      setup { mock(@test_runner).say(%r{'hi' doesn't exist}) { true } }
+      asserts("that it says") { @test_runner.return_error_message('hi') }
+    end
+    context "without project" do
+      setup { mock(@test_runner).say(%r{Termfile}) { true } }
+      asserts("that is says") { @test_runner.return_error_message('') }
+    end
+  end
+
+  context "execute_core" do
+
+    context "with no found path" do
+      setup { mock(@test_runner).resolve_path('project') { nil } }
+      setup { mock(@test_runner).return_error_message('project') { true } }
+      asserts("shows error message") { @test_runner.execute_core(:process!,'project') }
+    end
+
+    context "with no found core" do
+      setup { mock(@test_runner).resolve_path('project') { true }  }
+      setup { mock(@test_runner).find_core(anything)     { nil  }  }
+      setup { mock(@test_runner).say(/No suitable/)      { true }  }
+      asserts("shows message") { @test_runner.execute_core(:process!,'project') }
+    end
+
+    context "with found core" do
+      context "#process!" do
+        setup { mock(@test_runner).resolve_path('project') { '/path/to' } }
+        setup do
+          any_instance_of(Terminitor::AbstractCore) do |core|
+            stub(core).load_termfile('/path/to')  { true }
+            stub(core).process! { true }
+          end
+          mock(@test_runner).find_core(anything) { Terminitor::AbstractCore }
+        end
+        asserts("calls process!") { @test_runner.execute_core(:process!, 'project') }
+      end
+
+      context "#setup!" do
+        setup { mock(@test_runner).resolve_path('project') { '/path/to' } }
+        setup do
+          any_instance_of(Terminitor::AbstractCore) do |core|
+            stub(core).load_termfile('/path/to')  { true }
+            stub(core).setup! { true }
+          end
+          mock(@test_runner).find_core(anything) { Terminitor::AbstractCore }
+        end
+        asserts("calls process!") { @test_runner.execute_core(:setup!, 'project') }
+      end
+    end
+  end
+
+  context "clone_repo" do
+    context "with github" do
+      setup { stub(@test_runner).__double_definition_create__.call(:`,'which github') { "github" } }
+      context "with read/write priv" do
+        setup { mock(@test_runner).system("github clone achiu terminitor --ssh") { true } }
+        asserts("invokes ssh") { @test_runner.clone_repo('achiu','terminitor') }
+      end
+
+      context "with read only" do
+        setup { mock(@test_runner).system("github clone achiu terminitor --ssh") { false } }
+        setup { mock(@test_runner).system("github clone achiu terminitor") { true } }
+        asserts("invokes git://") { @test_runner.clone_repo('achiu', 'terminitor') }
+      end
+    end
+  end
+
+  context "fetch_repo" do
+    context "with setup" do
+      setup { mock(@test_runner).clone_repo('achiu','terminitor') { true } }
+      setup { mock(FileUtils).cd(File.join(Dir.pwd,'terminitor')) { true } }
+      setup { mock(@test_runner).invoke(:setup, []) { true } }
+      asserts("invokes setup") { @test_runner.fetch_repo('achiu','terminitor', :setup => true) }
+    end
+
+    context "without setup" do
+      setup { mock(@test_runner).clone_repo('achiu','terminitor') { true } }
+      setup { mock(FileUtils).cd(File.join(Dir.pwd,'terminitor')) { true } }
+      asserts("invokes setup") { @test_runner.fetch_repo('achiu','terminitor') }.nil
+    end
+
+    context "failed on repo" do
+      setup { mock(@test_runner).clone_repo('achiu','terminitor') { false } }
+      setup { mock(@test_runner).say("could not fetch repo!") { true } }
+      asserts("invokes say") { @test_runner.fetch_repo('achiu', 'terminitor') }
+    end
+
+  end
+
+
+end