marty 2.5.2 → 2.5.4

data/spec/models/event_spec.rb

@@ -16,27 +16,27 @@ describe Marty::Event do
 
     Marty::Script.load_script_bodies(promise_bodies, Date.today)
     start_delayed_job
-    Marty::Config["MARTY_EVENT_POLL_SECS"] = 1
+    Marty::Config['MARTY_EVENT_POLL_SECS'] = 1
 
     @time = Time.zone.now
     @date_string = @time.strftime('%Y-%m-%d')
     @old_start = '1970-01-01 08:00:00'
     @old_end = '1970-01-01 09:00:00'
     # add events
-    [['testcl1',  123, @time, nil,            nil,     'AVM',     'a comment',
-      nil],
-     ['testcl1',  123, @time + 2.second, nil,nil,     'CRA',     'b comment',
-      nil],
-     ['testcl1',  123, @time + 4.seconds, nil,10000,     'PRICING', 'c comment',
-      nil],
-     ['testcl1',  234, @time - 5.seconds, @time, nil,    'PRICING', 'c comment',
-      false],
-     ['testcl2', 123, @time, nil,             2, 'AVM',     'e comment', nil],
-     ['testcl2', 123, @time + 1.second, nil,  4, 'CRA',     'f comment', nil],
-     ['testcl2', 123, Time.zone.parse(@old_start),
-      Time.zone.parse(@old_end), nil, 'PRICING', 'old event', 0],
-    ].each do
-      |klass, subjid, startdt, enddt, expire, op, comment, error|
+    [
+      ['testcl1',  123, @time, nil,            nil,     'AVM',     'a comment',
+       nil],
+      ['testcl1',  123, @time + 2.second, nil, nil,     'CRA',     'b comment',
+       nil],
+      ['testcl1',  123, @time + 4.seconds, nil, 10000,     'PRICING', 'c comment',
+       nil],
+      ['testcl1',  234, @time - 5.seconds, @time, nil,    'PRICING', 'c comment',
+       false],
+      ['testcl2', 123, @time, nil,             2, 'AVM',     'e comment', nil],
+      ['testcl2', 123, @time + 1.second, nil,  4, 'CRA',     'f comment', nil],
+      ['testcl2', 123, Time.zone.parse(@old_start),
+       Time.zone.parse(@old_end), nil, 'PRICING', 'old event', 0]
+    ].each do |klass, subjid, startdt, enddt, expire, op, comment, error|
       Marty::Event.create!(klass: klass,
                            subject_id: subjid,
                            start_dt: startdt,
@@ -47,18 +47,17 @@ describe Marty::Event do
                            error: error)
     end
 
-
     engine = Marty::ScriptSet.new.get_engine(NAME_I)
-    res = engine.background_eval("SLEEPER", {"secs" => 5}, ["a"],
-                                 {klass: "testcl3",
-                                  id: 987,
-                                  operation: 'PRICING'})
+    res = engine.background_eval('SLEEPER', { 'secs' => 5 }, ['a'],
+                                 klass: 'testcl3',
+                                 id: 987,
+                                 operation: 'PRICING')
     res.force
     engine = Marty::ScriptSet.new.get_engine(NAME_J)
-    res = engine.background_eval("FAILER", {"dummy" => "dummy"}, ["a"],
-                                 {klass: "testcl3",
-                                  id: 654,
-                                  operation: 'PRICING'})
+    res = engine.background_eval('FAILER', { 'dummy' => 'dummy' }, ['a'],
+                                 klass: 'testcl3',
+                                 id: 654,
+                                 operation: 'PRICING')
     res.force rescue nil
     sleep 5
     save_clean_db(@save_file)
@@ -75,53 +74,51 @@ describe Marty::Event do
     Marty::Event.clear_cache
   end
 
-
-  it "reports currently running" do
+  it 'reports currently running' do
     expect(Marty::Event.currently_running('testcl1', 123)).
       to eq(['AVM', 'CRA', 'PRICING'])
     expect(Marty::Event.currently_running('testcl2', 123)).to eq([])
     expect(Marty::Event.currently_running('testcl3', 987)).to eq([])
     expect(Marty::Event.last_event('testcl1', 123)).
       to include(
-           {"klass"=>"testcl1",
-            "subject_id"=>123,
-            "enum_event_operation"=>"PRICING",
-            "comment"=>"c comment", "expire_secs"=>10000})
+        'klass' => 'testcl1',
+        'subject_id' => 123,
+        'enum_event_operation' => 'PRICING',
+        'comment' => 'c comment', 'expire_secs' => 10000)
     expect(Marty::Event.last_event('testcl2', 123)).
       to include(
-           {"klass"=>"testcl2",
-            "subject_id"=>123,
-            "enum_event_operation"=>"PRICING",
-            "comment"=>"old event"})
+        'klass' => 'testcl2',
+        'subject_id' => 123,
+        'enum_event_operation' => 'PRICING',
+        'comment' => 'old event')
     expect(Marty::Event.last_event('testcl3', 987)).
       to include(
-           {"klass"=>"testcl3",
-            "subject_id"=>987,
-            "enum_event_operation"=>"PRICING",
-            "comment"=>nil,
-            "expire_secs"=>nil})
+        'klass' => 'testcl3',
+        'subject_id' => 987,
+        'enum_event_operation' => 'PRICING',
+        'comment' => nil,
+        'expire_secs' => nil)
 
-    Timecop.freeze(@time+1.second)
+    Timecop.freeze(@time + 1.second)
     Marty::Event.clear_cache
     expect(Marty::Event.currently_running('testcl1', 123)).
       to eq(['AVM', 'CRA', 'PRICING'])
     expect(Marty::Event.currently_running('testcl2', 123)).to eq(['AVM', 'CRA'])
 
-    Timecop.freeze(@time+3.seconds)
+    Timecop.freeze(@time + 3.seconds)
     Marty::Event.clear_cache
     expect(Marty::Event.currently_running('testcl1', 123)).
       to eq(['AVM', 'CRA', 'PRICING'])
     expect(Marty::Event.currently_running('testcl2', 123)).to eq(['CRA'])
 
-    Timecop.freeze(@time+6.seconds)
+    Timecop.freeze(@time + 6.seconds)
     expect(Marty::Event.currently_running('testcl1', 123)).
       to eq(['AVM', 'CRA', 'PRICING'])
     expect(Marty::Event.currently_running('testcl2', 123)).to eq([])
     Timecop.return
-
   end
 
-  it "misc API tests" do
+  it 'misc API tests' do
     ev1 = Marty::Event.where(klass: 'testcl3', subject_id: 987).first
     ev2 = Marty::Event.where(klass: 'testcl3', subject_id: 654).first
     af = Marty::Event.all_finished
@@ -160,39 +157,39 @@ describe Marty::Event do
     expect(Marty::Event.currently_running('testcl1', 123)).
       to eq(['CRA', 'PRICING'])
     expect(Marty::Event.currently_running_multi('testcl1', [123])).
-      to eq({123 => ['CRA', 'PRICING']})
+      to eq(123 => ['CRA', 'PRICING'])
 
     expect(Marty::Event.op_is_running?('testcl1', 123, 'AVM')).to be_falsey
     expect(Marty::Event.op_is_running?('testcl1', 123, 'CRA')).to be_truthy
 
     ev = Marty::Event.lookup_event('testcl1', 123, 'AVM')
     expect(ev.length).to eq(1)
-    expect(ev.first).to include({"klass"=>"testcl1",
-                                 "subject_id"=>123,
-                                 "enum_event_operation"=>"AVM",
-                                 "comment"=>"wassup",
-                                 "expire_secs"=>nil,
-                                 "error"=> false})
-    Marty::Event.update_comment(ev.first, "updated")
+    expect(ev.first).to include('klass' => 'testcl1',
+                                 'subject_id' => 123,
+                                 'enum_event_operation' => 'AVM',
+                                 'comment' => 'wassup',
+                                 'expire_secs' => nil,
+                                 'error' => false)
+    Marty::Event.update_comment(ev.first, 'updated')
     ev = Marty::Event.lookup_event('testcl1', 123, 'AVM')
-    expect(ev.first).to include({"comment"=>"updated"})
+    expect(ev.first).to include('comment' => 'updated')
     expect(Marty::Event.compact_end_dt(ev.first)).to match(/\d\d:\d\d/)
     expect(Marty::Event.pretty_op(ev.first)).to eq('Avm')
     ev = Marty::Event.lookup_event('testcl1', 123, 'PRICING').first
     expect(Marty::Event.pretty_op(ev)).to eq('Pricing')
     evs = Marty::Event.last_event_multi('testcl1', [123, 234])
-    expect(evs[123]).to include({"klass"=>"testcl1",
-                                 "subject_id"=>123,
-                                 "enum_event_operation"=>"CRA",
-                                 "comment"=>"b comment",
-                                 "expire_secs"=>nil,
-                                 "error"=>nil})
-    expect(evs[234]).to include({"klass"=>"testcl1",
-                                 "subject_id"=>234,
-                                 "enum_event_operation"=>"PRICING",
-                                 "comment"=>"c comment",
-                                 "expire_secs"=>nil,
-                                 "error"=>false})
+    expect(evs[123]).to include('klass' => 'testcl1',
+                                 'subject_id' => 123,
+                                 'enum_event_operation' => 'CRA',
+                                 'comment' => 'b comment',
+                                 'expire_secs' => nil,
+                                 'error' => nil)
+    expect(evs[234]).to include('klass' => 'testcl1',
+                                 'subject_id' => 234,
+                                 'enum_event_operation' => 'PRICING',
+                                 'comment' => 'c comment',
+                                 'expire_secs' => nil,
+                                 'error' => false)
 
     af = Marty::Event.all_finished
     expect(af.count).to eq(4)
@@ -201,29 +198,41 @@ describe Marty::Event do
     expect(af[['testcl1', 123]]['AVM']).to start_with(@date_string)
   end
 
-  it "raises on error" do
-    expect {Marty::Event.create_event('testcl', 1234, 'AVM', Time.zone.now, 600,
-                                      "the comment") }.not_to raise_error
+  it 'raises on error' do
+    expect do
+      Marty::Event.create_event('testcl', 1234, 'AVM', Time.zone.now, 600,
+                                'the comment')
+    end    .not_to raise_error
 
-    expect {Marty::Event.create_event('testcl', 1234, 'AVM', Time.zone.now, 600,
-                                      "the comment") }.
+    expect do
+      Marty::Event.create_event('testcl', 1234, 'AVM', Time.zone.now, 600,
+                                'the comment')
+    end.
       to raise_error(%r!AVM is already running for testcl/1234!)
-    expect {Marty::Event.create_event('testcl', 2345, 'AVM', Time.zone.now, 600,
-                                      "the comment") }.not_to raise_error
-    expect {Marty::Event.finish_event('testcl', 1234, 'AVM', false,
-                                      "new comment") }.
+    expect do
+      Marty::Event.create_event('testcl', 2345, 'AVM', Time.zone.now, 600,
+                                'the comment')
+    end    .not_to raise_error
+    expect do
+      Marty::Event.finish_event('testcl', 1234, 'AVM', false,
+                                'new comment')
+    end.
       not_to raise_error
-    expect {Marty::Event.finish_event('testcl', 1234, 'AVM', false,
-                                      "new comment") }.
+    expect do
+      Marty::Event.finish_event('testcl', 1234, 'AVM', false,
+                                'new comment')
+    end.
       to raise_error(%r!event testcl/1234/AVM not found!)
-    expect {Marty::Event.finish_event('testcl', 2345, 'AVM', false, 'foobar') }.
+    expect { Marty::Event.finish_event('testcl', 2345, 'AVM', false, 'foobar') }.
       not_to raise_error
-    expect {Marty::Event.finish_event('testcl', 2345, 'AVM', false, 'foobar') }.
+    expect { Marty::Event.finish_event('testcl', 2345, 'AVM', false, 'foobar') }.
       to raise_error(%r!event testcl/2345/AVM not found!)
-    expect {Marty::Event.finish_event('testcl', 2345, 'AVM', nil, 'foobar') }.
+    expect { Marty::Event.finish_event('testcl', 2345, 'AVM', nil, 'foobar') }.
       to raise_error(/error must be true or false/)
-    expect {Marty::Event.create_event('testcl', 1234, 'AMV', Time.zone.now, 600,
-                                      "the comment") }.
+    expect do
+      Marty::Event.create_event('testcl', 1234, 'AMV', Time.zone.now, 600,
+                                'the comment')
+    end.
       to raise_error(%r!PG::.*invalid input value for enum.*"AMV"!)
     Marty::Event.clear_cache
     af = Marty::Event.all_finished
@@ -236,8 +245,8 @@ describe Marty::Event do
     expect(af[['testcl', 2345]]['AVM']).to start_with(@date_string)
   end
 
-  it "truncates long comment" do
-    long_comment = "comment string abcdefg"*100
+  it 'truncates long comment' do
+    long_comment = 'comment string abcdefg' * 100
     long_comment_truncated = long_comment.truncate(255)
     Marty::Event.create_event('testcl', 123, 'PRICING', Time.zone.now, 600,
                               long_comment)
@@ -249,16 +258,15 @@ describe Marty::Event do
                          comment: long_comment)
 
     Marty::Event.create_event('testcl', 789, 'AVM', Time.zone.now, 600,
-                              "comment")
+                              'comment')
     Marty::Event.finish_event('testcl', 789, 'AVM', false, long_comment)
 
     e1 = Marty::Event.lookup_event('testcl', 123, 'PRICING').first
     e2 = Marty::Event.lookup_event('testcl', 456, 'CRA').first
     e3 = Marty::Event.lookup_event('testcl', 789, 'AVM').first
 
-    expect(e1["comment"]).to eq(long_comment_truncated)
-    expect(e2["comment"]).to eq(long_comment_truncated)
-    expect(e3["comment"]).to eq(long_comment_truncated)
-
+    expect(e1['comment']).to eq(long_comment_truncated)
+    expect(e2['comment']).to eq(long_comment_truncated)
+    expect(e3['comment']).to eq(long_comment_truncated)
   end
 end

data/spec/models/import_type_spec.rb

@@ -17,14 +17,14 @@ module Marty
 
     before(:each) do
       @import = ImportType.new
-      @import.name = "Test1"
-      @import.db_model_name = "Marty::ARTestModel"
+      @import.name = 'Test1'
+      @import.db_model_name = 'Marty::ARTestModel'
       @import.role_id = role_id
       @import.save!
     end
 
-    describe "validations" do
-      it "require name, db_model and role" do
+    describe 'validations' do
+      it 'require name, db_model and role' do
         it = ImportType.new
         expect(it).to_not be_valid
         expect(it.errors[:name].any?).to be true
@@ -32,28 +32,28 @@ module Marty
         expect(it.errors[:role_id].any?).to be true
       end
 
-      it "require a unique name" do
+      it 'require a unique name' do
         it = ImportType.new
-        it.name = "Test1"
-        it.db_model_name = "Marty::ARTestModel"
+        it.name = 'Test1'
+        it.db_model_name = 'Marty::ARTestModel'
         it.role_id = role_id
         expect(it).to_not be_valid
         expect(it.errors[:name].any?).to be true
       end
 
-      it "require an ActiveRecord model for the db_model_name" do
+      it 'require an ActiveRecord model for the db_model_name' do
         it = ImportType.new
-        it.name = "Test1"
-        it.db_model_name = "Marty::TestModel"
+        it.name = 'Test1'
+        it.db_model_name = 'Marty::TestModel'
         it.role_id = role_id
         expect(it).to_not be_valid
-        expect(it.errors[:base][0]).to eq "bad model name"
+        expect(it.errors[:base][0]).to eq 'bad model name'
       end
 
-      it "do not fail on blank strings for functions" do
-        @import.cleaner_function = ""
-        @import.validation_function = " "
-        @import.preprocess_function = "  "
+      it 'do not fail on blank strings for functions' do
+        @import.cleaner_function = ''
+        @import.validation_function = ' '
+        @import.preprocess_function = '  '
 
         expect(@import).to be_valid
         @import.save!
@@ -62,15 +62,15 @@ module Marty
         expect(@import.preprocess_function).to be nil
       end
 
-      it "require valid functions for cleaner/validation/preprocess" do
-        @import.cleaner_function = "import_cleaner"
-        @import.validation_function = "import_validator"
+      it 'require valid functions for cleaner/validation/preprocess' do
+        @import.cleaner_function = 'import_cleaner'
+        @import.validation_function = 'import_validator'
         expect(@import).to be_valid
 
-        @import.preprocess_function = "missing_func"
+        @import.preprocess_function = 'missing_func'
         expect(@import).to_not be_valid
         expect(@import.errors[:base][0]).
-          to eq "unknown class method missing_func"
+          to eq 'unknown class method missing_func'
       end
     end
   end

data/spec/models/posting_spec.rb

@@ -2,36 +2,36 @@ require 'spec_helper'
 
 module Marty
   describe Posting do
-    describe "validations" do
-      it "requires unique names" do
-        dt = "20130215 0800"
+    describe 'validations' do
+      it 'requires unique names' do
+        dt = '20130215 0800'
         c = Posting.count
-        Posting.do_create("BASE", dt, 'a comment')
+        Posting.do_create('BASE', dt, 'a comment')
         Posting.count.should == c + 1
-        expect { s = Posting.do_create("BASE", dt, 'a comment') }.
+        expect { s = Posting.do_create('BASE', dt, 'a comment') }.
           to raise_error(ActiveRecord::RecordInvalid)
       end
 
-      it "creates name based on PDT" do
-        d, t, tz = "20130215", "0900", "PST8PDT"
+      it 'creates name based on PDT' do
+        d, t, tz = '20130215', '0900', 'PST8PDT'
         dt_tz = [d, t, tz].join(' ')
-        p = Posting.do_create("BASE", dt_tz, 'a comment')
+        p = Posting.do_create('BASE', dt_tz, 'a comment')
         expect(p.name).to match /BASE-#{d}-#{t}/
         p.reload
         expect(p.created_dt).to eq Time.zone.parse(dt_tz)
       end
     end
 
-    describe "lookups" do
-      it "are seeded with a NOW posting" do
-        expect(Posting.lookup_dt("NOW")).to eq Float::INFINITY
+    describe 'lookups' do
+      it 'are seeded with a NOW posting' do
+        expect(Posting.lookup_dt('NOW')).to eq Float::INFINITY
       end
 
-      describe ".get_latest" do
-        it "provide a list of latest of postings in descending order" do
-          4.times { |d|
-            Posting.do_create("BASE", d.day.from_now, 'a comment')
-          }
+      describe '.get_latest' do
+        it 'provide a list of latest of postings in descending order' do
+          4.times do |d|
+            Posting.do_create('BASE', d.day.from_now, 'a comment')
+          end
           dt3 = 3.day.from_now
 
           latest = Posting.get_latest(1)
@@ -40,32 +40,32 @@ module Marty
         end
       end
 
-      describe ".get_latest_by_type" do
-        context "when invalid parameters are supplied" do
+      describe '.get_latest_by_type' do
+        context 'when invalid parameters are supplied' do
           it "raises 'posting type list missing' error" do
             expect { Posting.get_latest_by_type(10, nil) }.
-              to raise_error "missing posting types list"
+              to raise_error 'missing posting types list'
           end
 
           it "raises 'bad posting types list' error" do
             expect { Posting.get_latest_by_type(10, 'BASE') }.
-              to raise_error "bad posting types list"
+              to raise_error 'bad posting types list'
           end
         end
 
-        context "when valid parameters are supplied" do
+        context 'when valid parameters are supplied' do
           before do
-            PostingType.create({name: 'SNAPSHOT'})
-            PostingType.create({name: 'OTHER'})
-            Posting.do_create("BASE",     0.day.from_now, 'base posting')
-            Posting.do_create("SNAPSHOT", 1.day.from_now, 'snapshot1 posting')
-            Posting.do_create("SNAPSHOT", 2.day.from_now, 'snapshot2 posting')
-            Posting.do_create("OTHER"   , 3.day.from_now, 'other1 posting')
-            Posting.do_create("SNAPSHOT", 4.day.from_now, 'snapshot3 posting')
-            Posting.do_create("OTHER"   , 5.day.from_now, 'other2 posting')
+            PostingType.create(name: 'SNAPSHOT')
+            PostingType.create(name: 'OTHER')
+            Posting.do_create('BASE',     0.day.from_now, 'base posting')
+            Posting.do_create('SNAPSHOT', 1.day.from_now, 'snapshot1 posting')
+            Posting.do_create('SNAPSHOT', 2.day.from_now, 'snapshot2 posting')
+            Posting.do_create('OTHER', 3.day.from_now, 'other1 posting')
+            Posting.do_create('SNAPSHOT', 4.day.from_now, 'snapshot3 posting')
+            Posting.do_create('OTHER', 5.day.from_now, 'other2 posting')
           end
 
-          it "filters on a single posting type" do
+          it 'filters on a single posting type' do
             # First param is just the limit (max) to return
             res = Posting.get_latest_by_type(10, ['BASE'])
             expect(res.count).to eq 1
@@ -73,7 +73,7 @@ module Marty
             expect(r0.comment).to eq 'base posting'
           end
 
-          it "filters on multiple posting types" do
+          it 'filters on multiple posting types' do
             res = Posting.get_latest_by_type(10, ['BASE', 'SNAPSHOT'])
             expect(res.count).to eq 4
             # snapshot3 is most recent with this filter
@@ -83,8 +83,8 @@ module Marty
             expect(r3.comment).to eq 'base posting'
           end
 
-          it "filters on posting types that are single or double quoted" do
-            res = Posting.get_latest_by_type(10, ['SNAPSHOT', "OTHER"])
+          it 'filters on posting types that are single or double quoted' do
+            res = Posting.get_latest_by_type(10, ['SNAPSHOT', 'OTHER'])
             expect(res.count).to eq 5
             # other2 is most recent with this filter
             r0 = Posting.find_by_name(res[0]['name'])
@@ -93,7 +93,7 @@ module Marty
             expect(r4.comment).to eq 'snapshot1 posting'
           end
 
-          it "filters and limits on multiple posting types" do
+          it 'filters and limits on multiple posting types' do
             res = Posting.get_latest_by_type(3, ['SNAPSHOT', 'OTHER'])
             expect(res.count).to eq 3
             # other2 is most recent with this filter
@@ -103,7 +103,7 @@ module Marty
             expect(r2.comment).to eq 'other1 posting'
           end
 
-          it "returns nothing with an empty posting type list" do
+          it 'returns nothing with an empty posting type list' do
             res = Posting.get_latest_by_type(10, [])
             expect(res.count).to eq 0
           end