bookie_accounting 2.0.0 → 2.0.1

data/lib/bookie/database/lock.rb

@@ -21,15 +21,15 @@ module Bookie
           yield
         end
       end
-      
+
       @locks = {}
-      
+
       ##
       #Returns a lock by name
       def self.[](name)
-        @locks[name.to_sym] ||= find_by_name(name.to_s) or raise "Unable to find lock '#{name}'"
+        @locks[name.to_sym] ||= find_by!(name: name.to_s)
       end
-      
+
       validates_presence_of :name
     end
   end

data/lib/bookie/database/system_type.rb

@@ -10,17 +10,17 @@ module Bookie
     #A system type
     class SystemType < ActiveRecord::Base
       has_many :systems
-      
+
       validates_presence_of :name, :memory_stat_type
 
       ##
       #Maps memory stat type symbols to their enumerated values in the database
       MEMORY_STAT_TYPE = {:unknown => 0, :avg => 1, :max => 2}
-      
+
       ##
       #The inverse of MEMORY_STAT_TYPE
       MEMORY_STAT_TYPE_INVERSE = MEMORY_STAT_TYPE.invert
-      
+
       ##
       #Finds a system type by name and memory stat type, creating it if it doesn't exist
       #
@@ -30,7 +30,7 @@ module Bookie
       def self.find_or_create!(name, memory_stat_type)
         sys_type = nil
         Lock[:system_types].synchronize do
-          sys_type = SystemType.find_by_name(name)
+          sys_type = SystemType.find_by(name: name)
           if sys_type
             unless sys_type.memory_stat_type == memory_stat_type
               type_code = MEMORY_STAT_TYPE[memory_stat_type]
@@ -49,7 +49,7 @@ module Bookie
         end
         sys_type
       end
-      
+
       ##
       #Returns the memory stat type as a symbol
       #
@@ -63,7 +63,7 @@ module Bookie
         raise "Unrecognized memory stat type code #{type_code}" unless type
         type
       end
-      
+
       ##
       #Sets the memory stat type
       #

data/lib/bookie/database/user.rb

@@ -9,7 +9,7 @@ module Bookie
     #Model for a user
     class User < ActiveRecord::Base
       belongs_to :group
-      
+
       def self.by_name(name)
         where('users.name = ?', name)
       end
@@ -19,11 +19,11 @@ module Bookie
       end
 
       def self.by_group_name(name)
-        group = Group.find_by_name(name)
+        group = Group.find_by(name: name)
         return by_group(group) if group
         self.none
       end
-      
+
       ##
       #Finds a user by name and group, creating it if it doesn't exist
       #
@@ -36,7 +36,7 @@ module Bookie
         unless user
           Lock[:users].synchronize do
             #Does the user already exist?
-            user = Bookie::Database::User.find_by_name_and_group_id(name, group.id)
+            user = Bookie::Database::User.find_by(name: name, group_id: group.id)
             user ||= Bookie::Database::User.create!(
               :name => name,
               :group => group
@@ -46,7 +46,7 @@ module Bookie
         end
         user
       end
-      
+
       validates_presence_of :group, :name
     end
 

data/lib/bookie/formatters/stdout.rb

@@ -10,21 +10,23 @@ module Bookie
           @io = STDOUT
         end
       end
-      
+
       def do_print_summary(field_values)
         Formatter::SUMMARY_FIELD_LABELS.zip(field_values) do |label, value|
           @io.printf("%-30.30s%s\n", "#{label}:", value)
         end
       end
-      
+
       def do_print_jobs(jobs)
-        #To consider: optimize by moving out of the function?
-        format_string = "%-15.15s %-15.15s %-20.20s %-20.20s %-26.26s %-26.26s %-30.30s %-30.30s %-20.20s %-20.20s %-11.11s\n"
+        #TODO: optimize by moving out of the function?
+        format_string = "%-15.15s %-15.15s %-20.20s %-20.20s %-26.26s %-26.26s %-30.30s %-30.30s %-20.20s %-20.20s %-11.11s"
         heading = sprintf(format_string, *Formatter::DETAILS_FIELD_LABELS)
-        @io.write heading
-        @io.puts '-' * (heading.length - 1)
+        @io.puts heading.rstrip
+        @io.puts '-' * (heading.length)
         fields_for_each_job(jobs) do |fields|
-          @io.printf(format_string, *fields)
+          line = sprintf(format_string, *fields)
+          line.rstrip!
+          @io.puts line
         end
       end
     end

data/lib/bookie/version.rb

@@ -1,4 +1,4 @@
 module Bookie
   #The library version
-  VERSION = "2.0.0"
+  VERSION = "2.0.1"
 end

data/spec/config_spec.rb

@@ -5,33 +5,33 @@ require 'active_record'
 describe Bookie::Config do
   it "loads correct data" do
     config = Bookie::Config.new('snapshot/test_config.json')
-    
-    config.db_type.should eql "sqlite3"
-    config.server.should eql "localhost"
-    config.port.should eql 8080
-    config.database.should eql ":memory:"
-    config.username.should eql "blm768"
-    config.password.should eql "test"
-    config.excluded_users.should eql Set.new(["root"])
-    config.hostname.should eql "localhost"
-    config.cores.should eql 8
-    config.memory.should eql 8000000
-    config.system_type.should eql 'torque_cluster'
+
+    expect(config.db_type).to eql "sqlite3"
+    expect(config.server).to eql "localhost"
+    expect(config.port).to eql 8080
+    expect(config.database).to eql ":memory:"
+    expect(config.username).to eql "blm768"
+    expect(config.password).to eql "test"
+    expect(config.excluded_users).to eql Set.new(["root"])
+    expect(config.hostname).to eql "localhost"
+    expect(config.cores).to eql 8
+    expect(config.memory).to eql 8000000
+    expect(config.system_type).to eql 'torque_cluster'
   end
-  
+
   it "correctly verifies types" do
     config = Bookie::Config.new('snapshot/default.json')
     config.verify_type("abc", "test", String)
     expect { config.verify_type("abc", "test", Fixnum) }.to raise_error(TypeError, 'Invalid data type String for JSON field "test": Fixnum expected')
   end
-  
+
   it "sets correct defaults" do
     dconfig = Bookie::Config.new('snapshot/default.json')
-    
-    dconfig.port.should eql nil
-    dconfig.excluded_users.should eql Set.new([])
+
+    expect(dconfig.port).to eql nil
+    expect(dconfig.excluded_users).to eql Set.new([])
   end
-  
+
   it 'correctly handles missing fields' do
     fields = JSON.parse(File.read('snapshot/default.json'))
     fields.keys.each do |key|
@@ -44,12 +44,12 @@ describe Bookie::Config do
     #This should not raise an error.
     Bookie::Config.new('snapshot/default.json')
   end
-  
+
   it "configures and connects to the database" do
     config = Bookie::Config.new('snapshot/test_config.json')
     ActiveRecord::Base.expects(:establish_connection)
     config.connect
-    ActiveRecord::Base.time_zone_aware_attributes.should eql true
-    ActiveRecord::Base.default_timezone.should eql :utc
+    expect(ActiveRecord::Base.time_zone_aware_attributes).to eql true
+    expect(ActiveRecord::Base.default_timezone).to eql :utc
   end
 end

data/spec/database/group_spec.rb

@@ -6,31 +6,30 @@ describe Bookie::Database::Group do
       Bookie::Database::Group.expects(:"create!")
       Bookie::Database::Group.find_or_create!('non_root')
     end
-    
+
     it "returns the cached group if one exists" do
-      group = Bookie::Database::Group.find_by_name('root')
+      group = Bookie::Database::Group.find_by(name: 'root')
       known_groups = {'root' => group}
-      Bookie::Database::Group.find_or_create!('root', known_groups).should equal group
+      expect(Bookie::Database::Group.find_or_create!('root', known_groups)).to equal group
     end
-    
+
     it "queries the database when this group is not cached" do
-      group = Bookie::Database::Group.find_by_name('root')
+      group = Bookie::Database::Group.find_by(name: 'root')
       known_groups = {}
-      Bookie::Database::Group.expects(:find_by_name).returns(group).twice
+      Bookie::Database::Group.expects(:find_by).returns(group).twice
       Bookie::Database::Group.expects(:"create!").never
-      Bookie::Database::Group.find_or_create!('root', known_groups).should eql group
-      Bookie::Database::Group.find_or_create!('root', nil).should eql group
-      known_groups.should include 'root'
+      expect(Bookie::Database::Group.find_or_create!('root', known_groups)).to eql group
+      expect(Bookie::Database::Group.find_or_create!('root', nil)).to eql group
+      expect(known_groups).to include 'root'
     end
   end
-  
+
   it "validates the name field" do
     group = Bookie::Database::Group.new(:name => nil)
-    group.valid?.should eql false
+    expect(group.valid?).to eql false
     group.name = ''
-    group.valid?.should eql false
+    expect(group.valid?).to eql false
     group.name = 'test'
-    group.valid?.should eql true
+    expect(group.valid?).to eql true
   end
 end
-

data/spec/database/job_spec.rb

@@ -16,15 +16,15 @@ end
 describe Bookie::Database::Job do
   it "correctly sets end times" do
     Job.find_each do |job|
-      job.end_time.should eql job.start_time + job.wall_time
-      job.end_time.should eql job.read_attribute(:end_time)
+      expect(job.end_time).to eql job.start_time + job.wall_time
+      expect(job.end_time).to eql job.read_attribute(:end_time)
     end
 
     #Test the update hook.
     job = Job.first
     job.start_time -= 1
     job.save!
-    job.end_time.should eql job.read_attribute(:end_time)
+    expect(job.end_time).to eql job.read_attribute(:end_time)
   end
 
   describe "#end_time=" do
@@ -38,106 +38,106 @@ describe Bookie::Database::Job do
       expect(job.end_time).to eql(old_end_time - 1)
     end
   end
-  
+
   it "correctly filters by user" do
     user = User.by_name('test').order(:id).first
     jobs = Job.by_user(user).to_a
     jobs.each do |job|
-      job.user.should eql user
+      expect(job.user).to eql user
     end
-    jobs.length.should eql 10 
+    expect(jobs.length).to eql 10
   end
-  
+
   it "correctly filters by user name" do
     jobs = Job.by_user_name('root').to_a
-    jobs.length.should eql 10
-    jobs[0].user.name.should eql "root"
+    expect(jobs.length).to eql 10
+    expect(jobs[0].user.name).to eql "root"
     jobs = Job.by_user_name('test').order(:end_time).to_a
-    jobs.length.should eql 20
+    expect(jobs.length).to eql 20
     jobs.each do |job|
-      job.user.name.should eql 'test'
+      expect(job.user.name).to eql 'test'
     end
-    jobs[0].user_id.should_not eql jobs[-1].user_id
+    expect(jobs[0].user_id).to_not eql jobs[-1].user_id
     jobs = Job.by_user_name('user').to_a
-    jobs.length.should eql 0
+    expect(jobs.length).to eql 0
   end
 
   it "correctly filters by group name" do
     jobs = Job.by_group_name("root").to_a
-    jobs.length.should eql 10
+    expect(jobs.length).to eql 10
     jobs.each do |job|
-      job.user.group.name.should eql "root"
+      expect(job.user.group.name).to eql "root"
     end
     jobs = Job.by_group_name("admin").order(:start_time).to_a
-    jobs.length.should eql 20
-    jobs[0].user.name.should_not eql jobs[1].user.name
+    expect(jobs.length).to eql 20
+    expect(jobs[0].user.name).to_not eql jobs[1].user.name
     jobs = Job.by_group_name("test").to_a
-    jobs.length.should eql 0
+    expect(jobs.length).to eql 0
   end
-  
+
   it "correctly filters by system" do
     sys = System.first
     jobs = Job.by_system(sys)
-    jobs.length.should eql 10
+    expect(jobs.length).to eql 10
     jobs.each do |job|
-      job.system.should eql sys
+      expect(job.system).to eql sys
     end
   end
-  
+
   it "correctly filters by system name" do
     jobs = Job.by_system_name('test1')
-    jobs.length.should eql 20
+    expect(jobs.length).to eql 20
     jobs = Job.by_system_name('test2')
-    jobs.length.should eql 10
+    expect(jobs.length).to eql 10
     jobs = Job.by_system_name('test3')
-    jobs.length.should eql 10
+    expect(jobs.length).to eql 10
     jobs = Job.by_system_name('test4')
-    jobs.length.should eql 0
+    expect(jobs.length).to eql 0
   end
-  
+
   it "correctly filters by system type" do
-    sys_type = SystemType.find_by_name('Standalone')
+    sys_type = SystemType.find_by(name: 'Standalone')
     jobs = Job.by_system_type(sys_type)
-    jobs.length.should eql 20
-    sys_type = SystemType.find_by_name('TORQUE cluster')
+    expect(jobs.length).to eql 20
+    sys_type = SystemType.find_by(name: 'TORQUE cluster')
     jobs = Job.by_system_type(sys_type)
-    jobs.length.should eql 20
+    expect(jobs.length).to eql 20
   end
 
   it "correctly filters by command name" do
     jobs = Job.by_command_name('vi')
-    jobs.length.should eql 20
+    expect(jobs.length).to eql 20
     jobs = Job.by_command_name('emacs')
-    jobs.length.should eql 20
+    expect(jobs.length).to eql 20
   end
-  
+
   describe "#by_time_range" do
     let(:base_start) { base_time + 1.hours }
     let(:base_end) { base_start + 2.hours }
 
     it "filters by inclusive time range" do
       jobs = Job.by_time_range(base_start ... base_end + 1)
-      jobs.count.should eql 3
-      jobs = Job.by_time_range(base_start + 1 ... base_end) 
-      jobs.count.should eql 2
+      expect(jobs.count).to eql 3
+      jobs = Job.by_time_range(base_start + 1 ... base_end)
+      expect(jobs.count).to eql 2
       jobs = Job.by_time_range(base_start ... base_start)
-      jobs.length.should eql 0
+      expect(jobs.length).to eql 0
     end
 
     it "filters by exclusive time range" do
       jobs = Job.by_time_range(base_start + 1 .. base_end)
-      jobs.count.should eql 3
+      expect(jobs.count).to eql 3
       jobs = Job.by_time_range(base_start .. base_end - 1)
-      jobs.count.should eql 2
+      expect(jobs.count).to eql 2
       jobs = Job.by_time_range(base_start .. base_start)
-      jobs.count.should eql 1
+      expect(jobs.count).to eql 1
     end
-    
+
     context "with an empty range" do
       it "finds no jobs" do
         (-1 .. 0).each do |offset|
           jobs = Job.by_time_range(base_start ... base_start + offset)
-          jobs.count.should eql 0
+          expect(jobs.count).to eql 0
         end
       end
     end
@@ -176,7 +176,7 @@ describe Bookie::Database::Job do
         jobs = Job.overlapping_edges(base_start + 1 ... base_end)
         expect(jobs.count).to eql 1
         expect(jobs.first.start_time).to eql base_time
-        
+
         #Overlapping end
         jobs = Job.overlapping_edges(base_start ... base_end - 1)
         expect(jobs.count).to eql 1
@@ -188,9 +188,9 @@ describe Bookie::Database::Job do
         expect(jobs.first.start_time).to eql base_time
 
         #Two jobs overlapping the endpoints
-        jobs = Job.overlapping_edges(base_end - 1 ... base_end + 1) 
+        jobs = Job.overlapping_edges(base_end - 1 ... base_end + 1)
         expect(jobs.count).to eql 2
-        
+
         #Not overlapping any endpoints
         jobs = Job.overlapping_edges(base_start ... base_end)
         expect(jobs.count).to eql 0
@@ -218,7 +218,7 @@ describe Bookie::Database::Job do
       end
     end
   end
-   
+
   describe "#summary" do
     let(:count) { Job.count }
     let(:summary) { create_summaries(Job, base_time) }
@@ -251,29 +251,29 @@ describe Bookie::Database::Job do
         :successful => num_clipped_jobs / 2 + 1,
       })
     end
-    
+
     it "correctly handles summaries of empty sets" do
-      summary[:empty].should eql({
+      expect(summary[:empty]).to eql({
           :num_jobs => 0,
           :cpu_time => 0,
           :memory_time => 0,
           :successful => 0,
         })
     end
-    
+
     it "correctly handles inverted ranges" do
-      Job.summary(Time.now() ... Time.now() - 1).should eql summary[:empty]
-      Job.summary(Time.now() .. Time.now() - 1).should eql summary[:empty]
+      expect(Job.summary(Time.now() ... Time.now() - 1)).to eql summary[:empty]
+      expect(Job.summary(Time.now() .. Time.now() - 1)).to eql summary[:empty]
     end
 
     it "distinguishes between inclusive and exclusive ranges" do
       sum = Job.summary(base_time ... base_time + 3600)
-      sum[:num_jobs].should eql 1
+      expect(sum[:num_jobs]).to eql 1
       sum = Job.summary(base_time .. base_time + 3600)
-      sum[:num_jobs].should eql 2
+      expect(sum[:num_jobs]).to eql 2
     end
   end
-  
+
   it "validates fields" do
     fields = {
       :user => User.first,
@@ -285,24 +285,23 @@ describe Bookie::Database::Job do
       :memory => 10000,
       :exit_code => 0
     }
-    
+
     job = Job.new(fields)
-    job.valid?.should eql true
-    
+    expect(job.valid?).to eql true
+
     fields.each_key do |field|
       job = Job.new(fields)
       job.method("#{field}=".intern).call(nil)
-      job.valid?.should eql false
+      expect(job.valid?).to eql false
     end
-    
+
     [:cpu_time, :wall_time, :memory].each do |field|
       job = Job.new(fields)
       m = job.method("#{field}=".intern)
       m.call(-1)
-      job.valid?.should eql false
+      expect(job.valid?).to eql false
       m.call(0)
-      job.valid?.should eql true
+      expect(job.valid?).to eql true
     end
   end
 end
-