freshtrack 0.4.2 → 0.5.0

data/spec/freshbooks/time_entry_spec.rb

@@ -1,38 +1,38 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
 
 describe FreshBooks::TimeEntry do
-  before :each do
+  before do
     @time_entry = FreshBooks::TimeEntry.new
   end
   
   describe 'attributes' do
     it 'should have a time_entry_id' do
-      @time_entry.should respond_to(:time_entry_id)
+      @time_entry.should.respond_to(:time_entry_id)
     end
     
     it 'should have a project_id' do
-      @time_entry.should respond_to(:project_id)
+      @time_entry.should.respond_to(:project_id)
     end
     
     it 'should have a task_id' do
-      @time_entry.should respond_to(:task_id)
+      @time_entry.should.respond_to(:task_id)
     end
     
     it 'should have hours' do
-      @time_entry.should respond_to(:hours)
+      @time_entry.should.respond_to(:hours)
     end
     
     it 'should have a date' do
-      @time_entry.should respond_to(:date)
+      @time_entry.should.respond_to(:date)
     end
     
     it 'should have notes' do
-      @time_entry.should respond_to(:notes)
+      @time_entry.should.respond_to(:notes)
     end
   end
   
   describe 'type mappings' do
-    before :each do
+    before do
       @mapping = FreshBooks::TimeEntry::TYPE_MAPPINGS
     end
     
@@ -58,25 +58,25 @@ describe FreshBooks::TimeEntry do
   end
   
   describe 'creating an instance' do
-    before :each do
-      @response = stub('response', :success? => nil)
-      FreshBooks.stubs(:call_api).returns(@response)
+    before do
+      @response = mock('response', :success? => nil)
+      FreshBooks.stub!(:call_api).and_return(@response)
     end
     
     it 'should issue a request with the instance' do
-      FreshBooks.expects(:call_api).with('time_entry.create', 'time_entry' => @time_entry).returns(@response)
+      FreshBooks.should.receive(:call_api).with('time_entry.create', 'time_entry' => @time_entry).and_return(@response)
       @time_entry.create
     end
     
     describe 'with a successful request' do
-      before :each do
+      before do
         @time_entry_id = 5
-        @response.stubs(:elements).returns([stub('pre element'), stub('element', :text => @time_entry_id.to_s), stub('post element')])
-        @response.stubs(:success?).returns(true)
+        @response.stub!(:elements).and_return([mock('pre element'), mock('element', :text => @time_entry_id.to_s), mock('post element')])
+        @response.stub!(:success?).and_return(true)
       end
       
       it 'should set the ID from the response' do
-        @time_entry.expects(:time_entry_id=).with(@time_entry_id)
+        @time_entry.should.receive(:time_entry_id=).with(@time_entry_id)
         @time_entry.create
       end
       
@@ -86,265 +86,265 @@ describe FreshBooks::TimeEntry do
     end
     
     describe 'with an unsuccessful request' do
-      before :each do
-        @response.stubs(:success?).returns(false)
+      before do
+        @response.stub!(:success?).and_return(false)
       end
       
       it 'should not set the ID' do
-        @time_entry.expects(:time_entry_id=).never
+        @time_entry.should.receive(:time_entry_id=).never
         @time_entry.create
       end
       
       it 'should return nil' do
-        @time_entry.create.should be_nil
+        @time_entry.create.should.be.nil
       end
     end
   end
   
   describe 'updating an instance' do
-    before :each do
-      @response = stub('response', :success? => nil)
-      FreshBooks.stubs(:call_api).returns(@response)
+    before do
+      @response = mock('response', :success? => nil)
+      FreshBooks.stub!(:call_api).and_return(@response)
     end
     
     it 'should issue a request with the instance' do
-      FreshBooks.expects(:call_api).with('time_entry.update', 'time_entry' => @time_entry).returns(@response)
+      FreshBooks.should.receive(:call_api).with('time_entry.update', 'time_entry' => @time_entry).and_return(@response)
       @time_entry.update
     end
     
     describe 'with a successful request' do
-      before :each do
-        @response.stubs(:success?).returns(true)
+      before do
+        @response.stub!(:success?).and_return(true)
       end
       
       it 'should return true' do
-        @time_entry.update.should be(true)
+        @time_entry.update.should == true
       end
     end
     
     describe 'with an unsuccessful request' do
-      before :each do
-        @response.stubs(:success?).returns(false)
+      before do
+        @response.stub!(:success?).and_return(false)
       end
       
       it 'should return false' do
-        @time_entry.update.should be(false)
+        @time_entry.update.should == false
       end
     end
   end
   
   describe 'deleting an instance' do
-    before :each do
+    before do
       @time_entry_id = '5'
-      @response = stub('response', :success? => nil)
-      FreshBooks.stubs(:call_api).returns(@response)
+      @response = mock('response', :success? => nil)
+      FreshBooks.stub!(:call_api).and_return(@response)
     end
     
     describe 'from the class' do
       it 'should require an argument' do
-        lambda { FreshBooks::TimeEntry.delete }.should raise_error(ArgumentError)
+        lambda { FreshBooks::TimeEntry.delete }.should.raise(ArgumentError)
       end
       
       it 'should accept an argument' do
-        lambda { FreshBooks::TimeEntry.delete('arg') }.should_not raise_error(ArgumentError)
+        lambda { FreshBooks::TimeEntry.delete('arg') }.should.not.raise(ArgumentError)
       end
       
       it 'should issue a request with the supplied ID' do
-        FreshBooks.expects(:call_api).with('time_entry.delete', 'time_entry_id' => @time_entry_id).returns(@response)
+        FreshBooks.should.receive(:call_api).with('time_entry.delete', 'time_entry_id' => @time_entry_id).and_return(@response)
         FreshBooks::TimeEntry.delete(@time_entry_id)
       end
       
       describe 'with a successful request' do
-        before :each do
-          @response.stubs(:success?).returns(true)
+        before do
+          @response.stub!(:success?).and_return(true)
         end
         
         it 'should return true' do
-          FreshBooks::TimeEntry.delete(@time_entry_id).should be(true)
+          FreshBooks::TimeEntry.delete(@time_entry_id).should == true
         end
       end
       
       describe 'with an unsuccessful request' do
-        before :each do
-          @response.stubs(:success?).returns(false)
+        before do
+          @response.stub!(:success?).and_return(false)
         end
         
         it 'should return false' do
-          FreshBooks::TimeEntry.delete(@time_entry_id).should be(false)
+          FreshBooks::TimeEntry.delete(@time_entry_id).should == false
         end
       end
     end
     
     describe 'from the instance' do
-      before :each do
-        @time_entry.stubs(:time_entry_id).returns(@time_entry_id)
-        FreshBooks::TimeEntry.stubs(:delete)
+      before do
+        @time_entry.stub!(:time_entry_id).and_return(@time_entry_id)
+        FreshBooks::TimeEntry.stub!(:delete)
       end
       
       it 'should delegate to the class' do
-        FreshBooks::TimeEntry.expects(:delete)
+        FreshBooks::TimeEntry.should.receive(:delete)
         @time_entry.delete
       end
       
       it 'should pass its ID to the class method' do
-        FreshBooks::TimeEntry.expects(:delete).with(@time_entry_id)
+        FreshBooks::TimeEntry.should.receive(:delete).with(@time_entry_id)
         @time_entry.delete
       end
       
       it 'should return the result from the class method' do
-        val = stub('return val')
-        FreshBooks::TimeEntry.stubs(:delete).returns(val)
+        val = mock('return val')
+        FreshBooks::TimeEntry.stub!(:delete).and_return(val)
         @time_entry.delete.should == val
       end
     end
   end
   
   describe 'getting an instance' do
-    before :each do
+    before do
       @time_entry_id = 1
-      @element = stub('element')
-      @response = stub('response', :elements => [stub('pre element'), @element, stub('post element')], :success? => nil)
-      FreshBooks.stubs(:call_api).returns(@response)
+      @element = mock('element')
+      @response = mock('response', :elements => [mock('pre element'), @element, mock('post element')], :success? => nil)
+      FreshBooks.stub!(:call_api).and_return(@response)
     end
     
     it 'should require an argument' do
-      lambda { FreshBooks::TimeEntry.get }.should raise_error(ArgumentError)
+      lambda { FreshBooks::TimeEntry.get }.should.raise(ArgumentError)
     end
     
     it 'should accept an argument' do
-      lambda { FreshBooks::TimeEntry.get(@time_entry_id) }.should_not raise_error(ArgumentError)
+      lambda { FreshBooks::TimeEntry.get(@time_entry_id) }.should.not.raise(ArgumentError)
     end
     
     it 'should issue a request for the supplied ID' do
-      FreshBooks.expects(:call_api).with('time_entry.get', 'time_entry_id' => @time_entry_id).returns(@response)
+      FreshBooks.should.receive(:call_api).with('time_entry.get', 'time_entry_id' => @time_entry_id).and_return(@response)
       FreshBooks::TimeEntry.get(@time_entry_id)
     end
     
     describe 'with a successful request' do
-      before :each do
-        @response.stubs(:success?).returns(true)
+      before do
+        @response.stub!(:success?).and_return(true)
       end
       
       it 'should instantiate a new time_entry instance from the request' do
-        FreshBooks::TimeEntry.expects(:new_from_xml).with(@element)
+        FreshBooks::TimeEntry.should.receive(:new_from_xml).with(@element)
         FreshBooks::TimeEntry.get(@time_entry_id)
       end
       
       it 'should return the time_entry instance' do
-        val = stub('return val')
-        FreshBooks::TimeEntry.stubs(:new_from_xml).returns(val)
+        val = mock('return val')
+        FreshBooks::TimeEntry.stub!(:new_from_xml).and_return(val)
         FreshBooks::TimeEntry.get(@time_entry_id).should == val
       end
     end
     
     describe 'with an unsuccessful request' do
-      before :each do
-        @response.stubs(:success?).returns(false)
+      before do
+        @response.stub!(:success?).and_return(false)
       end
       
       it 'should return nil' do
-        FreshBooks::TimeEntry.get(@time_entry_id).should be_nil
+        FreshBooks::TimeEntry.get(@time_entry_id).should.be.nil
       end
     end
   end
   
   describe 'getting a list' do
-    before :each do
+    before do
       @time_entry_id = 1
-      @elements = Array.new(3) { stub('list element') }
-      @response = stub('response', :elements => [stub('pre element'), stub('element', :elements => @elements), stub('post element')], :success? => nil)
-      FreshBooks.stubs(:call_api).returns(@response)
+      @elements = Array.new(3) { mock('list element') }
+      @response = mock('response', :elements => [mock('pre element'), mock('element', :elements => @elements), mock('post element')], :success? => nil)
+      FreshBooks.stub!(:call_api).and_return(@response)
     end
     
     it 'should not require an argument' do
-      lambda { FreshBooks::TimeEntry.list }.should_not raise_error(ArgumentError)
+      lambda { FreshBooks::TimeEntry.list }.should.not.raise(ArgumentError)
     end
     
     it 'should accept an argument' do
-      lambda { FreshBooks::TimeEntry.list('arg') }.should_not raise_error(ArgumentError)
+      lambda { FreshBooks::TimeEntry.list('arg') }.should.not.raise(ArgumentError)
     end
     
     it 'should issue a request for the time_entry list' do
-      FreshBooks.expects(:call_api).with('time_entry.list', {}).returns(@response)
+      FreshBooks.should.receive(:call_api).with('time_entry.list', {}).and_return(@response)
       FreshBooks::TimeEntry.list
     end
     
     it 'should pass the argument to the request' do
-      arg = stub('arg')
-      FreshBooks.expects(:call_api).with('time_entry.list', arg).returns(@response)
+      arg = mock('arg')
+      FreshBooks.should.receive(:call_api).with('time_entry.list', arg).and_return(@response)
       FreshBooks::TimeEntry.list(arg)
     end
     
     describe 'with a successful request' do
-      before :each do
-        @response.stubs(:success?).returns(true)
+      before do
+        @response.stub!(:success?).and_return(true)
       end
       
       it 'should instantiate new time_entry instances from the request' do
         @elements.each do |element|
-          FreshBooks::TimeEntry.expects(:new_from_xml).with(element)
+          FreshBooks::TimeEntry.should.receive(:new_from_xml).with(element)
         end
         FreshBooks::TimeEntry.list
       end
       
       it 'should return the time_entry instances' do
-        vals = Array.new(@elements.length) { stub('return val') }
+        vals = Array.new(@elements.length) { mock('return val') }
         @elements.each_with_index do |element, i|
-          FreshBooks::TimeEntry.stubs(:new_from_xml).with(element).returns(vals[i])
+          FreshBooks::TimeEntry.stub!(:new_from_xml).with(element).and_return(vals[i])
         end
         FreshBooks::TimeEntry.list.should == vals
       end
     end
     
     describe 'with an unsuccessful request' do
-      before :each do
-        @response.stubs(:success?).returns(false)
+      before do
+        @response.stub!(:success?).and_return(false)
       end
       
       it 'should return nil' do
-        FreshBooks::TimeEntry.list.should be_nil
+        FreshBooks::TimeEntry.list.should.be.nil
       end
     end
   end
   
   it 'should have a task' do
-    @time_entry.should respond_to(:task)
+    @time_entry.should.respond_to(:task)
   end
   
   describe 'task' do
     it 'should find task based on task_id' do
-      task_id = stub('task ID')
-      @time_entry.stubs(:task_id).returns(task_id)
-      FreshBooks::Task.expects(:get).with(task_id)
+      task_id = mock('task ID')
+      @time_entry.stub!(:task_id).and_return(task_id)
+      FreshBooks::Task.should.receive(:get).with(task_id)
       @time_entry.task
     end
     
     it 'should return found task' do
-      task = stub('task')
-      task_id = stub('task ID')
-      @time_entry.stubs(:task_id).returns(task_id)
-      FreshBooks::Task.expects(:get).with(task_id).returns(task)
+      task = mock('task')
+      task_id = mock('task ID')
+      @time_entry.stub!(:task_id).and_return(task_id)
+      FreshBooks::Task.should.receive(:get).with(task_id).and_return(task)
       @time_entry.task.should == task
     end
   end
   
   it 'should have a project' do
-    @time_entry.should respond_to(:project)
+    @time_entry.should.respond_to(:project)
   end
   
   describe 'project' do
     it 'should find project based on project_id' do
-      project_id = stub('project ID')
-      @time_entry.stubs(:project_id).returns(project_id)
-      FreshBooks::Project.expects(:get).with(project_id)
+      project_id = mock('project ID')
+      @time_entry.stub!(:project_id).and_return(project_id)
+      FreshBooks::Project.should.receive(:get).with(project_id)
       @time_entry.project
     end
     
     it 'should return found project' do
-      project = stub('project')
-      project_id = stub('project ID')
-      @time_entry.stubs(:project_id).returns(project_id)
-      FreshBooks::Project.expects(:get).with(project_id).returns(project)
+      project = mock('project')
+      project_id = mock('project ID')
+      @time_entry.stub!(:project_id).and_return(project_id)
+      FreshBooks::Project.should.receive(:get).with(project_id).and_return(project)
       @time_entry.project.should == project
     end
   end

data/spec/freshtrack_command_spec.rb

@@ -1,46 +1,53 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper.rb')
 
-describe 'freshtrack command' do
-  def run_command(*args)
-    Object.const_set(:ARGV, args)
-    begin
-      eval File.read(File.join(File.dirname(__FILE__), *%w[.. bin freshtrack]))
-    rescue SystemExit
-    end
+def run_command(*args)
+  Object.const_set(:ARGV, args)
+  begin
+    eval File.read(File.join(File.dirname(__FILE__), *%w[.. bin freshtrack]))
+  rescue SystemExit
   end
-  
-  before :each do
+end
+
+def pending(*args, &block)
+end
+
+describe 'freshtrack command' do
+  before do
     [:ARGV, :OPTIONS, :MANDATORY_OPTIONS].each do |const|
       Object.send(:remove_const, const) if Object.const_defined?(const)
     end
     
-    Freshtrack.stubs(:init)
-    Freshtrack.stubs(:track)
+    Freshtrack.stub!(:init)
+    Freshtrack.stub!(:track)
     
     @project = 'myproj'
   end
   
   it 'should exist' do
-    lambda { run_command(@project) }.should_not raise_error(Errno::ENOENT)
+    lambda { run_command(@project) }.should.not.raise(Errno::ENOENT)
   end
   
   it 'should require a project' do
-    self.expects(:puts) { |text|  text.match(/usage.+project/i) }
+    self.should.receive(:puts) { |text|  text.match(/usage.+project/i) }
     run_command
   end
   
-  it 'should init Freshtrack' do
-    Freshtrack.expects(:init)
+  it 'should init Freshtrack with the given project' do
+    Freshtrack.should.receive(:init) do |arg|
+      arg.should == @project
+    end
     run_command(@project)
   end
   
   it 'should track time' do
-    Freshtrack.expects(:track)
+    Freshtrack.should.receive(:track)
     run_command(@project)
   end
   
   it 'should track time for the given project' do
-    Freshtrack.expects(:track).with(@project, anything)
+    Freshtrack.should.receive(:track) do |project, _|
+      project.should == @project
+    end
     run_command(@project)
   end
   
@@ -48,116 +55,141 @@ describe 'freshtrack command' do
     it "should pass on an 'after' time option given by --after" do
       time_option = '2008-08-26 09:47'
       time = Time.local(2008, 8, 26, 9, 47)
-      Freshtrack.expects(:track).with(@project, has_entry(:after => time))
+      Freshtrack.should.receive(:track) do |project, opts|
+        project.should == @project
+        opts[:after].should == time
+      end
       run_command(@project, '--after', time_option)
     end
 
     it "should pass on a 'before' time option given by --before" do
       time_option = '2008-08-23 15:39'
       time = Time.local(2008, 8, 23, 15, 39)
-      Freshtrack.expects(:track).with(@project, has_entry(:before => time))
+      Freshtrack.should.receive(:track) do |project, opts|
+        project.should == @project
+        opts[:before].should == time
+      end
       run_command(@project, '--before', time_option)
     end
 
     it 'should handle a time option given as a date' do
       time_option = '2008-08-23'
       time = Time.local(2008, 8, 23)
-      Freshtrack.expects(:track).with(@project, has_entry(:before => time))
+      Freshtrack.should.receive(:track) do |project, opts|
+        project.should == @project
+        opts[:before].should == time
+      end
       run_command(@project, '--before', time_option)
     end
   end
   
   it 'should pass no options if none specified' do
-    Freshtrack.expects(:track).with(@project, {})
+    Freshtrack.should.receive(:track).with(@project, {})
     run_command(@project)
   end
   
   describe 'when --aging specified' do
-    before :each do
+    before do
       @aging_info = [
         { :id => 5,  :number => '123', :age => 31, :client => 'blah', :status => 'viewed', :amount => 123.3, :owed => 5.67 },
         { :id => 53, :number => '234', :age => 43, :client => 'bang', :status => 'sent',   :amount => 60.0,  :owed => 60.0 },
         { :id => 20, :number => '938', :age => 3,  :client => 'boom', :status => 'viewed', :amount => 100.0, :owed => 100.0 }
       ]
-      Freshtrack.stubs(:invoice_aging).returns(@aging_info)
-      self.stubs(:printf)
+      Freshtrack.stub!(:invoice_aging).and_return(@aging_info)
+      self.stub!(:printf)
     end
     
-    def aging_run
-      run_command('--aging')
+    def aging_run(project=nil)
+      args = [project, '--aging'].compact
+      run_command(*args)
     end
     
     it 'should not require a project' do
-      self.expects(:puts) { |text|  text.match(/usage.+project/i) }.never
+      self.should.receive(:puts) { |text|  text.match(/usage.+project/i) }.never
       aging_run
     end
     
-    it 'should init Freshtrack' do
-      Freshtrack.expects(:init)
+    it 'should init Freshtrack with a project if given' do
+      Freshtrack.should.receive(:init) do |arg|
+        arg.should == @project
+      end
+      aging_run(@project)
+    end
+    
+    it 'should init Freshtrack for no project if none given' do
+      Freshtrack.should.receive(:init) do |arg|
+        arg.should.be.nil
+      end
       aging_run
     end
     
     it 'should get the invoice aging information' do
-      Freshtrack.expects(:invoice_aging).returns(@aging_info)
+      Freshtrack.should.receive(:invoice_aging).and_return(@aging_info)
       aging_run
     end
     
     it 'should print the number of each invoice' do
-      pending 'making this actually test what it purports to'
+      pending 'making this actually test what it purports to' do
       @aging_info.each do |info|
-        self.expects(:printf) { |*args|  args.include?(info[:number]) }
+        self.should.receive(:printf) { |*args|  args.should.include(info[:number]) }
       end
       aging_run
+      end
     end
     
     it 'should print the client of each invoice' do
-      pending 'making this actually test what it purports to'
+      pending 'making this actually test what it purports to' do
       @aging_info.each do |info|
-        self.expects(:printf) { |*args|  args.include?(info[:client]) }
+        self.should.receive(:printf) { |*args|  args.should.include(info[:client]) }
       end
       aging_run
+      end
     end
     
     it 'should print the age of each invoice' do
-      pending 'making this actually test what it purports to'
+      pending 'making this actually test what it purports to' do
       @aging_info.each do |info|
-        self.expects(:printf) { |*args|  args.include?(info[:age]) }
+        self.should.receive(:printf) { |*args|  args.should.include(info[:age]) }
       end
       aging_run
+      end
     end
     
     it 'should print the status of each invoice' do
-      pending 'making this actually test what it purports to'
+      pending 'making this actually test what it purports to' do
       @aging_info.each do |info|
-        self.expects(:printf) { |*args|  args.include?(info[:status]) }
+        self.should.receive(:printf) { |*args|  args.should.include(info[:status]) }
       end
       aging_run
+      end
     end
     
     it 'should print the amount of each invoice' do
-      pending 'making this actually test what it purports to'
+      pending 'making this actually test what it purports to' do
       @aging_info.each do |info|
-        self.expects(:printf) { |*args|  args.include?(info[:amount]) }
+        self.should.receive(:printf) { |*args|  args.should.include(info[:amount]) }
       end
       aging_run
+      end
     end
     
     it 'should print the owed of each invoice' do
-      pending 'making this actually test what it purports to'
+      pending 'making this actually test what it purports to' do
       @aging_info.each do |info|
-        self.expects(:printf) { |*args|  args.include?(info[:owed]) }
+        self.should.receive(:printf) { |*args|  args.should.include(info[:owed]) }
       end
       aging_run
+      end
     end
     
     it 'should not track time' do
-      Freshtrack.expects(:track).never
+      Freshtrack.should.receive(:track).never
       aging_run
     end
     
     it 'should not track time even when given a project' do
-      Freshtrack.expects(:track).never
-      run_command('--aging', @project)
+      Freshtrack.should.receive(:track).never
+      aging_run(@project)
     end
   end
 end