bookie_accounting 2.0.0 → 2.0.1

data/spec/database/system_type_spec.rb

@@ -7,16 +7,16 @@ describe Bookie::Database::SystemType do
     systype = SystemType.new
     #TODO: create custom RSpec matcher for this?
     systype.memory_stat_type = :unknown
-    systype.memory_stat_type.should eql :unknown
-    systype.read_attribute(:memory_stat_type).should eql SystemType::MEMORY_STAT_TYPE[:unknown]
+    expect(systype.memory_stat_type).to eql :unknown
+    expect(systype.read_attribute(:memory_stat_type)).to eql SystemType::MEMORY_STAT_TYPE[:unknown]
     systype.memory_stat_type = :avg
-    systype.memory_stat_type.should eql :avg
-    systype.read_attribute(:memory_stat_type).should eql SystemType::MEMORY_STAT_TYPE[:avg]
+    expect(systype.memory_stat_type).to eql :avg
+    expect(systype.read_attribute(:memory_stat_type)).to eql SystemType::MEMORY_STAT_TYPE[:avg]
     systype.memory_stat_type = :max
-    systype.memory_stat_type.should eql :max
-    systype.read_attribute(:memory_stat_type).should eql SystemType::MEMORY_STAT_TYPE[:max]
+    expect(systype.memory_stat_type).to eql :max
+    expect(systype.read_attribute(:memory_stat_type)).to eql SystemType::MEMORY_STAT_TYPE[:max]
   end
-  
+
   it "rejects unrecognized memory stat type codes" do
     systype = SystemType.new
     expect { systype.memory_stat_type = :invalid_type }.to raise_error("Unrecognized memory stat type 'invalid_type'")
@@ -24,12 +24,12 @@ describe Bookie::Database::SystemType do
     systype.send(:write_attribute, :memory_stat_type, 10000)
     expect { systype.memory_stat_type }.to raise_error("Unrecognized memory stat type code 10000")
   end
-  
+
   it "creates the system type when needed" do
     SystemType.expects(:'create!')
     SystemType.find_or_create!('test', :avg)
   end
-  
+
   it "raises an error if the existing type has the wrong memory stat type" do
     systype = SystemType.create!(:name => 'test', :memory_stat_type => :max)
     begin
@@ -43,7 +43,7 @@ describe Bookie::Database::SystemType do
       systype.delete
     end
   end
-  
+
   it "uses the existing type" do
     systype = SystemType.create!(:name => 'test', :memory_stat_type => :avg)
     begin
@@ -53,16 +53,15 @@ describe Bookie::Database::SystemType do
       systype.delete
     end
   end
-  
+
   it "validates fields" do
     systype = SystemType.new(:name => 'test')
     expect { systype.valid? }.to raise_error('Memory stat type must not be nil')
     systype.memory_stat_type = :unknown
-    systype.valid?.should eql true
+    expect(systype.valid?).to eql true
     systype.name = nil
-    systype.valid?.should eql false
+    expect(systype.valid?).to eql false
     systype.name = ''
-    systype.valid?.should eql false
+    expect(systype.valid?).to eql false
   end
 end
-

data/spec/database/user_spec.rb

@@ -3,67 +3,66 @@ require 'spec_helper'
 describe Bookie::Database::User do
   it "correctly filters by name" do
     users = Bookie::Database::User.by_name('test').to_a
-    users.length.should eql 2
+    expect(users.length).to eql 2
     users.each do |user|
-      user.name.should eql 'test'
+      expect(user.name).to eql 'test'
     end
   end
 
   it "correctly filters by group" do
-    Bookie::Database::User.by_group(Bookie::Database::Group.find_by_name('admin')).count.should eql 2
-    Bookie::Database::User.by_group(Bookie::Database::Group.find_by_name('root')).count.should eql 1
+    expect(Bookie::Database::User.by_group(Bookie::Database::Group.find_by(name: 'admin')).count).to eql 2
+    expect(Bookie::Database::User.by_group(Bookie::Database::Group.find_by(name: 'root')).count).to eql 1
   end
 
   it "correctly filters by group name" do
-    Bookie::Database::User.by_group_name('admin').count.should eql 2
-    Bookie::Database::User.by_group_name('fake_group').count.should eql 0
+    expect(Bookie::Database::User.by_group_name('admin').count).to eql 2
+    expect(Bookie::Database::User.by_group_name('fake_group').count).to eql 0
   end
-  
+
   describe "#find_or_create" do
     before(:each) do
-      @group = Bookie::Database::Group.find_by_name('admin')
+      @group = Bookie::Database::Group.find_by(name: 'admin')
     end
-    
+
     it "creates the user if needed" do
       Bookie::Database::User.expects(:"create!").twice
       user = Bookie::Database::User.find_or_create!('me', @group)
       user = Bookie::Database::User.find_or_create!('me', @group, {})
     end
-    
+
     it "returns the cached user if one exists" do
-      user = Bookie::Database::User.find_by_name('root')
+      user = Bookie::Database::User.find_by(name: 'root')
       known_users = {['root', user.group] => user}
-      Bookie::Database::User.find_or_create!('root', user.group, known_users).should equal user
+      expect(Bookie::Database::User.find_or_create!('root', user.group, known_users)).to equal user
     end
-    
+
     it "queries the database when this user is not cached" do
-      user = Bookie::Database::User.find_by_name_and_group_id('root', 1)
+      user = Bookie::Database::User.find_by!(name: 'root', group_id: 1)
       known_users = {}
-      Bookie::Database::User.expects(:find_by_name_and_group_id).returns(user).twice
+      Bookie::Database::User.expects(:find_by).returns(user).twice
       Bookie::Database::User.expects(:"create!").never
-      Bookie::Database::User.find_or_create!('root', user.group, known_users).should eql user
-      Bookie::Database::User.find_or_create!('root', user.group, nil).should eql user
-      known_users.should include ['root', user.group]
+      expect(Bookie::Database::User.find_or_create!('root', user.group, known_users)).to eql user
+      expect(Bookie::Database::User.find_or_create!('root', user.group, nil)).to eql user
+      expect(known_users).to include ['root', user.group]
     end
   end
-  
+
   it "validates fields" do
     fields = {
       :group => Bookie::Database::Group.first,
       :name => 'test',
     }
-    
-    Bookie::Database::User.new(fields).valid?.should eql true
-    
+
+    expect(Bookie::Database::User.new(fields).valid?).to eql true
+
     fields.each_key do |field|
       user = Bookie::Database::User.new(fields)
       user.method("#{field}=".intern).call(nil)
-      user.valid?.should eql false
+      expect(user.valid?).to eql false
     end
-    
+
     user = Bookie::Database::User.new(fields)
     user.name = ''
-    user.valid?.should eql false
+    expect(user.valid?).to eql false
   end
 end
-

data/spec/extensions_spec.rb

@@ -3,22 +3,22 @@ require 'spec_helper'
 describe Range do
   describe "#normalized" do
     it "correctly normalizes" do
-      (1 .. 2).normalized.should eql(1 .. 2)
-      (1 .. 1).normalized.should eql(1 .. 1)
-      (1 ... 1).normalized.should eql(1 ... 1)
-      (1 .. 0).normalized.should eql(1 ... 1)
-      (1 ... 0).normalized.should eql( 1 ... 1 )
+      expect((1 .. 2).normalized).to eql(1 .. 2)
+      expect((1 .. 1).normalized).to eql(1 .. 1)
+      expect((1 ... 1).normalized).to eql(1 ... 1)
+      expect((1 .. 0).normalized).to eql(1 ... 1)
+      expect((1 ... 0).normalized).to eql( 1 ... 1 )
     end
   end
 
   describe "empty?" do
     it "correctly determines emptiness" do
-      (1 .. 2).empty?.should eql false
-      (1 .. 1).empty?.should eql false
-      (1 ... 2).empty?.should eql false
-      (1 ... 1).empty?.should eql true
-      (1 .. 0).empty?.should eql true
-      (1 ... 0).empty?.should eql true
+      expect((1 .. 2).empty?).to eql false
+      expect((1 .. 1).empty?).to eql false
+      expect((1 ... 2).empty?).to eql false
+      expect((1 ... 1).empty?).to eql true
+      expect((1 .. 0).empty?).to eql true
+      expect((1 ... 0).empty?).to eql true
     end
   end
 end

data/spec/formatter_spec.rb

@@ -6,9 +6,9 @@ module Bookie
       attr_reader :mock_field_values
 
       def open(filename)
-      
+
       end
-      
+
       def do_print_summary(field_values)
         @mock_field_values = field_values
       end
@@ -22,7 +22,7 @@ describe Bookie::Formatter do
   before(:each) do
     Formatter.any_instance.stubs(:require)
   end
-  
+
   let(:formatter) { Formatter.new(:mock) }
   let(:jobs) { Database::Job }
   let(:summaries) { Database::JobSummary }
@@ -31,16 +31,16 @@ describe Bookie::Formatter do
     Formatter.any_instance.expects(:require).with('bookie/formatters/mock')
     Formatter.new(:mock)
   end
-  
+
   it "correctly formats durations" do
-    Formatter.format_duration(1.seconds + 2.minutes + 3.hours + 4.days + 5.weeks).should eql '5 weeks, 4 days, 03:02:01'
-    Formatter.format_duration(1.weeks + 1.days).should eql '1 week, 1 day, 00:00:00'
+    expect(Formatter.format_duration(1.seconds + 2.minutes + 3.hours + 4.days + 5.weeks)).to eql '5 weeks, 4 days, 03:02:01'
+    expect(Formatter.format_duration(1.weeks + 1.days)).to eql '1 week, 1 day, 00:00:00'
   end
-  
+
   it "correctly calculates fields for jobs" do
     with_utc do
       formatter.fields_for_each_job(jobs.limit(1)) do |fields|
-        fields.should eql [
+        expect(fields).to eql [
             'root',
             'root',
             'test1',
@@ -57,11 +57,11 @@ describe Bookie::Formatter do
       jobs = [Database::Job.first]
       jobs[0].system.system_type.memory_stat_type = :unknown
       formatter.send(:fields_for_each_job, jobs) do |fields|
-        fields[8].should eql '200kb'
+        expect(fields[8]).to eql '200kb'
       end
     end
   end
-  
+
   describe "#print_summary" do
     it "prints the correct summary fields" do
       with_utc do
@@ -69,12 +69,12 @@ describe Bookie::Formatter do
 
         formatter.print_summary(jobs, summaries, Database::System)
         formatter.flush
-        formatter.mock_field_values.should eql [
+        expect(formatter.mock_field_values).to eql [
           40, "0 weeks, 0 days, 01:06:40", "50.0000%",
           "0 weeks, 5 days, 20:00:00", "0.7937%",
           "1750000 kb", "0.0114%"
         ]
-        
+
         Database::System.expects(:summary).returns(
           :avail_cpu_time => 0,
           :avail_memory_time => 0,
@@ -82,7 +82,7 @@ describe Bookie::Formatter do
         )
         formatter.print_summary(jobs, summaries, Database::System, base_time ... base_time)
         formatter.flush
-        formatter.mock_field_values.should eql [
+        expect(formatter.mock_field_values).to eql [
           0, "0 weeks, 0 days, 00:00:00", "0.0000%",
           "0 weeks, 0 days, 00:00:00", "0.0000%",
           "0 kb", "0.0000%"
@@ -90,12 +90,12 @@ describe Bookie::Formatter do
       end
     end
   end
-  
+
   it "forwards print_jobs to do_print_jobs" do
     formatter.expects(:do_print_jobs).with(Job)
     formatter.print_jobs(Job)
   end
-  
+
   it "forwards flush to do_flush" do
     formatter.expects(:'respond_to?').with(:do_flush).returns(false)
     formatter.expects(:do_flush).never

data/spec/formatters/comma_dump_spec.rb

@@ -11,27 +11,27 @@ describe Bookie::Formatters::CommaDump do
     File.expects(:open).at_least(0).returns(io_mock)
   end
   let(:formatter) { Bookie::Formatter.new(:comma_dump, 'test.csv') }
-  
+
   it "correctly opens files" do
     File.expects(:open).with('test.csv')
     Bookie::Formatter.new(:comma_dump, 'test.csv')
   end
-  
+
   it "correctly formats jobs" do
     with_utc do
       formatter.print_jobs(Job.order(:start_time).limit(2))
-      io_mock.buf.should eql <<-eos
+      expect(io_mock.buf).to eql <<-eos
 User, Group, System, System type, Start time, End time, Wall time, CPU time, Memory usage, Command, Exit code
 "root", "root", "test1", "Standalone", "2012-01-01 00:00:00", "2012-01-01 01:00:00", "0 weeks, 0 days, 01:00:00", "0 weeks, 0 days, 00:01:40", "200kb (avg)", "vi", "0"
 "test", "default", "test1", "Standalone", "2012-01-01 01:00:00", "2012-01-01 02:00:00", "0 weeks, 0 days, 01:00:00", "0 weeks, 0 days, 00:01:40", "200kb (avg)", "emacs", "1"
 eos
     end
   end
-  
+
   it "correctly formats summaries" do
     Time.expects(:now).returns(base_time + 40.hours).at_least_once
     formatter.print_summary(Job, JobSummary, System)
-    io_mock.buf.should eql <<-eos
+    expect(io_mock.buf).to eql <<-eos
 "Number of jobs", "40"
 "Total CPU time", "0 weeks, 0 days, 01:06:40"
 "Successful", "50.0000%"
@@ -44,8 +44,8 @@ eos
 
   it "correctly quotes values" do
     formatter = Formatters::CommaDump
-    formatter.quote("test").should eql '"test"'
-    formatter.quote('"test"').should eql '"""test"""'
-    formatter.quote(0).should eql '"0"'
+    expect(formatter.quote("test")).to eql '"test"'
+    expect(formatter.quote('"test"')).to eql '"""test"""'
+    expect(formatter.quote(0)).to eql '"0"'
   end
 end

data/spec/formatters/spreadsheet_spec.rb

@@ -18,7 +18,7 @@ end
 class MockWorksheet
   attr_reader :mock_rows
   attr_reader :mock_columns
-  
+
   def initialize
     @mock_rows = []
     @mock_columns = []
@@ -31,7 +31,7 @@ class MockWorksheet
   def column(num)
     @mock_columns[num] ||= MockColumn.new
   end
-  
+
   def last_row_index
     @mock_rows.length - 1
   end
@@ -41,7 +41,7 @@ class MockColumn
   def width=(value)
     @width = value
   end
-  
+
   def width
     @width
   end
@@ -53,14 +53,14 @@ describe Bookie::Formatters::Spreadsheet do
     Spreadsheet::Workbook.expects(:new).returns(mock_workbook)
   end
   let(:formatter) { Bookie::Formatter.new(:spreadsheet, 'test.xls') }
-  
+
   it "correctly formats jobs" do
     with_utc do
       formatter.print_jobs(Job.limit(2))
       w = mock_workbook.worksheet('Details')
-      w.mock_columns.length.should eql Bookie::Formatter::DETAILS_FIELD_LABELS.length
+      expect(w.mock_columns.length).to eql Bookie::Formatter::DETAILS_FIELD_LABELS.length
       w.mock_columns.each do |col|
-        col.width.should_not eql nil
+        expect(col.width).to_not eql nil
       end
       expect(w.mock_rows).to eql([
         Bookie::Formatter::DETAILS_FIELD_LABELS,
@@ -74,12 +74,12 @@ describe Bookie::Formatters::Spreadsheet do
       ])
     end
   end
-  
+
   it "correctly formats summaries" do
     Time.expects(:now).returns(base_time + 40.hours).at_least_once
     formatter.print_summary(Job, JobSummary, System)
     w = mock_workbook.worksheet('Summary')
-    w.column(0).width.should_not eql nil
+    expect(w.column(0).width).to_not eql nil
     expect(w.mock_rows).to eql([
       ["Number of jobs", 40],
       ["Total CPU time", "0 weeks, 0 days, 01:06:40"],
@@ -90,7 +90,7 @@ describe Bookie::Formatters::Spreadsheet do
       ["Memory used (average)", "0.0114%"],
     ])
   end
-  
+
   it "correctly flushes output" do
     mock_workbook.expects(:write).with('test.xls')
     formatter.do_flush

data/spec/formatters/stdout_spec.rb

@@ -14,29 +14,29 @@ describe Bookie::Formatters::Stdout do
 
   it "correctly opens files" do
     f = Bookie::Formatter.new(:stdout)
-    f.instance_variable_get(:'@io').should eql STDOUT
+    expect(f.instance_variable_get(:'@io')).to eql STDOUT
     File.expects(:open).with('mock.out')
     Bookie::Formatter.new(:stdout, 'mock.out')
   end
-  
+
   it "correctly formats jobs" do
     with_utc do
       formatter.print_jobs(Job.order(:start_time).limit(2))
       formatter.flush
-      io_mock.buf.should eql <<-eos
-User            Group           System               System type          Start time                 End time                   Wall time                      CPU time                       Memory usage         Command              Exit code  
+      expect(io_mock.buf).to eql <<-eos
+User            Group           System               System type          Start time                 End time                   Wall time                      CPU time                       Memory usage         Command              Exit code
 ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-root            root            test1                Standalone           2012-01-01 00:00:00        2012-01-01 01:00:00        0 weeks, 0 days, 01:00:00      0 weeks, 0 days, 00:01:40      200kb (avg)          vi                   0          
-test            default         test1                Standalone           2012-01-01 01:00:00        2012-01-01 02:00:00        0 weeks, 0 days, 01:00:00      0 weeks, 0 days, 00:01:40      200kb (avg)          emacs                1          
+root            root            test1                Standalone           2012-01-01 00:00:00        2012-01-01 01:00:00        0 weeks, 0 days, 01:00:00      0 weeks, 0 days, 00:01:40      200kb (avg)          vi                   0
+test            default         test1                Standalone           2012-01-01 01:00:00        2012-01-01 02:00:00        0 weeks, 0 days, 01:00:00      0 weeks, 0 days, 00:01:40      200kb (avg)          emacs                1
 eos
     end
   end
-    
+
   it "correctly formats summaries" do
     Time.expects(:now).returns(base_time + 40.hours).at_least_once
     formatter.print_summary(Job, JobSummary, System)
     formatter.flush
-    io_mock.buf.should eql <<-eos
+    expect(io_mock.buf).to eql <<-eos
 Number of jobs:               40
 Total CPU time:               0 weeks, 0 days, 01:06:40
 Successful:                   50.0000%

data/spec/sender_spec.rb

@@ -29,7 +29,7 @@ class JobStub
   attr_accessor :cpu_time
   attr_accessor :memory
   attr_accessor :exit_code
-  
+
   include Bookie::ModelHelpers
 
   def self.from_job(job)
@@ -74,59 +74,59 @@ describe Bookie::Sender do
   after(:all) do
     rollback_transaction
   end
-  
+
   let(:sender) { Bookie::Sender.new(test_config) }
   before(:each) do
     Bookie::Database::Job.delete_all
   end
-  
+
   it "correctly filters jobs" do
     job = JobStub.new
     job.user_name = "root"
-    sender.filtered?(job).should eql true
+    expect(sender.filtered?(job)).to eql true
     job.user_name = "test"
-    sender.filtered?(job).should eql false
+    expect(sender.filtered?(job)).to eql false
   end
-  
+
   it "correctly sends jobs" do
     config = test_config.clone
     config.excluded_users = Set.new
     sender.send_data('snapshot/torque_large')
     jobs = Job.includes(:system)
     jobs.each do |job|
-      job.system.name.should eql config.hostname
+      expect(job.system.name).to eql config.hostname
     end
-    jobs.length.should eql 100
+    expect(jobs.length).to eql 100
   end
-  
+
   it "refuses to send jobs when jobs already have been sent from a file" do
     sender.send_data('snapshot/torque_large')
     expect {
       sender.send_data('snapshot/torque_large')
     }.to raise_error("Jobs already exist in the database for 'snapshot/torque_large'.")
   end
-  
+
   it "correctly handles empty files" do
     Bookie::Database::Job.any_instance.expects(:'save!').never
     ActiveRecord::Relation.any_instance.expects(:'delete_all').never
     sender.send_data('/dev/null')
   end
-  
+
   it "handles missing files" do
     expect { sender.send_data('snapshot/abc') }.to raise_error("File 'snapshot/abc' does not exist.")
   end
-  
+
   it "chooses the correct systems" do
     sender = Bookie::Sender.new(test_config)
 
     redefine_each_job(sender)
-   
+
     #The filename is just a dummy argument.
     sender.send_data('snapshot/pacct')
-    
+
     jobs = Bookie::Database::Job.by_system_name(test_config.hostname).order(:end_time).to_a
-    jobs[0].system.should eql @sys_1
-    jobs[1].system.should eql @sys_2
+    expect(jobs[0].system).to eql @sys_1
+    expect(jobs[1].system).to eql @sys_2
   end
 
   it "correctly finds duplicates" do
@@ -136,9 +136,9 @@ describe Bookie::Sender do
     #The job's system should be @sys_2.
     #Just to make sure this test doesn't break later, I'll check it.
     #TODO: restore?
-    #expect(job.system).to eql @sys_2
-    #sender.duplicate(stub, @sys_1).should eql nil
-    sender.duplicate(stub, job.system).should eql job
+    #expect(expect(job.system).to eql @sys_2
+    #expect(sender.duplicate(stub, @sys_1)).to eql nil
+    expect(sender.duplicate(stub, job.system)).to eql job
     [:user_name, :group_name, :command_name, :start_time, :wall_time, :cpu_time, :memory, :exit_code].each do |field|
       old_val = stub.send(field)
       if old_val.is_a?(String)
@@ -146,11 +146,11 @@ describe Bookie::Sender do
       else
         stub.send("#{field}=", old_val + 1)
       end
-      sender.duplicate(stub, @sys_2).should eql nil
+      expect(sender.duplicate(stub, @sys_2)).to eql nil
       stub.send("#{field}=", old_val)
     end
   end
-  
+
   it "deletes cached summaries that overlap the new jobs" do
     sender.send_data('snapshot/torque_large')
     time_min = Bookie::Database::Job.order(:start_time).first.start_time
@@ -159,12 +159,12 @@ describe Bookie::Sender do
     sender.expects(:clear_summaries).with(time_min.to_date, time_max.to_date)
     sender.send_data('snapshot/torque_large')
   end
-  
+
   describe "#clear_summaries" do
     it "deletes cached summaries" do
       sender = Bookie::Sender.new(test_config)
       sender.send_data('snapshot/torque_large')
-      
+
       user = Bookie::Database::User.first
       date_start = Date.new(2012) - 2
       date_end = date_start + 4
@@ -175,50 +175,48 @@ describe Bookie::Sender do
             :system => system,
             :user => user,
             :command_name => 'vi',
-            :num_jobs => 1,
             :cpu_time => 1,
-            :memory_time => 100,
-            :successful => 1
+            :memory_time => 100
           )
         end
       end
-      
+
       sender.send(:clear_summaries, date_start + 1, date_end - 1)
-      
+
       sums = Bookie::Database::JobSummary.all.to_a
-      sums.length.should eql 9
+      expect(sums.length).to eql 9
       sums.each do |sum|
         #Since there are no jobs for @sys_dummy, its summaries should be left intact.
         unless sum.system == @sys_dummy
-          (date_start + 1 .. date_end - 1).cover?(sum.date).should eql false
+          expect((date_start + 1 .. date_end - 1).cover?(sum.date)).to eql false
         end
       end
       sums = Bookie::Database::JobSummary.by_date(Date.new(2012))
-      sums.count.should eql 1
-      sums.first.system.should eql @sys_dummy
+      expect(sums.count).to eql 1
+      expect(sums.first.system).to eql @sys_dummy
     end
   end
-  
+
   describe "#undo_send" do
     it "removes the correct entries" do
       sender.send_data('snapshot/torque_large')
       sender.send_data('snapshot/torque')
       sender.undo_send('snapshot/torque_large')
-      
-      Bookie::Database::Job.count.should eql 1
+
+      expect(Bookie::Database::Job.count).to eql 1
       job = Bookie::Database::Job.first
       Bookie::Database::Job.delete_all
       sender.send_data('snapshot/torque')
       job2 = Bookie::Database::Job.first
       job2.id = job.id
-      job2.should eql job
+      expect(job2).to eql job
     end
 
     it "switches systems if needed" do
       sender = Bookie::Sender.new(test_config)
 
       redefine_each_job(sender)
-     
+
       #The filename is just a dummy argument.
       sender.send_data('snapshot/pacct')
 
@@ -254,21 +252,21 @@ describe Bookie::ModelHelpers do
     @job.cpu_time = 2
     @job.memory = 300
   end
-  
+
   it "correctly converts jobs to records" do
     Bookie::Database::Job.stubs(:new).returns(JobStub.new)
     djob = @job.to_record
-    djob.command_name.should eql @job.command_name
-    djob.start_time.should eql @job.start_time
-    djob.end_time.should eql @job.start_time + @job.wall_time
-    djob.wall_time.should eql @job.wall_time
-    djob.cpu_time.should eql @job.cpu_time
-    djob.memory.should eql @job.memory
-    djob.exit_code.should eql @job.exit_code
+    expect(djob.command_name).to eql @job.command_name
+    expect(djob.start_time).to eql @job.start_time
+    expect(djob.end_time).to eql @job.start_time + @job.wall_time
+    expect(djob.wall_time).to eql @job.wall_time
+    expect(djob.cpu_time).to eql @job.cpu_time
+    expect(djob.memory).to eql @job.memory
+    expect(djob.exit_code).to eql @job.exit_code
   end
 
   it "correctly calculates end time" do
-    @job.end_time.should eql @job.start_time + @job.wall_time
+    expect(@job.end_time).to eql @job.start_time + @job.wall_time
   end
 end