Overbryd-mighty-mite 0.1.0

data/spec/unit/mighty_mite/application_spec.rb

@@ -0,0 +1,509 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe MightyMite::Application, 'new' do
+  it "should load the configuration for MightyMite" do
+    MightyMite.should_receive(:load_configuration)
+    MightyMite::Application.new []
+  end
+  
+  it "should not load the configuration if the first argument is 'configure'" do
+    MightyMite.should_not_receive(:load_configuration)
+    MightyMite::Application.new ['configure']
+  end
+  
+  it "should set arguments" do
+    MightyMite.stub!(:load_configuration)
+    MightyMite::Application.new(['1', '2', '3']).instance_variable_get('@arguments').should == ['1', '2', '3']
+  end
+end
+
+describe MightyMite::Application, 'run' do
+  before(:each) do
+    MightyMite.stub!(:load_configuration)
+  end
+  
+  describe 'no argument' do
+    before(:each) do
+      @application = MightyMite::Application.new []
+      @application.stub!(:say)
+      @application.stub!(:flirt).and_return 'Your beautiful eyes touch my heart.'
+    end
+        
+    it "should tell the inspection of the current tracker if there is one" do    
+      tracker = stub('tracker', :inspect => 'I am the inspection of this tracker')
+      Mite::Tracker.stub!(:current).and_return tracker
+      @application.should_receive(:tell).with 'I am the inspection of this tracker'
+      @application.run
+    end
+    
+    it "should tell something romantic if there is no current tracker" do
+      Mite::Tracker.stub!(:current).and_return nil
+      @application.should_receive(:tell).with 'Your beautiful eyes touch my heart.'
+      @application.run
+    end
+  end
+  
+  describe 'the open argument' do
+    it "should try to open the account url or at least echo it" do
+      Mite.stub!(:account_url).and_return 'http://demo.mite.yo.lk'
+      application = MightyMite::Application.new ['open']
+      application.should_receive(:exec).with "open 'http://demo.mite.yo.lk' || echo 'http://demo.mite.yo.lk'"
+      application.run
+    end
+  end
+  
+  describe 'the help argument' do
+    it "should try to open the github repository of mighty mite or at least echo it" do
+      application = MightyMite::Application.new ['help']
+      application.should_receive(:exec).with "open 'http://github.com/Overbryd/mighty-mite' || echo 'http://github.com/Overbryd/mighty-mite'"
+      application.run
+    end
+  end
+  
+  describe 'the configure argument' do
+    before(:each) do
+      @application = MightyMite::Application.new ['configure', 'demo', '123']
+      @application.stub!(:tell)
+    end
+    
+    it "should generate a yaml formatted file in ~/.mite.yml with the account and the apikey" do
+      File.stub!(:expand_path).and_return '/tmp/.mite.yml'
+      File.should_receive(:open).with('/tmp/.mite.yml', 'w').and_yield :file_handle
+      YAML.should_receive(:dump).with({:account => 'demo', :apikey => '123'}, :file_handle)
+      @application.run
+    end
+    
+    it "should tell something nice if the bash completion setup fails" do
+      @application.stub!(:try_to_setup_bash_completion).and_return false
+      @application.should_receive(:tell).with "Could't set up bash completion. I'm terribly frustrated. Maybe 'mite help' helps out."
+      
+      File.stub!(:open) # prevents the yml file to be written
+      @application.run
+    end
+    
+    describe 'and setup bash completion' do
+      it "should append the bash completion call for mite to ~/.bash_completion if it exists and return true" do
+        File.stub!(:expand_path).and_return '/tmp/.bash_completion'
+        File.should_receive(:exist?).with('/tmp/.bash_completion').and_return true
+        file_handle = stub('file_handle')
+        File.should_receive(:open).with('/tmp/.bash_completion', 'a').and_yield file_handle
+        file_handle.should_receive(:puts).with("\n\ncomplete -C \"mite auto-complete\" mite")
+        
+        File.stub!(:read).and_return ''
+        @application.send(:try_to_setup_bash_completion).should == true
+      end
+      
+      it "should try '~/.bash_completion', '~/.bash_profile', '~/.bash_login', '~/.bashrc'" do
+        files = ['~/.bash_completion', '~/.bash_profile', '~/.bash_login', '~/.bashrc']
+        files_regexp = files.map {|f| Regexp.escape(f)}.join('|')
+        File.should_receive(:expand_path).with(
+          Regexp.new(files_regexp)
+        ).exactly(files.size).times
+        
+        File.stub!(:exist?).and_return false
+        @application.send :try_to_setup_bash_completion
+      end
+      
+      it "should not open a file handle if the file does not exist" do
+        File.stub!(:exist?).and_return false
+        File.should_not_receive(:open)
+        @application.send :try_to_setup_bash_completion
+      end
+      
+      it "should not append the bash completion call twice" do
+        File.stub!(:read).and_return "\n\ncomplete -C \"mite auto-complete\" mite"
+        File.should_not_receive(:open)
+        @application.send :try_to_setup_bash_completion
+      end
+      
+      it "should return false if the bash completion could not be set up" do
+        File.stub!(:exist?).and_return false
+        @application.send(:try_to_setup_bash_completion).should == false
+      end
+    end
+    
+    it "should raise an error if one of the last two arguments is missing" do
+      application = MightyMite::Application.new ['configure', 'faildemo']
+      lambda {
+        application.run
+      }.should raise_error(MightyMite::Exception)
+    end
+  end
+  
+  describe 'the auto-complete argument' do
+    before(:each) do
+      @application = MightyMite::Application.new ['auto-complete']
+      @application.stub!(:tell)
+      
+      @autocomplete = stub('autocomplete', :completion_table => {}, :completion_table= => nil, :suggestions => [])
+      MightyMite::Autocomplete.stub!(:new).and_return @autocomplete
+    end
+    
+    it "should create a new instance of MightyMite::Autocomplete setting the calling_script" do
+      MightyMite.stub!(:calling_script).and_return '/usr/local/bin/mite'
+      MightyMite::Autocomplete.should_receive(:new).with '/usr/local/bin/mite'
+      @application.run
+    end
+
+    it "should unmarshal the cached completion table from ~/.mite.cache if it exists" do
+      File.stub!(:exist?).and_return true
+      File.should_receive(:read).and_return :marshal_data
+      Marshal.should_receive(:load).and_return :cached_completion_table
+      @autocomplete.should_receive(:completion_table=).with :cached_completion_table
+      @autocomplete.stub!(:suggestions).and_return []
+      @application.run
+    end
+    
+    it "should tell each suggestion from MightyMite::Autocomplete" do
+      File.stub!(:exist?).and_return true
+      File.stub!(:read)
+      Marshal.stub!(:load)
+      @autocomplete.stub!(:suggestions).and_return ['Heinz', 'Peter']
+      @application.should_receive(:tell).with(/Heinz|Peter/).exactly(2).times
+      @application.run
+    end
+    
+    it "should wrap suggestions inside quotes if they are spaced" do
+      File.stub!(:exist?).and_return true
+      File.stub!(:read)
+      Marshal.stub!(:load)
+      @autocomplete.stub!(:suggestions).and_return ['I need quotes', 'MeNot']
+      @application.should_receive(:tell).with(/"I need quotes"|MeNot/).exactly(2).times
+      @application.run
+    end
+
+    shared_examples_for 'an uncached completion table' do
+      before(:each) do
+        File.stub!(:exist?).and_return false
+        
+        Mite::Project.stub!(:all).and_return [stub('project', :name => 'Demo Project')]
+        Mite::Service.stub!(:all).and_return [stub('service', :name => 'late night programming')]
+        Mite::TimeEntry.stub!(:all).and_return [stub('time entry', :note => 'shit 02:13 is really late')]
+        
+        File.stub!(:open)
+        Marshal.stub!(:dump)
+        
+        @completion_table = {
+          0 => ['Demo Project'],
+          1 => ['late night programming'],
+          2 => ['"0:05"', '"0:05+"', '"0:15"', '"0:15+"', '"0:30"', '"0:30+"', '"1:00"', '"1:00+"'],
+          3 => ['shit 02:13 is really late']
+        }
+      end
+
+      it "should create a new completion table" do
+        @application.send(:rebuild_completion_table).should == @completion_table
+      end
+
+      it "should save the new completion table to ~/.mite.cache" do
+        File.stub!(:expand_path).and_return '/tmp/.mite.cache'
+        File.should_receive(:open).with('/tmp/.mite.cache', 'w').and_yield :file_handle
+        Marshal.should_receive(:dump).with(@completion_table, :file_handle)
+        @application.run
+      end
+    end
+    
+    describe 'and the completion table is not cached' do
+      it_should_behave_like 'an uncached completion table'
+    end
+    
+  end
+
+  describe 'the rebuild-cache argument' do
+    before(:each) do
+      @application = MightyMite::Application.new ['rebuild-cache']
+      @application.stub!(:tell)
+    end
+    
+    it "should delete the file at ~/.mite.cache if it exists" do
+      File.stub!(:exist?).and_return true
+      File.stub!(:expand_path).and_return '/tmp/.mite.cache'
+      File.should_receive(:delete).with '/tmp/.mite.cache'
+      @application.run
+    end
+    
+    it "should not call delete on File if ~/.mite.cache does not exist" do
+      File.stub!(:exist?).and_return false
+      File.should_not_receive(:delete)
+      @application.run
+    end
+    
+    it "should tell something nice if the cache has been rebuild" do
+      @application.should_receive(:tell).with 'The rebuilding of the cache has been done, Master. Your wish is my command.'
+      @application.run
+    end
+    
+    it_should_behave_like 'an uncached completion table'
+  end
+  
+  describe 'the simple report argument' do
+    shared_examples_for 'a simple report' do
+      before(:each) do
+        @application = MightyMite::Application.new [@argument]
+        @application.stub!(:tell)
+
+        @time_entry = stub('time_entry', :inspect => 'I am a time entry.', :revenue => 1200)
+        @time_entry_with_nil_revenue = stub('time_entry_without_revenue', :inspect => 'I am a time entry.', :revenue => nil)
+        @time_entry_with_nil_revenue.stub!(:revenue).and_return nil
+        Mite::TimeEntry.stub!(:all).and_return [@time_entry, @time_entry, @time_entry_with_nil_revenue]
+      end
+
+      it "should tell an inspection of each time entry" do
+        Mite::TimeEntry.should_receive(:all).with(:params => hash_including(:at => @argument))
+        @time_entry.should_receive(:inspect).exactly(2).times
+        @time_entry_with_nil_revenue.should_receive(:inspect).at_least(:once)
+        @application.should_receive(:tell).with('I am a time entry.').exactly(3).times
+        @application.run
+      end
+      
+      it "should only output the time entries of the current user" do
+        Mite::TimeEntry.should_receive(:all).with(:params => hash_including(:user_id => 'current'))
+        @application.run
+      end
+      
+      it "should tell #{@argument}'s revenue, nicely formatted and colorized in lightgreen" do
+        @application.should_receive(:tell).with("\e[1;32;49m2400.00 $\e[0m").at_least(:once)
+        @application.run
+      end
+    end
+    
+    ['today', 'yesterday', 'this_week', 'last_week', 'this_month', 'last_month'].each do |argument|
+      describe argument do
+        before(:each) { @argument = argument }
+        it_should_behave_like 'a simple report'
+      end
+    end
+  end
+  
+  describe 'the stop argument' do
+    before(:each) do
+      @application = MightyMite::Application.new ['stop']
+      @application.stub!(:tell)
+      
+      time_entry = stub('time_entry', :inspect => 'hey there.')
+      @current_tracker = stub('tracker', :time_entry => time_entry)
+      @current_tracker.stub!(:stop).and_return @current_tracker
+      Mite::Tracker.stub!(:current).and_return @current_tracker
+    end
+    
+    it "should call stop on the current tracker" do
+      @current_tracker.should_receive :stop
+      @application.run
+    end
+    
+    it "should do nothing if there is no current tracker" do
+      Mite::Tracker.stub!(:current).and_return nil
+      @application.run
+    end
+    
+    it "should tell the inspection of the tracker's time entry if it has been stopped" do
+      @application.should_receive(:tell).with 'hey there.'
+      @application.run
+    end
+  end
+
+  describe 'the start argument' do
+    before(:each) do
+      @application = MightyMite::Application.new ['start']
+      @application.stub!(:tell)
+      
+      @time_entry = stub('time_entry', :start_tracker => nil, :inspect => 'I was started.')
+      Mite::TimeEntry.stub!(:first).and_return @time_entry
+    end
+  
+    it "should call start_tracker on the last time entry of today" do
+      # last time entry by time = first by list order
+      Mite::TimeEntry.should_receive(:first).with(:params => {:at => 'today'})
+      @time_entry.should_receive(:start_tracker)
+      @application.run
+    end
+    
+    it "should tell an inspection of the last time entry if it has been started" do
+      @application.should_receive(:tell).with 'I was started.'
+      @application.run
+    end
+    
+    it "should tell something nice if there is no time entry to start" do
+      Mite::TimeEntry.stub!(:first).and_return nil
+      @application.should_receive(:tell).with "Oh my dear! I tried hard, but I could'nt find any time entry for today."
+      @application.run
+    end
+  end
+
+end
+
+describe MightyMite::Application, 'dynamic time entry creation' do
+  before(:each) do
+    MightyMite.stub!(:load_configuration)
+    
+    @time_entry = stub('time_entry', :start_tracker => nil, :inspect => '')
+    Mite::TimeEntry.stub!(:create).and_return @time_entry
+    Mite::Project.stub! :first
+    Mite::Project.stub! :create
+    Mite::Service.stub! :first
+    Mite::Service.stub! :create
+  end
+  
+  def new_application(args=[])
+    application = MightyMite::Application.new args
+    application.stub!(:tell)
+    application
+  end
+  
+  it "should tell an inspection of the time entry" do
+    @time_entry.stub!(:inspect).and_return 'My name is entry, time entry.'
+    application = new_application(['Project', 'Service', 'Note'])
+    application.should_receive(:tell).with 'My name is entry, time entry.'
+    application.run
+  end
+  
+  describe 'the + argument' do
+    it "should create and start a new time entry" do
+      time_entry = stub('time_entry')
+      Mite::TimeEntry.should_receive(:create).and_return time_entry
+      time_entry.should_receive :start_tracker
+      new_application(['+']).run
+    end
+  end
+  
+  describe 'with a time given' do
+    it "should parse minutes as integer out of h:mm(+)?" do
+      new_application.send(:parse_minutes, '1:18').should == 78
+      new_application.send(:parse_minutes, '72:00').should == 4320
+      new_application.send(:parse_minutes, '0:01+').should == 1
+    end
+    
+    it "should parse minutes as integer out of h(:)?(+)?" do
+      new_application.send(:parse_minutes, '3').should == 180
+      new_application.send(:parse_minutes, '2:').should == 120
+      new_application.send(:parse_minutes, '1.5').should == 90
+      new_application.send(:parse_minutes, '2.5+').should == 150
+      new_application.send(:parse_minutes, '5:').should == 300
+      new_application.send(:parse_minutes, '1:+').should == 60
+      new_application.send(:parse_minutes, '0.5:').should == 30
+    end
+    
+    it "should parse minutes as nil out of +" do
+      new_application.send(:parse_minutes, '+').should == nil
+    end
+    
+    it "should add the parsed minutes to the attributes" do
+      Mite::TimeEntry.should_receive(:create).with hash_including(:minutes => 78)
+      new_application(['ARG1', 'ARG2', '1:18', 'ARG4']).run
+    end
+    
+    it "should start the tracker for the time entry if the attributes is suffixed with '+'" do
+      @time_entry.should_receive(:start_tracker)
+      new_application(['ARG1', 'ARG2', '1:18+', 'ARG4']).run
+    end
+  end
+  
+  describe 'with a project name given' do
+    before(:each) do
+      @project = stub('project', :id => 1)
+      Mite::Project.stub!(:first).and_return @project
+    end
+    
+    it "should try if the first argument is an existing project" do
+      Mite::Project.should_receive(:first).with(:params => {:name => 'Project No1'})
+      new_application(['Project No1']).run
+    end
+    
+    it "should add the project id to the attributes if a project was found" do
+      Mite::TimeEntry.should_receive(:create).with hash_including(:project_id => 1)
+      new_application(['Project No1']).run
+    end
+    
+    it "should create a new project unless a project was found" do
+      Mite::Project.stub!(:first).and_return nil
+      @project.stub!(:id).and_return 1234
+      Mite::Project.stub!(:create).and_return @project
+      Mite::TimeEntry.should_receive(:create).with hash_including(:project_id => 1234)
+      new_application(['I do not exist']).run
+    end
+    
+    it "should not create a new project if the first argument is a time argument" do
+      Mite::Project.stub!(:first).and_return nil
+      Mite::Project.should_not_receive(:create)
+      new_application(['1:11+']).run
+    end
+  end
+  
+  describe "with a service name given" do
+    before(:each) do
+      @service = stub('service', :id => 2)
+      Mite::Service.stub!(:first).and_return @service
+    end
+    
+    it "should try if the second argument is an existing service" do
+      Mite::Service.should_receive(:first).with(:params => {:name => 'Carwashing'})
+      new_application(['1', 'Carwashing']).run
+    end
+    
+    it "should add the service id to the attributes if a service was found" do
+      Mite::TimeEntry.should_receive(:create).with hash_including(:service_id => 2)
+      new_application(['1', 'Read a book']).run
+    end
+    
+    it "should not add the service id to the attributes unless a service was found" do
+      Mite::Service.stub!(:first).and_return nil
+      Mite::TimeEntry.should_not_receive(:create).with hash_including(:service_id => 2)
+      new_application(['1', 'Write a book']).run
+    end
+    
+    it "should create a new service unless a service was found" do
+      Mite::Service.stub!(:first).and_return nil
+      @service.stub!(:id).and_return 15
+      Mite::Service.stub!(:create).and_return @service
+      Mite::TimeEntry.should_receive(:create).with hash_including(:service_id => 15)
+      new_application(['1', 'I do not exist yet']).run
+    end
+    
+    it "should not create a new service if the second argument is a time argument" do
+      Mite::Service.stub!(:first).and_return nil
+      Mite::Service.should_not_receive(:create)
+      new_application(['1', '0:18']).run
+    end
+    
+    it "should do nothing on services if there is no second argument" do
+      application = new_application(['1'])
+      application.should_not_receive :find_or_create_service
+      application.run
+    end
+  end
+  
+  describe "with a note given" do
+    it "should parse the note out of the arguments" do
+      new_application.send(:parse_note, ['0:12', 'gnarr gnarr'], '0:12').should == 'gnarr gnarr'
+      new_application.send(:parse_note, ['1', '1:30+', 'bla bla'], '1:30+').should == 'bla bla'
+      new_application.send(:parse_note, ['Project', 'Service', 'NOTE!'], nil).should == 'NOTE!'
+    end
+    
+    it "should add the note to the attributes if the fourth argument is given" do
+      Mite::TimeEntry.should_receive(:create).with hash_including(:note => 'Reminder')
+      new_application(['ARG1', 'ARG2', '3+', 'Reminder']).run
+    end
+    
+    it "should add the note to the attributes if it is third argument and no time is given" do
+      Mite::TimeEntry.should_receive(:create).with hash_including(:note => 'bla bla')
+      new_application(['ARG1', 'ARG2', 'bla bla']).run
+    end
+    
+    it "should add the note to the attributes if a time argument is followed by a note" do
+      Mite::TimeEntry.should_receive(:create).with hash_including(:note => 'gnarr gnarr')
+      new_application(['1:02', 'gnarr gnarr']).run
+      Mite::TimeEntry.should_receive(:create).with hash_including(:note => 'glubb glubb')
+      new_application(['ARG1', '3:04', 'glubb glubb']).run
+    end
+  end
+end
+
+describe MightyMite::Application, 'flirt' do
+  before(:each) do
+    MightyMite.stub!(:load_configuration)
+  end
+  
+  it "should return a random flirt as string" do
+    MightyMite::Application.new.flirt.should be_kind_of(String)
+  end
+end

data/spec/unit/mighty_mite/autocomplete_spec.rb

@@ -0,0 +1,100 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe MightyMite::Autocomplete, 'new' do
+  it "should set calling_script" do
+    autocomplete = MightyMite::Autocomplete.new('/usr/local/bin/mite')
+    autocomplete.instance_variable_get('@calling_script').should == '/usr/local/bin/mite'
+  end
+end
+
+describe MightyMite::Autocomplete do
+  before(:each) do
+    @autocomplete = MightyMite::Autocomplete.new '/usr/local/bin/test_command'
+    @autocomplete.completion_table = {
+      0 => ['argument1', 'argument1a', 'argument1b', 'argument1c'],
+      1 => ['Homer', 'Simpsons', 'Holy', 'Holy Moly', 'Holy Grail'],
+      2 => ['I love spaces']
+    }
+    ENV['COMP_LINE'] = "./test_command argument1 Holy \"I love spaces\""
+    ENV['COMP_POINT'] = '27'
+  end
+  
+  describe 'argument_string' do
+    it "should return a string of all arguments without the calling script" do
+      @autocomplete.argument_string.should == 'argument1 Holy "I love spaces"'
+    end
+  end
+  
+  describe 'partial_argument_string' do
+    it "should return the arguments part of the bash line" do
+      @autocomplete.partial_argument_string.should == 'argument1 Holy'
+    end
+    
+    it "should be able to handle unmatched quotes" do
+      ENV['COMP_LINE'] = "./test_command \"arg "
+      ENV['COMP_POINT'] = '20'
+      @autocomplete.partial_argument_string.should == '"arg "'
+    end
+  end
+  
+  describe 'args' do
+    it "should return an array of arguments" do
+      @autocomplete.args.should == ['argument1', 'Holy', 'I love spaces']
+    end
+  end
+  
+  describe 'cursor_position' do
+    it "should return the cursor position as integer" do
+      @autocomplete.cursor_position.should == 27
+    end
+  end
+  
+  describe 'current_word' do
+    it "should return the current word at the cursor position" do
+      @autocomplete.current_word.should == 'Holy'
+    end
+    
+    it "should be able to handle unmatched quotes" do
+      ENV['COMP_LINE'] = "./test_command \"arg "
+      ENV['COMP_POINT'] = '20'
+      @autocomplete.current_word.should == 'arg '
+    end
+    
+    it "should return nil if the last word has been completed" do
+      ENV['COMP_LINE'] = "./test_command arg0 "
+      ENV['COMP_POINT'] = '20'
+      @autocomplete.current_word.should == nil
+    end
+  end
+  
+  describe 'current_argument_index' do
+    it "should return the index of the argument at the cursor position" do
+      @autocomplete.current_argument_index.should == 1
+    end
+    
+    it "should default to 0 if there are no args yet" do
+      ENV['COMP_LINE'] = "./test_command "
+      ENV['COMP_POINT'] = '15'
+      @autocomplete.current_argument_index.should == 0
+    end
+    
+    it "should return the size of the existing arguments plus 1 if the cursor position is at the end" do
+      ENV['COMP_LINE'] = "./test_command arg_index0 arg_index1 "
+      ENV['COMP_POINT'] = '37'
+      @autocomplete.current_argument_index.should == 2
+    end
+  end
+  
+  describe 'suggestions' do
+    it "should return the suggested values from the completion table at the current argument index" do
+      @autocomplete.suggestions.should == ['Holy', 'Holy Moly', 'Holy Grail']
+    end
+    
+    it "should return an empty array if the current argument index is out of range" do
+      @autocomplete.stub!(:current_argument_index).and_return 50
+      @autocomplete.suggestions.should == []
+    end
+    
+  end
+  
+end

data/spec/unit/mighty_mite_spec.rb

@@ -0,0 +1,51 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe MightyMite, 'load_configuration' do
+  def fake_configuration
+    File.stub!(:exist?).and_return true
+    File.stub!(:read).and_return :yaml_data
+    YAML.stub!(:load).and_return({:account => 'demo', :apikey => '123'})
+  end
+  
+  describe 'configuration file exists' do
+    before(:each) do
+      fake_configuration
+    end
+    
+    it "should set the account name for Mite" do
+      Mite.should_receive(:account=).with 'demo'
+      MightyMite.load_configuration
+    end
+
+    it "should set the apikey for Mite" do
+      Mite.should_receive(:key=).with '123'
+      MightyMite.load_configuration
+    end
+  end
+
+  describe 'configuration file does not exist' do
+    before(:each) do
+      File.stub!(:exist?).and_return false
+    end
+
+    it "should raise an error if the configuration file is missing" do
+      lambda {
+        MightyMite.load_configuration
+      }.should raise_error
+    end
+  end
+end
+
+describe MightyMite, 'run' do
+  it "should create a new instance of the Application class using the given arguments" do
+    MightyMite::Application.should_receive(:new).with(['arg1', 'arg2']).and_return stub('application', :run => nil)
+    MightyMite.run(['arg1', 'arg2'])
+  end
+  
+  it "should call run on the new instance" do
+    application = stub('application')
+    MightyMite::Application.stub!(:new).and_return application
+    application.should_receive :run
+    MightyMite.run([])
+  end
+end