marty 2.5.2 → 2.5.4

data/spec/lib/logger_spec.rb

@@ -14,7 +14,7 @@ module Marty
       self.use_transactional_tests = true
     end
 
-    it "log has its own connection" do
+    it 'log has its own connection' do
       log_conn     = Marty::Log.connection.raw_connection
       posting_conn = Marty::Posting.connection.raw_connection
       script_conn  = Marty::Script.connection.raw_connection
@@ -23,26 +23,26 @@ module Marty
       expect(posting_conn).to equal(script_conn)
     end
 
-    it "logs" do
-      info_s = {'info' => 'message'}
-      error_s = [1, 2, 3, {'error' =>'message'}]
-      fatal_s = ["string", 123, {'fatal' => "message",
-                                 'another_key' => 'value'}]
+    it 'logs' do
+      info_s = { 'info' => 'message' }
+      error_s = [1, 2, 3, { 'error' => 'message' }]
+      fatal_s = ['string', 123, { 'fatal' => 'message',
+                                 'another_key' => 'value' }]
       Marty::Logger.info('info message', info_s)
       Marty::Logger.error('error message', error_s)
       Marty::Logger.fatal('fatal message', fatal_s)
       log = Marty::Log.all
-      log_detail = log.map{|l| [l[:message_type], l[:message], l[:details]]}
-      log_ts = log.map{|l| l[:timestamp]}
-      expect(log_detail[0]).to eq(["info", "info message", info_s])
-      expect(log_detail[1]).to eq(["error", "error message", error_s])
-      expect(log_detail[2]).to eq(["fatal", "fatal message", fatal_s])
+      log_detail = log.map { |l| [l[:message_type], l[:message], l[:details]] }
+      log_ts = log.map { |l| l[:timestamp] }
+      expect(log_detail[0]).to eq(['info', 'info message', info_s])
+      expect(log_detail[1]).to eq(['error', 'error message', error_s])
+      expect(log_detail[2]).to eq(['fatal', 'fatal message', fatal_s])
       log_ts.each do |ts|
         expect(ts.to_i).to be_within(5).of(Time.zone.now.to_i)
       end
     end
 
-    it "with_logging" do
+    it 'with_logging' do
       bd = 'block description'
       the_error = 'error during my block'
       data = [1, 2, 3, Marty::User.first]
@@ -50,19 +50,19 @@ module Marty
         Marty::Logger.with_logging(bd, data) do
           raise the_error
         end
-      rescue => e
+      rescue StandardError => e
         raised = e.message
       end
       expect(raised).to eq("#{bd}: #{the_error}")
       log = Marty::Log.first
       expect(log.message_type).to eq('error')
       expect(log.message).to eq(bd)
-      expect(log.details).to eq({ "message" => the_error,
-                                  "data" => JSON.parse(data.to_json)})
+      expect(log.details).to eq('message' => the_error,
+                                  'data' => JSON.parse(data.to_json))
     end
   end
 
-  describe "Exercise" do
+  describe 'Exercise' do
     before(:all) do
       @clean_file = "/tmp/clean_#{Process.pid}.psql"
       save_clean_db(@clean_file)
@@ -81,28 +81,27 @@ module Marty
     after(:all) do
       restore_clean_db(@clean_file)
       stop_delayed_job
-      File.unlink("/tmp/logaction.txt")
+      File.unlink('/tmp/logaction.txt')
       Marty::Log.cleanup(0)
       self.use_transactional_tests = true
     end
 
-    it "handles heavy load" do
-      File.open(Rails.root.join("log/test.log")) do |f|
+    it 'handles heavy load' do
+      File.open(Rails.root.join('log/test.log')) do |f|
         f.seek(0, IO::SEEK_END)
         engine = Marty::ScriptSet.new.get_engine(NAME_K)
 
         res = (1..1000).map do |i|
-          engine.background_eval("LOGGER", {"msgid" => i}, ["result"])
+          engine.background_eval('LOGGER', { 'msgid' => i }, ['result'])
         end
 
         # wait for all the jobs to finish; collect/check their result
-        expect(res.map {|x| x["result"]}.sort).to eq (1..1000).to_a
+        expect(res.map { |x| x['result'] }.sort).to eq (1..1000).to_a
 
-        line_count = File.readlines("/tmp/logaction.txt").count
+        line_count = File.readlines('/tmp/logaction.txt').count
 
         log_count = Marty::Log.all.count
-        failed_count = f.readlines.select do
-          |l|
+        failed_count = f.readlines.select do |l|
           l == "Marty::Logger failure: database is locked\n"
         end.count
 

data/spec/lib/mcfly_model_spec.rb

@@ -1,18 +1,17 @@
-require "spec_helper"
+require 'spec_helper'
 
 module Marty
-
-entities =<<EOF
+entities = <<EOF
 name
 PLS
 EOF
-bud_cats =<<EOF
+bud_cats = <<EOF
 name
 Conv Fixed 30
 Conv Fixed 20
 EOF
 
-fannie_bup =<<EOF
+fannie_bup = <<EOF
 entity	bud_category	note_rate	buy_up	buy_down	settlement_mm	settlement_yy
 	Conv Fixed 30	2.250	4.42000	7.24000	12	2012
 	Conv Fixed 30	2.375	4.42000	7.24000	12	2012
@@ -30,7 +29,7 @@ PLS	Conv Fixed 20	2.875	5.24800	7.95900	12	2012
 PLS	Conv Fixed 20	2.875	5.24800	7.95900	11	2012
 EOF
 
-script =<<EOF
+script = <<EOF
 A:
     pt        =?
     entity    =?
@@ -48,21 +47,21 @@ A:
     a_func = Gemini::FannieBup.a_func('infinity', e_id, bc_id)
     b_func = Gemini::FannieBup.b_func('infinity', e_id, bc_id, 12)
 EOF
-errscript =<<EOF
+errscript = <<EOF
 Err:
     pt        =?
     entity    =?
     note_rate =?
     result = Gemini::FannieBup.%s(pt, entity, note_rate, 1)
 EOF
-errscript2 =<<EOF
+errscript2 = <<EOF
 Err:
     pt    =?
     e_id  =?
     bc_id =?
     result = Gemini::FannieBup.%s(pt, e_id, bc_id, nil)
 EOF
-errscript3 =<<EOF
+errscript3 = <<EOF
 Err:
     pt    =?
     e_id  =?
@@ -71,128 +70,132 @@ Err:
     result = Gemini::FannieBup.%s(pt, e_id, bc_id, mm, {})
 EOF
 
-  describe 'McflyModel' do
-    before(:all) do
-      @clean_file = "/tmp/clean_#{Process.pid}.psql"
-      save_clean_db(@clean_file)
-      marty_whodunnit
-      dt = Date.today
-      Marty::DataImporter.do_import_summary(Gemini::Entity, entities)
-      Marty::DataImporter.do_import_summary(Gemini::BudCategory, bud_cats)
-      Marty::DataImporter.do_import_summary(Gemini::FannieBup, fannie_bup)
+describe 'McflyModel' do
+  before(:all) do
+    @clean_file = "/tmp/clean_#{Process.pid}.psql"
+    save_clean_db(@clean_file)
+    marty_whodunnit
+    dt = Date.today
+    Marty::DataImporter.do_import_summary(Gemini::Entity, entities)
+    Marty::DataImporter.do_import_summary(Gemini::BudCategory, bud_cats)
+    Marty::DataImporter.do_import_summary(Gemini::FannieBup, fannie_bup)
+    Marty::Script.load_script_bodies(
+      {
+        'AA' => script,
+      }, dt)
+    @errs = ['E1', 'lookup_p',
+             'E2', 'clookup_p',
+             'E3', 'lookupn_p',
+             'E4', 'clookupn_p']
+
+    @errs.in_groups_of(2) do |name, fn|
       Marty::Script.load_script_bodies(
-        {
-          "AA" => script,
-        }, dt)
-      @errs = ['E1', 'lookup_p',
-               'E2', 'clookup_p',
-               'E3', 'lookupn_p',
-               'E4', 'clookupn_p']
-
-      @errs.in_groups_of(2) do |name, fn|
-        Marty::Script.load_script_bodies(
         {
           name => (errscript % fn),
         }, Date.today)
-      end
+    end
 
-      Marty::Script.load_script_bodies({'E5'=>(errscript2 % 'a_func_p')}, dt)
-      Marty::Script.load_script_bodies({'E6'=>(errscript3 % 'b_func_p')}, dt)
+    Marty::Script.load_script_bodies({ 'E5' => (errscript2 % 'a_func_p') }, dt)
+    Marty::Script.load_script_bodies({ 'E6' => (errscript3 % 'b_func_p') }, dt)
 
-      @engine = Marty::ScriptSet.new.get_engine("AA")
-    end
-    after(:all) do
-      restore_clean_db(@clean_file)
-      Marty::ScriptSet.clear_cache
-    end
-    let(:params) {{"pt"        =>'infinity',
-                   "entity"    => Gemini::Entity.all.first,
-                   "note_rate" => 2.875}}
-    it "lookup mode default" do
-      a1 = @engine.evaluate("A", "lookup", params)
-      a2 = @engine.evaluate("A", "clookup", params)
-      expect(a1).to eq(a2)                            # cache/non return same
-      expect(a1.class).to eq(OpenStruct)              # mode default so return OS
-      expect(a2.class).to eq(OpenStruct)
-
-      # check that keys are non mcfly non uniqueness
-      expect(a1.to_h.keys.to_set).to eq(Set[:buy_up, :buy_down])
-    end
+    @engine = Marty::ScriptSet.new.get_engine('AA')
+  end
+  after(:all) do
+    restore_clean_db(@clean_file)
+    Marty::ScriptSet.clear_cache
+  end
+  let(:params) do
+    { 'pt' => 'infinity',
+                 'entity'    => Gemini::Entity.all.first,
+                 'note_rate' => 2.875 }
+  end
+  it 'lookup mode default' do
+    a1 = @engine.evaluate('A', 'lookup', params)
+    a2 = @engine.evaluate('A', 'clookup', params)
+    expect(a1).to eq(a2)                            # cache/non return same
+    expect(a1.class).to eq(OpenStruct)              # mode default so return OS
+    expect(a2.class).to eq(OpenStruct)
+
+    # check that keys are non mcfly non uniqueness
+    expect(a1.to_h.keys.to_set).to eq(Set[:buy_up, :buy_down])
+  end
 
-    it "lookup non generated" do
-      # a1 will be AR Relations
-      # b1 will be OpenStructs because the b fns return #first
-      e_id = Gemini::Entity.where(name: "PLS").first.id
-      bc_id = Gemini::BudCategory.where(name: "Conv Fixed 20").first.id
-      p = {"e_id"=>e_id, "bc_id"=>bc_id}
-      a1 = @engine.evaluate("A", "a_func", p)
-      b1 = @engine.evaluate("A", "b_func", p)
+  it 'lookup non generated' do
+    # a1 will be AR Relations
+    # b1 will be OpenStructs because the b fns return #first
+    e_id = Gemini::Entity.where(name: 'PLS').first.id
+    bc_id = Gemini::BudCategory.where(name: 'Conv Fixed 20').first.id
+    p = { 'e_id' => e_id, 'bc_id' => bc_id }
+    a1 = @engine.evaluate('A', 'a_func', p)
+    b1 = @engine.evaluate('A', 'b_func', p)
 
-      # all return relations
-      expect(ActiveRecord::Relation === a1).to be_truthy
-      expect(ActiveRecord::Base === a1.first).to be_truthy
+    # all return relations
+    expect(ActiveRecord::Relation === a1).to be_truthy
+    expect(ActiveRecord::Base === a1.first).to be_truthy
 
-      expect(a1.to_a.count).to eq(2)
+    expect(a1.to_a.count).to eq(2)
 
-      # a1 lookup did not include extra attrs
-      expect(a1.first.attributes.keys.to_set).to eq(Set["id", "buy_up", "buy_down"])
+    # a1 lookup did not include extra attrs
+    expect(a1.first.attributes.keys.to_set).to eq(Set['id', 'buy_up', 'buy_down'])
 
-      # a1 is AR but still missing the FK entity_id so will raise
-      expect{a1.first.entity}.to raise_error(/missing attribute: entity_id/)
+    # a1 is AR but still missing the FK entity_id so will raise
+    expect { a1.first.entity }.to raise_error(/missing attribute: entity_id/)
 
-      expect(b1.class).to eq(OpenStruct)
+    expect(b1.class).to eq(OpenStruct)
 
-      # make sure b1 has correct keys
-      expect(b1.to_h.keys.to_set).to eq(Set[:buy_up, :buy_down])
-    end
+    # make sure b1 has correct keys
+    expect(b1.to_h.keys.to_set).to eq(Set[:buy_up, :buy_down])
+  end
 
-    it "lookup mode nil" do
-      # make sure ARs are returned
-      a1 = @engine.evaluate("A", "lookupn", params)
-      a2 = @engine.evaluate("A", "clookupn", params)
-      expect(a1).to eq(a2)
-      expect(ActiveRecord::Relation === a1).to be_truthy
-      expect(a1.to_a.count).to eq(4)
-    end
+  it 'lookup mode nil' do
+    # make sure ARs are returned
+    a1 = @engine.evaluate('A', 'lookupn', params)
+    a2 = @engine.evaluate('A', 'clookupn', params)
+    expect(a1).to eq(a2)
+    expect(ActiveRecord::Relation === a1).to be_truthy
+    expect(a1.to_a.count).to eq(4)
+  end
 
-    it "private methods can't be called by delorean" do
-      # generated methods
-      aggregate_failures "errors" do
-        @errs.in_groups_of(2) do |name, fn|
-          err = /Too many args to #{fn}/
+  it "private methods can't be called by delorean" do
+    # generated methods
+    aggregate_failures 'errors' do
+      @errs.in_groups_of(2) do |name, fn|
+        err = /Too many args to #{fn}/
 
-          expect{
-            Marty::ScriptSet.new.get_engine(name)
-          }.to raise_error(Delorean::BadCallError, err)
-        end
+        expect do
+          Marty::ScriptSet.new.get_engine(name)
+        end.to raise_error(Delorean::BadCallError, err)
       end
     end
+  end
 
-    it "private methods can't be called by delorean (2)" do
-      # non-generated
-      aggregate_failures "errors" do
-        ['E5', 'a_func_p', 'E6', 'b_func_p'].in_groups_of(2) do |scr, fn|
-          err = /Too many args to #{fn}/
-          expect{Marty::ScriptSet.new.get_engine(scr)}.to raise_error(
-                                             Delorean::BadCallError, err)
-        end
+  it "private methods can't be called by delorean (2)" do
+    # non-generated
+    aggregate_failures 'errors' do
+      ['E5', 'a_func_p', 'E6', 'b_func_p'].in_groups_of(2) do |scr, fn|
+        err = /Too many args to #{fn}/
+        expect { Marty::ScriptSet.new.get_engine(scr) }.to raise_error(
+          Delorean::BadCallError, err)
       end
     end
+  end
 
-    it "caching times" do
-      ts = DateTime.now
-      x=Benchmark.measure { 10000.times {
-                            Gemini::FannieBup.a_func(ts,
-                                                     1, 2)
-                          }
-      }
-      y=Benchmark.measure { 10000.times {
-                            Gemini::FannieBup.ca_func(ts,
-                                                     1, 2)
-                          }
-      }
-      # x time should be 30x or more than y time
-      expect(x.real / y.real).to be > 30
+  it 'caching times' do
+    ts = DateTime.now
+    x = Benchmark.measure do
+        10000.times do
+                          Gemini::FannieBup.a_func(ts,
+                                                   1, 2)
+        end
     end
+    y = Benchmark.measure do
+        10000.times do
+                          Gemini::FannieBup.ca_func(ts,
+                                                    1, 2)
+        end
+    end
+    # x time should be 30x or more than y time
+    expect(x.real / y.real).to be > 30
   end
 end
+end

data/spec/lib/migrations_spec.rb

@@ -1,18 +1,18 @@
-require "spec_helper"
+require 'spec_helper'
 
 module Marty
-  describe "Migrations" do
-    it "writes db views correctly" do
-      tdir = File.dirname(__FILE__) + "/migrations/"
+  describe 'Migrations' do
+    it 'writes db views correctly' do
+      tdir = File.dirname(__FILE__) + '/migrations/'
       Marty::Migrations.write_view(tdir,
                                    'vw_marty_postings',
-                                   Marty::Posting, {}, ["comment"],
-                                   [["marty_posting_types", "id",
-                                     "post_type_id"]])
-      filename = "vw_marty_postings.sql"
-      genfile = File.join(tdir,filename)
+                                   Marty::Posting, {}, ['comment'],
+                                   [['marty_posting_types', 'id',
+                                     'post_type_id']])
+      filename = 'vw_marty_postings.sql'
+      genfile = File.join(tdir, filename)
       generated = File.read(genfile)
-      expected = File.read(File.join(tdir,"#{filename}.expected"))
+      expected = File.read(File.join(tdir, "#{filename}.expected"))
       expect(generated).to eq(expected)
       File.delete(genfile)
     end

data/spec/lib/struct_compare_spec.rb

@@ -1,18 +1,18 @@
 require 'spec_helper'
 
-describe "StructCompare" do
-  it "compares correctly" do
+describe 'StructCompare' do
+  it 'compares correctly' do
     p = File.expand_path('../../fixtures/misc', __FILE__)
-    fname = "%s/%s" % [p, 'struct_compare_tests.txt']
+    fname = '%s/%s' % [p, 'struct_compare_tests.txt']
     aggregate_failures 'struct_compare' do
       data = JSON.parse(File.read(fname))
       data.each do |ex|
-        args = [ex["v1"], ex["v2"], ex['cmp_opts']].compact
+        args = [ex['v1'], ex['v2'], ex['cmp_opts']].compact
         comp = struct_compare(*args)
         comparison = comp.nil? ? false : comp
-        num = ex["example_number"]
+        num = ex['example_number']
         binding.pry if comparison != ex['res']
-        expect(comparison).to eq(ex["res"]), "Test ##{num} failed: #{comparison}"
+        expect(comparison).to eq(ex['res']), "Test ##{num} failed: #{comparison}"
       end
     end
   end

data/spec/lib/table_report_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe 'Blame Report', slow: true do
+  RES0 = [
+    ['bud_category', 'note_rate', 'settlement_mm', 'settlement_yy', 'buy_up'],
+    ['Govt Fixed 30', '2.25', '22', '2010', '12.123'],
+    ['Conv Fixed 30', '2.25', '12', '2012', '1.127']
+  ].freeze
+
+  RES1 = [
+    ['entity', 'bud_category', 'note_rate', 'settlement_mm', 'settlement_yy',
+     'buy_up', 'buy_down'],
+    [nil, 'Govt Fixed 30', '2.25', '22', '2014', '2.123', '3.345'],
+    [nil, 'Govt Fixed 30', '2.25', '22', '2010', '12.123', '3.345'],
+    [nil, 'Conv Fixed 30', '2.25', '12', '2012', '1.126', '2.345']
+  ].freeze
+
+  before do
+    marty_whodunnit
+
+    Marty::Script.load_scripts(nil, Time.zone.now)
+
+    time1 = Time.zone.parse '2019-01-23 05:14:50 -0800'
+    time2 = Time.zone.parse '2019-01-24 05:14:50 -0800'
+    time3 = Time.zone.parse '2019-01-25 05:14:50 -0800'
+    time4 = Time.zone.parse '2019-01-26 05:14:50 -0800'
+    time5 = Time.zone.parse '2019-01-27 05:14:50 -0800'
+
+    posting = Marty::Posting.do_create('BASE', time5 - 2.hours, 'base posting')
+    @pt_name = Marty::Posting.find_by_name(posting.name).name
+
+    bc = Gemini::BudCategory.create(name: 'Conv Fixed 30', created_dt: time1)
+    bc2 = Gemini::BudCategory.create(name: 'Govt Fixed 30', created_dt: time1)
+
+    fannie_bup1 = Gemini::FannieBup.create(bud_category: bc,
+                             note_rate: 2.250,
+                             buy_up: 1.123,
+                             buy_down: 2.345,
+                             settlement_mm: 12,
+                             settlement_yy: 2012,
+                             created_dt: time1
+                                          )
+
+    fannie_bup2 = Gemini::FannieBup.create(bud_category: bc2,
+                             note_rate: 2.250,
+                             buy_up: 2.123,
+                             buy_down: 3.345,
+                             settlement_mm: 22,
+                             settlement_yy: 2014,
+                             created_dt: time4
+                                          )
+
+    fannie_bup3 = Gemini::FannieBup.create(bud_category: bc2,
+                             note_rate: 2.250,
+                             buy_up: 12.123,
+                             buy_down: 3.345,
+                             settlement_mm: 22,
+                             settlement_yy: 2010,
+                             created_dt: time4
+                                          )
+
+    fannie_bup2.destroy!
+    fannie_bup1.update!(buy_up: 1.125, created_dt: time2)
+    fannie_bup1.update!(buy_up: 1.126, created_dt: time4)
+    fannie_bup1.update!(buy_up: 1.127, created_dt: time5)
+  end
+
+  it 'should generate Table report' do
+    engine = Marty::ScriptSet.new.get_engine('TableReport')
+    ws = engine.evaluate(
+      'TableReport', 'result',
+      'pt_name'       => 'NOW',
+      'class_name'    => 'Gemini::FannieBup',
+      'exclude_attrs' => ['entity_id', 'buy_down'],
+      'sort_field'    => 'settlement_yy'
+    )
+
+    parsed_csv = CSV.parse(ws)
+    expect(parsed_csv).to eq RES0
+
+    ws = engine.evaluate(
+      'TableReport', 'result',
+      'pt_name'    => @pt_name,
+      'class_name' => 'Gemini::FannieBup',
+    )
+
+    parsed_csv = CSV.parse(ws)
+    expect(parsed_csv).to eq RES1
+  end
+end