bookie_accounting 0.0.2 → 0.0.3

data/lib/bookie/formatter.rb

@@ -28,7 +28,6 @@ module Bookie
     #An array containing the labels for each field in a summary
     SUMMARY_FIELD_LABELS = [
         "Number of jobs",
-        "Total wall time",
         "Total CPU time",
         "Successful",
         "Available CPU time",
@@ -45,27 +44,28 @@ module Bookie
       ]
     
     ##
-    #Prints a summary of <tt>jobs</tt> and <tt>systems</tt> to <tt>io</tt>
+    #Prints a summary of <tt>jobs</tt> and <tt>systems</tt> to <tt>io</tt>, using cached data from <tt>summaries</tt>
     #
     #Use start_time and end_time to filter the jobs by a time range.
     #
-    #It is probably not a good idea to apply any time-based filters to <tt>jobs</tt> or <tt>systems</tt> beforehand.
+    #It is probably not a good idea to apply any time-based filters to the arguments beforehand.
     #
-    #Both <tt>jobs</tt> and <tt>systems</tt> should be either models or ActiveRecord::Relation objects.
+    #Both <tt>jobs</tt>, <tt>summaries</tt>, and <tt>systems</tt> should be either models or ActiveRecord::Relation objects.
     #
     #Returns the summaries for <tt>jobs</tt> and <tt>systems</tt>
-    def print_summary(jobs, systems, start_time = nil, end_time = nil)
-      jobs_summary = jobs.summary(start_time, end_time)
-      systems_summary = systems.summary(start_time, end_time)
+    def print_summary(jobs, summaries, systems, time_range = nil)
+      jobs_summary = summaries.summary(:jobs => jobs, :range => time_range)
+      num_jobs = jobs_summary[:num_jobs]
+      systems_summary = systems.summary(time_range)
       cpu_time = jobs_summary[:cpu_time]
       avail_cpu_time = systems_summary[:avail_cpu_time]
       memory_time = jobs_summary[:memory_time]
       avail_memory_time = systems_summary[:avail_memory_time]
+      successful = (num_jobs == 0) ? 0.0 : Float(jobs_summary[:successful]) / num_jobs
       field_values = [
-        jobs_summary[:jobs].length,
-        Formatter.format_duration(jobs_summary[:wall_time]),
+        num_jobs,
         Formatter.format_duration(cpu_time),
-        '%.4f%%' % (jobs_summary[:successful] * 100),
+        '%.4f%%' % (successful * 100),
         Formatter.format_duration(systems_summary[:avail_cpu_time]),
         if avail_cpu_time == 0 then '0.0000%' else '%.4f%%' % (Float(cpu_time) / avail_cpu_time * 100) end,
         "#{Integer(systems_summary[:avail_memory_avg])} kb",

data/lib/bookie/sender.rb

@@ -6,6 +6,8 @@ module Bookie
   ##
   #An object that sends data to the database
   class Sender
+    attr_reader :config
+    
     ##
     #Creates a new Sender
     #
@@ -17,61 +19,66 @@ module Bookie
       extend Bookie::Senders.const_get(t.camelize)
     end
     
-    ##
-    #Retrieves the System object with which the jobs will be associated
-    #--
-    #To consider: caching?
-    #++
-    def system
-      hostname = @config.hostname
-      system_type = self.system_type
-      Bookie::Database::System.find_active(
-        :name => hostname,
-        :system_type => system_type,
-        :start_time => Time.now,
-        :cores => @config.cores,
-        :memory => @config.memory
-      )
-    end
-    
     ##
     #Sends job data from the given file to the database server
     def send_data(filename)
       raise IOError.new("File '#{filename}' does not exist.") unless File.exists?(filename)
     
-      system = self.system
+      system = nil
       
       known_users = {}
       known_groups = {}
       
-      #Check the first job to see if there are entries in the database for its date from this system.
+      time_min, time_max = nil
+      
+      #Grab data from the first job:  
       each_job(filename) do |job|
         next if filtered?(job)
         end_time = job.start_time + job.wall_time
+        system = Bookie::Database::System.find_current(self, end_time)
         duplicate = system.jobs.find_by_end_time(end_time)
-        if duplicate
-          raise "Jobs already exist in the database for the date #{end_time.strftime('%Y-%m-%d')}."
-        end
+        raise "Jobs already exist in the database for '#{filename}'." if duplicate
+        time_min = job.start_time
+        time_max = end_time
         break
       end
       
+      #If there are no jobs, return.
+      return unless time_min
+      
+      #To do: add an option to resume an interrupted send.
+      
+      #Send the job data:
       each_job(filename) do |job|
         next if filtered?(job)
-        db_job = job.to_model
-        #Determine if the user/group pair must be added to/retrieved from the database.
+        model = job.to_model
+        time_min = (model.start_time < time_min) ? model.start_time : time_min
+        time_max = (model.end_time > time_max) ? model.end_time : time_max
+        #To consider: handle files that don't have jobs sorted by end time?
+        if system.end_time && model.end_time > system.end_time
+          system = Database::System.find_current(self, model.end_time)
+        end
         user = Bookie::Database::User.find_or_create!(
           job.user_name,
           Bookie::Database::Group.find_or_create!(job.group_name, known_groups),
-          known_users)
-        db_job.system = system
-        db_job.user = user
-        db_job.save!
+          known_users
+        )
+        model.system = system
+        model.user = user
+        model.save!
       end
+      
+      #Clear out the summaries that would have been affected by the new data:
+      date_min = time_min.to_date
+      date_max = time_max.to_date
+      
+      Database::JobSummary.by_system(system).where('date >= ? AND date <= ?', date_min, date_max).delete_all
     end
     
     ##
     #The name of the Bookie::Database::SystemType that systems using this sender will have
     def system_type
+      #To consider: cache?
       Bookie::Database::SystemType.find_or_create!(system_type_name, memory_stat_type)
     end
     

data/lib/bookie/version.rb

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

data/rpm/bookie_accounting.spec.erb

@@ -0,0 +1,81 @@
+%define gem_name <%= gem_name %>
+
+<% if is_app %>
+Name:   %{gem_name}
+<% else %>
+Name:		rubygem-%{gem_name}
+<% end %>
+Version:	<%= version %>
+Release:	1%{?dist}
+Summary:	<%= summary %>
+
+%define gem <%= gem %>
+
+Group:		Development/Libraries
+License:	<%= license %>
+URL:		  <%= url %>
+Source0:	<%= gem_file %>
+BuildRoot:	%(mktemp -ud %{_tmppath}/%{name}-%{version}-%{release}-XXXXXX)
+
+BuildRequires:	ruby-devel
+Requires:	rubygems
+<% if requires.length > 0 %>
+Requires:	<%= requires.join(", ") %>
+<% end %>
+
+%description
+<%= description %>
+
+%prep
+rm -rf %{name}
+mkdir %{name}
+%setup -q -D -T -n %{name}
+cp %{SOURCE0} .
+
+%define gem_dir /usr/lib/ruby/gems/<%= ruby_version %>
+%define gem_instdir %{gem_dir}/gems/%{gem}
+
+%build
+mkdir -p ./%{gem_dir}
+
+export CONFIGURE_ARGS="--with-cflags='%{optflags}'"
+gem install -V \
+        --local \
+        --install-dir ./%{gem_dir} \
+        --bindir ./%{_bindir} \
+        --force \
+        --rdoc \
+        <%= gem_file %>
+
+%install
+rm -rf %{buildroot}
+mkdir -p %{buildroot}%{gem_instdir}
+
+<% if has_binaries %>
+cp -a ./%{_bindir} %{buildroot}%{_bindir}/
+<% end %>
+
+cp -a ./%{gem_dir}/* %{buildroot}%{gem_dir}/
+
+mkdir -p %{buildroot}/etc/bookie/
+echo "{}" > %{buildroot}/etc/bookie/config.json
+
+%clean
+rm -rf %{buildroot}
+
+%files
+%defattr(-,root,root,-)
+%dir %{gem_dir}/doc/%{gem}
+%doc %{gem_dir}/doc/%{gem}/*
+%dir %{gem_instdir}
+<% if has_binaries %>
+%{_bindir}/*
+<% end %>
+/etc/bookie/config.json
+%{gem_instdir}/*
+%{gem_instdir}/.*
+%{gem_dir}/specifications/%{gem}.gemspec
+%{gem_dir}/cache/%{gem}.gem
+
+%changelog
+

data/rpm/spec_template.erb

@@ -0,0 +1,77 @@
+%define gem_name <%= gem_name %>
+
+<% if is_app %>
+Name:   %{gem_name}
+<% else %>
+Name:		rubygem-%{gem_name}
+<% end %>
+Version:	<%= version %>
+Release:	1%{?dist}
+Summary:	<%= summary %>
+
+%define gem <%= gem %>
+
+Group:		Development/Libraries
+License:	<%= license %>
+URL:		  <%= url %>
+Source0:	<%= gem_file %>
+BuildRoot:	%(mktemp -ud %{_tmppath}/%{name}-%{version}-%{release}-XXXXXX)
+
+BuildRequires:	ruby-devel
+Requires:	rubygems
+<% if requires.length > 0 %>
+Requires:	<%= requires.join(", ") %>
+<% end %>
+
+%description
+<%= description %>
+
+%prep
+rm -rf %{name}
+mkdir %{name}
+%setup -q -D -T -n %{name}
+cp %{SOURCE0} .
+
+%define gem_dir /usr/lib/ruby/gems/<%= ruby_version %>
+%define gem_instdir %{gem_dir}/gems/%{gem}
+
+%build
+mkdir -p ./%{gem_dir}
+
+export CONFIGURE_ARGS="--with-cflags='%{optflags}'"
+gem install -V \
+        --local \
+        --install-dir ./%{gem_dir} \
+        --bindir ./%{_bindir} \
+        --force \
+        --rdoc \
+        <%= gem_file %>
+
+%install
+rm -rf %{buildroot}
+mkdir -p %{buildroot}%{gem_instdir}
+
+<% if has_binaries %>
+cp -a ./%{_bindir} %{buildroot}%{_bindir}/
+<% end %>
+
+cp -a ./%{gem_dir}/* %{buildroot}%{gem_dir}/
+
+%clean
+rm -rf %{buildroot}
+
+%files
+%defattr(-,root,root,-)
+%dir %{gem_dir}/doc/%{gem}
+%doc %{gem_dir}/doc/%{gem}/*
+%dir %{gem_instdir}
+<% if has_binaries %>
+%{_bindir}/*
+<% end %>
+%{gem_instdir}/*
+%{gem_instdir}/.*
+%{gem_dir}/specifications/%{gem}.gemspec
+%{gem_dir}/cache/%{gem}.gem
+
+%changelog
+

data/spec/comma_dump_formatter_spec.rb

@@ -13,6 +13,7 @@ describe Bookie::Formatters::CommaDump do
     Bookie::Database::Migration.up
     Helpers::generate_database
     @jobs = Bookie::Database::Job
+    @summaries = Bookie::Database::JobSummary
   end
   
   before(:each) do
@@ -31,7 +32,7 @@ describe Bookie::Formatters::CommaDump do
   end
   
   it "correctly formats jobs" do
-    @formatter.print_jobs(@jobs.order(:start_time).limit(2))
+    @formatter.print_jobs(@jobs.order(:start_time).limit(2).all)
     @m.buf.should eql <<-eos
 User, Group, System, System type, Start time, End time, Wall time, CPU time, Memory usage, Exit code
 root, root, test1, Standalone, 2012-01-01 00:00:00, 2012-01-01 01:00:00, 01:00:00, 00:01:40, 200kb (avg), 0
@@ -41,16 +42,15 @@ eos
   
   it "correctly formats summaries" do
     Time.expects(:now).returns(Time.local(2012) + 36000 * 4).at_least_once
-    @formatter.print_summary(@jobs.order(:start_time).limit(5), Bookie::Database::System)
+    @formatter.print_summary(@jobs, @summaries, Bookie::Database::System)
     @m.buf.should eql <<-eos
-Number of jobs, 5
-Total wall time, 05:00:00
-Total CPU time, 00:08:20
-Successful, 60.0000%
+Number of jobs, 40
+Total CPU time, 01:06:40
+Successful, 50.0000%
 Available CPU time, 140:00:00
-CPU time used, 0.0992%
+CPU time used, 0.7937%
 Available memory (average), 1750000 kb
-Memory used (average), 0.0014%
+Memory used (average), 0.0114%
 eos
   end
 end

data/spec/database_spec.rb

@@ -6,12 +6,17 @@ module Helpers
     end_time_1   = base_time + 3600 * 40
     start_time_2 = base_time + 1800
     end_time_2 = base_time + (36000 * 2 + 18000)
-    {
+    summaries = {
       :all => obj.summary,
-      :all_constrained => obj.summary(start_time_1, end_time_1),
-      :clipped => obj.summary(start_time_2, end_time_2),
-      :empty => obj.summary(Time.at(0), Time.at(0)),
+      :all_constrained => obj.summary(start_time_1 ... end_time_1),
+      :clipped => obj.summary(start_time_2 ... end_time_2),
+      :empty => obj.summary(Time.at(0) ... Time.at(0)),
     }
+    if obj.respond_to?(:by_command_name)
+      summaries[:all_filtered] = obj.by_command_name('vi').summary(start_time_1 ... end_time_1)
+    end
+    
+    summaries
   end
   
   def test_relations(job, relations)
@@ -24,6 +29,14 @@ module Helpers
       relations[r] = r
     end
   end
+  
+  def check_job_sums(js_sum, j_sum)
+    js_sum[:num_jobs].should eql j_sum[:jobs].length
+    [:cpu_time, :memory_time, :successful].each do |field|
+      js_sum[field].should eql j_sum[field]
+    end
+    true
+  end
 end
 
 describe Bookie::Database do
@@ -99,6 +112,15 @@ describe Bookie::Database do
     end
     
     it "correctly filters by user" do
+      user = Bookie::Database::User.by_name('test').order(:id).first
+      jobs = @jobs.by_user(user).all
+      jobs.each do |job|
+        job.user.should eql user
+      end
+      jobs.length.should eql 10 
+    end
+    
+    it "correctly filters by user name" do
       jobs = @jobs.by_user_name('root').all
       jobs.length.should eql 10
       jobs[0].user.name.should eql "root"
@@ -112,7 +134,7 @@ describe Bookie::Database do
       jobs.length.should eql 0
     end
   
-    it "correctly filters by group" do
+    it "correctly filters by group name" do
       jobs = @jobs.by_group_name("root").all
       jobs.length.should eql 10
       jobs.each do |job|
@@ -126,6 +148,15 @@ describe Bookie::Database do
     end
     
     it "correctly filters by system" do
+      sys = Bookie::Database::System.first
+      jobs = @jobs.by_system(sys)
+      jobs.length.should eql 10
+      jobs.each do |job|
+        job.system.should eql sys
+      end
+    end
+    
+    it "correctly filters by system name" do
       jobs = @jobs.by_system_name('test1')
       jobs.length.should eql 20
       jobs = @jobs.by_system_name('test2')
@@ -153,43 +184,48 @@ describe Bookie::Database do
     end
     
     it "correctly filters by start time" do
-      jobs = @jobs.by_start_time_range(@base_time, @base_time + 3600 * 2 + 1)
+      jobs = @jobs.by_start_time_range(@base_time ... @base_time + 3600 * 2 + 1)
       jobs.length.should eql 3
-      jobs = @jobs.by_start_time_range(@base_time + 1, @base_time + 3600 * 2)
+      jobs = @jobs.by_start_time_range(@base_time + 1 ... @base_time + 3600 * 2)
       jobs.length.should eql 1
-      jobs = @jobs.by_start_time_range(Time.at(0), Time.at(3))
+      jobs = @jobs.by_start_time_range(Time.at(0) ... Time.at(3))
       jobs.length.should eql 0
     end
     
     it "correctly filters by end time" do
-      jobs = @jobs.by_end_time_range(@base_time, @base_time + 3600 * 2 + 1)
+      jobs = @jobs.by_end_time_range(@base_time ... @base_time + 3600 * 2 + 1)
       jobs.length.should eql 2
-      jobs = @jobs.by_end_time_range(@base_time + 1, @base_time + 3600 * 2)
+      jobs = @jobs.by_end_time_range(@base_time + 1 ... @base_time + 3600 * 2)
       jobs.length.should eql 1
-      jobs = @jobs.by_end_time_range(Time.at(0), Time.at(3))
+      jobs = @jobs.by_end_time_range(Time.at(0) ... Time.at(3))
       jobs.length.should eql 0
     end
     
-    it "correctly filters by inclusive time range" do
-      jobs = @jobs.by_time_range_inclusive(@base_time, @base_time + 3600 * 2 + 1)
-      jobs.length.should eql 3
-      jobs = @jobs.by_time_range_inclusive(@base_time + 1, @base_time + 3600 * 2 - 1)
-      jobs.length.should eql 2
-      jobs = @jobs.by_time_range_inclusive(Time.at(0), Time.at(3))
-      jobs.length.should eql 0
-      expect {
-        @jobs.by_time_range_inclusive(Time.local(2012), Time.local(2012) - 1)
-      }.to raise_error('Max time must be greater than or equal to min time')
+    describe "#by_time_range_inclusive" do
+      it "correctly filters by inclusive time range" do
+        jobs = @jobs.by_time_range_inclusive(@base_time ... @base_time + 3600 * 2 + 1)
+        jobs.length.should eql 3
+        jobs = @jobs.by_time_range_inclusive(@base_time + 1 ... @base_time + 3600 * 2 - 1)
+        jobs.length.should eql 2
+        jobs = @jobs.by_time_range_inclusive(Time.at(0) ... Time.at(3))
+        jobs.length.should eql 0
+      end
+      
+      it "correctly handles inverted ranges" do
+        t = Date.new(2012).to_time
+        jobs = @jobs.by_time_range_inclusive(t ... t - 1)
+        jobs.count.should eql 0
+      end
     end
     
     it "correctly chains filters" do
       jobs = @jobs.by_user_name("test")
-      jobs = jobs.by_start_time_range(@base_time + 3600, @base_time + 3601)
+      jobs = jobs.by_start_time_range(@base_time + 3600 ... @base_time + 3601)
       jobs.length.should eql 1
       jobs[0].user.group.name.should eql "default"
     end
     
-    describe "::all_with_relations" do
+    describe "#all_with_relations" do
       it "loads all relations" do
         jobs = Bookie::Database::Job.limit(5)
         relations = {}
@@ -199,7 +235,7 @@ describe Bookie::Database do
       end
     end
     
-    describe "::summary" do
+    describe "#summary" do
       before(:all) do
         Time.expects(:now).returns(Time.local(2012) + 36000 * 4).at_least_once
         @base_time = Time.local(2012)
@@ -210,51 +246,67 @@ describe Bookie::Database do
       
       it "produces correct summary totals" do
         @summary[:all][:jobs].length.should eql @length
-        @summary[:all][:wall_time].should eql @length * 3600
         @summary[:all][:cpu_time].should eql @length * 100
         @summary[:all][:memory_time].should eql @length * 200 * 3600
-        @summary[:all][:successful].should eql 0.5
+        @summary[:all][:successful].should eql 20
         @summary[:all_constrained][:jobs].length.should eql @length
-        @summary[:all_constrained][:wall_time].should eql @length * 3600
         @summary[:all_constrained][:cpu_time].should eql @length * 100
-        @summary[:all_constrained][:successful].should eql 0.5
+        @summary[:all_constrained][:successful].should eql 20
+        @summary[:all_filtered][:jobs].length.should eql @length / 2
+        @summary[:all_filtered][:cpu_time].should eql @length * 100 / 2
+        @summary[:all_filtered][:successful].should eql 20
         clipped_jobs = @summary[:clipped][:jobs].length
         clipped_jobs.should eql 25
-        @summary[:clipped][:wall_time].should eql clipped_jobs * 3600 - 1800
         @summary[:clipped][:cpu_time].should eql clipped_jobs * 100 - 50
         @summary[:clipped][:memory_time].should eql clipped_jobs * 200 * 3600 - 100 * 3600
+        #Luckily for us, rounding down gives us the right answer. This is a bit fragile, though.
+        @summary[:clipped][:successful].should eql clipped_jobs / 2
       end
       
       it "correctly handles summaries of empty sets" do
         @summary[:empty].should eql({
             :jobs => [],
-            :wall_time => 0,
             :cpu_time => 0,
             :memory_time => 0,
-            :successful => 0.0,
+            :successful => 0,
           })
       end
       
-      it "correctly handles jobs with zero wall time" do
+      it "correctly handles summaries with zero wall time" do
         job = @jobs.order(:start_time).first
         wall_time = job.wall_time
         begin
           job.wall_time = 0
           job.save!
-          @jobs.order(:start_time).limit(1).summary[:wall_time].should eql 0
+          @jobs.order(:start_time).limit(1).summary[:cpu_time].should eql 0
         ensure
           job.wall_time = wall_time
           job.save!
         end
       end
       
-      it "validates arguments" do
-        expect {
-          @jobs.summary(Time.local(2012), nil)
-        }.to raise_error('Max time must be specified with min time')
-        expect {
-          @jobs.summary(Time.local(2012), Time.local(2012) - 1)
-        }.to raise_error('Max time must be greater than or equal to min time')
+      it "only considers finished jobs to be successful" do
+        begin
+          job = Bookie::Database::Job.create!(
+            :user => Bookie::Database::User.first,
+            :system => Bookie::Database::System.first,
+            :command_name => '',
+            :cpu_time => 100,
+            :start_time => Time.local(2013),
+            :wall_time => 3600 * 24 * 2,
+            :memory => 10000,
+            :exit_code => 0
+          )
+          @jobs.summary(job.start_time ... job.start_time + 3600 * 24)[:successful].should eql 0
+        ensure
+          job.delete if job
+        end
+      end
+    
+      
+      it "correctly handles inverted ranges" do
+        @jobs.summary(Time.now() ... Time.now() - 1).should eql @summary[:empty]
+        @jobs.summary(Time.now() .. Time.now() - 1).should eql @summary[:empty]
       end
     end
     
@@ -262,6 +314,7 @@ describe Bookie::Database do
       fields = {
         :user => Bookie::Database::User.first,
         :system => Bookie::Database::System.first,
+        :command_name => '',
         :cpu_time => 100,
         :start_time => Time.local(2012),
         :wall_time => 1000,
@@ -286,15 +339,310 @@ describe Bookie::Database do
         m.call(0)
         job.valid?.should eql true
       end
+    end
+  end
+  
+  describe Bookie::Database::JobSummary do
+  
+    describe "" do
+      before(:all) do
+        d = Date.new(2012)
+        Bookie::Database::User.all.each do |user|
+          Bookie::Database::System.all.each do |system|
+            ['vi', 'emacs'].each do |command_name|
+              (d ... d + 2).each do |date|
+                Bookie::Database::JobSummary.create!(
+                  :user => user,
+                  :system => system,
+                  :command_name => command_name,
+                  :date => date,
+                  :num_jobs => 0,
+                  :cpu_time => 0,
+                  :memory_time => 0,
+                  :successful => 0
+                )
+              end
+            end
+          end
+        end
+      end
       
-      job = Bookie::Database::Job.new(fields)
-      job.start_time = 0
-      job.valid?.should eql false
+      it "correctly filters by date" do
+        d = Date.new(2012)
+        sums = Bookie::Database::JobSummary.by_date(d).all
+        sums.length.should eql 32
+        sums.each do |sum|
+          sum.date.should eql d
+        end
+      end
+      
+      it "correctly filters by user" do
+        u = Bookie::Database::User.first
+        sums = Bookie::Database::JobSummary.by_user(u).all
+        sums.length.should eql 16
+        sums.each do |sum|
+          sum.user.should eql u
+        end
+      end
+      
+      it "correctly filters by user name" do
+        sums = Bookie::Database::JobSummary.by_user_name('test').all
+        sums.length.should eql 32
+        sums.each do |sum|
+          sum.user.name.should eql 'test'
+        end
+      end
+      
+      it "correctly filters by group" do
+        g = Bookie::Database::Group.find_by_name('admin')
+        sums = Bookie::Database::JobSummary.by_group(g).all
+        sums.length.should eql 32
+        sums.each do |sum|
+          sum.user.group.should eql g
+        end
+      end
+      
+      it "correctly filters by group name" do
+        sums = Bookie::Database::JobSummary.by_group_name('admin').all
+        sums.length.should eql 32
+        sums.each do |sum|
+          sum.user.group.name.should eql 'admin'
+        end
+      end
+      
+      it "correctly filters by system" do
+        s = Bookie::Database::System.first
+        sums = Bookie::Database::JobSummary.by_system(s).all
+        sums.length.should eql 16
+        sums.each do |sum|
+          sum.system.should eql s
+        end
+      end
+      
+      it "correctly filters by system name" do
+        sums = Bookie::Database::JobSummary.by_system_name('test1').all
+        sums.length.should eql 32
+        sums.each do |sum|
+          sum.system.name.should eql 'test1'
+        end
+      end
+      
+      it "correctly filters by system type" do
+        s = Bookie::Database::SystemType.first
+        sums = Bookie::Database::JobSummary.by_system_type(s).all
+        sums.length.should eql 32
+        sums.each do |sum|
+          sum.system.system_type.should eql s
+        end
+      end
+      
+      it "correctly filters by command name" do
+        sums = Bookie::Database::JobSummary.by_command_name('vi').all
+        sums.length.should eql 32
+        sums.each do |sum|
+          sum.command_name.should eql 'vi'
+        end
+      end
+    end
+    
+    describe "#find_or_new" do
+      it "creates a summary if needed" do
+        Bookie::Database::JobSummary.delete_all
+        s = Bookie::Database::JobSummary.find_or_new(Date.new(2012), 1, 1, 'vi')
+        s.persisted?.should eql false
+        s.num_jobs = 0
+        s.cpu_time = 0
+        s.memory_time = 0
+        s.successful = 0
+        s.save!
+      end
+      
+      it "uses the old summary if present" do
+        s = Bookie::Database::JobSummary.find_or_new(Date.new(2012), 1, 1, 'vi')
+        s.persisted?.should eql true
+      end
+    end
+    
+    describe "#summarize" do
+      before(:each) do
+        Bookie::Database::JobSummary.delete_all
+      end
+      
+      it "produces correct summaries" do
+        d = Date.new(2012)
+        range = d.to_time ... (d + 1).to_time
+        Bookie::Database::JobSummary.summarize(d)
+        sums = Bookie::Database::JobSummary.all
+        found_sums = Set.new
+        sums.each do |sum|
+          sum.date.should eql Date.new(2012)
+          jobs = Bookie::Database::Job.by_user(sum.user).by_system(sum.system).by_command_name(sum.command_name)
+          sum_2 = jobs.summary(range)
+          check_job_sums(sum, sum_2)
+          found_sums.add([sum.user.id, sum.system.id, sum.command_name])
+        end
+        #Is it producing all of the values needed?
+        Bookie::Database::Job.by_time_range_inclusive(range).select('user_id, system_id, command_name').uniq.all.each do |values|
+          values = [values.user_id, values.system_id, values.command_name]
+          found_sums.include?(values).should eql true
+        end
+      end
+    end
+  
+    describe "#summary" do
+      before(:each) do
+        Bookie::Database::JobSummary.delete_all
+        t = (Date.new(2012) + 3).to_time
+        Time.expects(:now).at_least(0).returns(t)
+      end
+      
+      #To do: test inclusive ranges?
+      it "produces correct summaries" do
+        #To consider: flesh out some more?
+        date_start = Date.new(2012)
+        date_end = date_start
+        date_bound = date_start + 3
+        while date_start < date_bound
+          while date_end < date_bound
+            range = date_start ... date_end
+            time_range = date_start.to_time ... date_end.to_time
+            sum1 = Bookie::Database::JobSummary.summary(:range => range)
+            sum2 = Bookie::Database::Job.summary(time_range)
+            check_job_sums(sum1, sum2)
+            Bookie::Database::JobSummary.summary(:range => time_range).should eql sum1
+            date_end += 1
+          end
+          date_start += 1
+        end
+        date_start = Date.new(2012)
+        time_start = date_start.to_time
+        time_end = (date_start + 1).to_time
+        [0, -7200, 7200].each do |offset_begin|
+          [0, -7200, 7200].each do |offset_end|
+            range_offset = time_start + offset_end ... time_end + offset_end
+            sum1 = Bookie::Database::JobSummary.summary(:range => range_offset)
+            sum2 = Bookie::Database::Job.summary(range_offset)
+            check_job_sums(sum1, sum2)
+          end
+        end
+      end
+      
+      def check_time_bounds
+        date_min = Date.new(2012)
+        date_max = date_min + 1
+        check_job_sums(Bookie::Database::JobSummary.summary, Bookie::Database::Job.summary)
+        Bookie::Database::JobSummary.order(:date).first.date.should eql date_min
+        Bookie::Database::JobSummary.order('date DESC').first.date.should eql date_max
+      end
+      
+      it "correctly finds the default time bounds" do
+        check_time_bounds
+        systems = Bookie::Database::System.active_systems
+        Bookie::Database::JobSummary.delete_all
+        #Check the case where all systems are decommissioned.
+        begin
+          systems.each do |sys|
+            sys.end_time = Time.now
+            sys.save!
+          end
+          check_time_bounds
+        ensure
+          systems.each do |sys|
+            sys.end_time = nil
+            sys.save!
+          end
+        end
+        Bookie::Database::JobSummary.delete_all
+        empty = Bookie::Database::System.limit(0)
+        #Check the case where there are no systems.
+        ActiveRecord::Relation.any_instance.expects(:'any?').at_least_once.returns(false)
+        ActiveRecord::Relation.any_instance.expects(:first).at_least_once.returns(nil)
+        sum = Bookie::Database::JobSummary.summary
+        sum.should eql({
+          :num_jobs => 0,
+          :cpu_time => 0,
+          :memory_time => 0,
+          :successful => 0,
+        })
+        ActiveRecord::Relation.any_instance.unstub(:'any?')
+        Bookie::Database::JobSummary.any?.should eql false
+      end
+      
+      it "correctly handles filtered summaries" do
+        filters = {
+          :user_name => 'blm',
+          :group_name => 'blm',
+          :command_name => 'vi',
+        }
+        filters.each do |filter, value|
+          filter_sym = "by_#{filter}".intern
+          jobs = Bookie::Database::Job.send(filter_sym, value)
+          sum1 = Bookie::Database::JobSummary.send(filter_sym, value).summary(:jobs => jobs)
+          sum2 = jobs.summary
+          check_job_sums(sum1, sum2)
+        end
+      end
+      
+      it "correctly handles inverted ranges" do
+        t = Date.new(2012).to_time
+        Bookie::Database::JobSummary.summary(:range => t .. t - 1).should eql({
+          :num_jobs => 0,
+          :cpu_time => 0,
+          :memory_time => 0,
+          :successful => 0,
+        })
+      end
+      
+      it "caches summaries" do
+        Bookie::Database::JobSummary.summary
+        Bookie::Database::Job.expects(:summary).never
+        range = Date.new(2012) ... Date.new(2012) + 1
+        Bookie::Database::JobSummary.summary(:range => range)
+      end
+    end
+    
+    it "validates fields" do
+      fields = {
+        :user => Bookie::Database::User.first,
+        :system => Bookie::Database::System.first,
+        :command_name => '',
+        :date => Date.new(2012),
+        :num_jobs => 1,
+        :cpu_time => 100,
+        :memory_time => 1000000,
+        :successful => 1,
+      }
+      
+      sum = Bookie::Database::JobSummary.new(fields)
+      sum.valid?.should eql true
+      
+      fields.each_key do |field|
+        job = Bookie::Database::JobSummary.new(fields)
+        job.method("#{field}=".intern).call(nil)
+        job.valid?.should eql false
+      end
+      
+      [:cpu_time, :memory_time, :successful].each do |field|
+        job = Bookie::Database::JobSummary.new(fields)
+        m = job.method("#{field}=".intern)
+        m.call(-1)
+        job.valid?.should eql false
+        m.call(0)
+        job.valid?.should eql true
+      end
     end
   end
   
   describe Bookie::Database::User do
-    describe "::find_or_create" do
+    it "correctly filters by name" do
+      users = Bookie::Database::User.by_name('test').all
+      users.length.should eql 2
+      users.each do |user|
+        user.name.should eql 'test'
+      end
+    end
+    
+    describe "#find_or_create" do
       before(:each) do
         @group = Bookie::Database::Group.find_by_name('admin')
       end
@@ -343,7 +691,7 @@ describe Bookie::Database do
   end
   
   describe Bookie::Database::Group do
-    describe "::find_or_create" do
+    describe "#find_or_create" do
       it "creates the group if needed" do
         Bookie::Database::Group.expects(:"create!")
         Bookie::Database::Group.find_or_create!('non_root')
@@ -394,13 +742,13 @@ describe Bookie::Database do
       end
     end
     
-    describe "::summary" do
+    describe "#summary" do
       before(:all) do
         Time.expects(:now).returns(Time.local(2012) + 3600 * 40).at_least_once
         @base_time = Time.local(2012)
         @systems = Bookie::Database::System
         @summary = Helpers::create_summaries(@systems, Time.local(2012))
-        @summary_wide = @systems.summary(Time.local(2012) - 3600, Time.local(2012) + 3600 * 40 + 3600)
+        @summary_wide = @systems.summary(Time.local(2012) - 3600 ... Time.local(2012) + 3600 * 40 + 3600)
       end
       
       it "produces correct summaries" do
@@ -437,7 +785,7 @@ describe Bookie::Database do
           end
           summary_all_systems_ended = @systems.summary()
           summary_all_systems_ended.should eql @summary[:all]
-          summary_all_systems_ended = @systems.summary(Time.local(2012), Time.now + 3600)
+          summary_all_systems_ended = @systems.summary(Time.local(2012) ... Time.now + 3600)
           s2 = @summary[:all].dup
           s2[:avail_memory_avg] = Float(1000000 * system_total_wall_time) / (3600 * 41)
           summary_all_systems_ended.should eql s2
@@ -451,60 +799,63 @@ describe Bookie::Database do
         end
       end
       
-      it "validates arguments" do
-        expect {
-          @systems.summary(Time.local(2012), nil)
-        }.to raise_error('Max time must be specified with min time')
-        expect {
-          @systems.summary(Time.local(2012), Time.local(2012) - 1)
-        }.to raise_error('Max time must be greater than or equal to min time')
+      it "correctly handles inverted ranges" do
+        t = Date.new(2012).to_time
+        @systems.summary(t ... t - 1).should eql @summary[:empty]
+        @systems.summary(t .. t - 1).should eql @summary[:empty]
       end
     end
 
-    describe "::find_active" do
+    describe "#find_current" do
       before(:all) do
-        @FIELDS = {
-          :name => 'test',
-          :start_time => Time.local(2012),
-          :system_type => Bookie::Database::SystemType.first,
-          :cores => 2,
-          :memory => 1000000
-        }
+        @config_t1 = @config.clone
+        
+        @config_t1.hostname = 'test1'
+        @config_t1.system_type = 'standalone'
+        @config_t1.cores = 2
+        @config_t1.memory = 1000000
+        
+        @config_t2 = @config_t1.clone
+        @config_t2.system_type = 'torque_cluster'
+        
+        @sender_1 = Bookie::Sender.new(@config_t1)
+        @sender_2 = Bookie::Sender.new(@config_t2)
       end
-      
-      it "raises an error if no versions or only old versions of this system exist" do
-        create_fields = @FIELDS.dup
-        create_fields[:end_time] = Time.local(2012) + 1
-        sys = Bookie::Database::System.create!(create_fields)
-        begin
-          expect {
-            Bookie::Database::System.find_active(@FIELDS)
-          }.to raise_error("There is no active system with hostname 'test' in the database.")
-        ensure
-          sys.delete
-        end
+
+      it "finds the correct system" do
+        Bookie::Database::System.find_current(@sender_2).id.should eql 2
+        Bookie::Database::System.find_current(@sender_2, Time.now).id.should eql 2
+        Bookie::Database::System.find_current(@sender_1, Date.new(2012, 1, 1).to_time).id.should eql 1
       end
-  
-      it "finds the existing active system" do
-        sys = Bookie::Database::System.create!(@FIELDS)
-        begin
-          Bookie::Database::System.find_active(@FIELDS).should eql sys
-        ensure
-          sys.delete
-        end
+      
+      it "correctly detects the lack of a matching system" do
+        expect {
+          Bookie::Database::System.find_current(@sender_1, Date.new(2011, 1, 1).to_time)
+        }.to raise_error(/^There is no system with hostname 'test1' in the database at /)
+        @config_t1.expects(:hostname).at_least_once.returns('test1000')
+        expect {
+          Bookie::Database::System.find_current(@sender_1, Date.new(2012, 1, 1).to_time)
+        }.to raise_error(/^There is no system with hostname 'test1000' in the database at /)
       end
       
       it "correctly detects conflicts" do
-        fields = @FIELDS.dup
-        fields[:cores] = 1
-        csys = Bookie::Database::System.create!(fields)
-        begin
+        config = @config.clone
+        config.hostname = 'test1'
+        config.cores = 2
+        config.memory = 1000000
+
+        sender = Bookie::Sender.new(config)
+        [:cores, :memory].each do |field|
+          config.expects(field).at_least_once.returns("value")
           expect {
-            Bookie::Database::System.find_active(@FIELDS)
+            Bookie::Database::System.find_current(sender)
           }.to raise_error(Bookie::Database::System::SystemConflictError)
-        ensure
-          csys.delete
+          config.unstub(field)
         end
+        sender.expects(:system_type).returns(Bookie::Database::SystemType.find_by_name("Standalone"))
+        expect {
+          Bookie::Database::System.find_current(sender)
+        }.to raise_error(Bookie::Database::System::SystemConflictError)
       end
     end
 
@@ -549,10 +900,6 @@ describe Bookie::Database do
         system.valid?.should eql true
       end
       
-      system = Bookie::Database::System.new(fields)
-      system.start_time = 0
-      system.valid?.should eql false
-      
       system = Bookie::Database::System.new(fields)
       system.end_time = Time.local(2012)
       system.valid?.should eql true