marty 1.2.0 → 1.2.1

data/spec/dummy/lib/gemini/my_rule_script_set.rb

@@ -0,0 +1,13 @@
+class Gemini::MyRuleScriptSet < Marty::RuleScriptSet
+  def self.node_name
+    "Node2"
+  end
+  def self.body_start
+    params = <<~END
+    param1 =?
+    param2 =?
+    paramb =? false
+    END
+    super + indent(params)
+  end
+end

data/spec/dummy/lib/gemini/xyz_rule_script_set.rb

@@ -0,0 +1,22 @@
+class Gemini::XyzRuleScriptSet < Marty::RuleScriptSet
+  def self.node_name
+    "NodeXyz"
+  end
+  def self.body_start
+    "import BaseCode\n#{node_name}: BaseCode::BaseCode\n"
+  end
+  def xyz_code(rule)
+    write_code(rule.computed_guards.select{|k,_|k.starts_with?("xyz_")})
+  end
+  def guard_code(rule)
+    write_code(rule.computed_guards.reject{|k,_|k.starts_with?("xyz_")})
+  end
+  def get_code(rule)
+    x = xyz_code(rule)
+    super + (x.blank? ? '' :
+      "XyzNode:\n    xyz_param =? nil\n" + self.class.indent(x))
+  end
+  def code_section_counts(rule)
+    super + { xyz: xyz_code(rule).count("\n") }
+  end
+end

data/spec/features/rule_spec.rb

@@ -0,0 +1,265 @@
+require 'spec_helper'
+require 'marty_rspec'
+
+feature 'rule view', js: true do
+  before(:all) do
+    marty_whodunnit
+    @save_file = "/tmp/save_#{Process.pid}.psql"
+    save_clean_db(@save_file)
+    Marty::Script.load_scripts
+    dt = DateTime.parse('2017-1-1')
+    p = File.expand_path('../../fixtures/csv/rule', __FILE__)
+    [Marty::DataGrid, Gemini::XyzRule, Gemini::MyRule].each do |klass|
+      f = "%s/%s.csv" % [p, klass.to_s.sub(/(Gemini|Marty)::/,'')]
+      Marty::DataImporter.do_import(klass, File.read(f), dt, nil, nil, ",")
+    end
+  end
+  after(:all) do
+    restore_clean_db(@save_file)
+  end
+  def go_to_my_rules
+    press("Pricing Config.")
+    press("My Rules")
+    expect(page).to have_content 'My Rules'
+  end
+  def go_to_xyz_rules
+    press("Pricing Config.")
+    press("Xyz Rules")
+    expect(page).to have_content 'Xyz Rules'
+  end
+  def col_id(v, col)
+    run_js <<-JS
+           #{ext_var(v.grid, 'grid')}
+           return #{ext_find(ext_arg('gridcolumn', text: col), 'grid')}.id
+     JS
+  end
+  # click_checkbox in marty_rspec not working here for some reason
+  def click_checkbox(name)
+    q = %Q(checkbox[fieldLabel="#{name}"])
+    id = run_js "return  Ext.ComponentQuery.query('#{q}')[0].inputId"
+    find_by_id(id).click
+  end
+  # click_col in marty_rspec is not reliable
+  def click_column(rv,name)
+    cid = col_id(rv, name)
+    c = find('#'+cid)
+    c.select_option   #   .click does not work reliably
+    c.send_keys(' ')
+    # wait_for_ajax and wait_for_ready do not work here,
+    # or in the next two methods
+    sleep 1.0
+  end
+
+  def column_filter(rv,name,value)
+    cid = col_id(rv, name)
+    c = find('#'+cid)
+    c.send_keys([:down, :down, :down, :down, :right, value, :return])
+    sleep 1.0
+  end
+  def column_filter_toggle(rv,name)
+    cid = col_id(rv, name)
+    c = find('#'+cid)
+    c.send_keys([:down, :down, :down, :down, ' ', :escape])
+    sleep 1.0
+  end
+  # idx 0 is the start dt, 1 is the end dt
+  def date_fill_in(idx, value)
+    dt = all(:xpath, "//input[contains(@name, 'datefield')]")[idx]
+    dt.native.clear()
+    dt.native.send_keys(value)
+  end
+  def time_fill_in(idx,value)
+    tm = all(:xpath, "//input[contains(@name, 'timefield')]")[idx]
+    tm.native.clear()
+    tm.native.send_keys(value)
+  end
+  it "rule workflow" do
+    log_in_as('marty')
+    page.driver.browser.manage.window.maximize
+    go_to_my_rules
+    mrv = netzke_find("my_rule_view")
+    # test required field
+    press('Add')
+    wait_for_ajax
+    fill_in('name', with: 'abc')
+    press('OK')
+    expect(page).to have_content("Rule type can't be blank")
+    expect(page).to have_content("Start dt can't be blank")
+    # create and verify rule
+    fill_in('rule_type', with: 'SimpleRule')
+    date_fill_in(0, '2013-01-01')
+    time_fill_in(0, '11:03:01')
+    date_fill_in(1, '2030-01-01')
+    time_fill_in(1, '08:03:01')
+    press("OK")
+    wait_for_ajax
+    expect(mrv.row_count()).to eq(8)
+    expect(mrv.get_row_vals(1)).to include({"name"=>"abc",
+                                            "rule_type"=>"SimpleRule",
+                                            "start_dt"=>"2013-01-01T19:03:01.000Z",
+                                            "end_dt"=>"2030-01-01T16:03:01.000Z",
+                                            "other_flag"=>false,
+                                            "g_array"=>"",
+                                            "g_single"=>"",
+                                            "g_string"=>"",
+                                            "g_bool"=>nil,
+                                            "g_range"=>nil,
+                                            "g_integer"=>nil,
+                                            "computed_guards"=>"",
+                                            "grids"=>"",
+                                            "results"=>"",
+                                            })
+    r = Gemini::MyRule.lookup('infinity','abc')
+    expect(r.as_json).to include({"user_id"=>1,
+                                  "o_user_id"=>nil,
+                                  "name"=>"abc",
+                                  "engine"=>"Gemini::MyRuleScriptSet",
+                                  "rule_type"=>"SimpleRule",
+                                  "simple_guards"=>{"g_has_default"=>
+                                                    "string default"},
+                                  "computed_guards"=>{},
+                                  "grids"=>{},
+                                  "results"=>{},
+                                  })
+    # type validation (string with values list)
+    mrv.select_row(1)
+    press("Edit")
+    fill_in(:g_string, with: "12345")
+    press("OK")
+    expect(page).to have_content("Bad value '12345' for 'g_string'")
+    # type validation (range)
+    fill_in(:g_string, with: "Hi Mom")
+    click_checkbox("Bool Guard")
+    click_checkbox("Other")
+    netzke_find('Array Guard', 'combobox').select_values("G1V1,G1V3")
+    netzke_find('Single Guard', 'combobox').select_values("G2V2")
+    fill_in(:g_integer, with: 123)
+    fill_in(:g_range, with: "asfd")
+    press("OK")
+    expect(page).to have_content("Wrong type for 'g_range'")
+    # validate rule
+    fill_in(:g_range, with: "<=100")
+    netzke_find('Grid1', 'combobox').select_values("DataGrid1")
+    netzke_find('Grid2', 'combobox').select_values("DataGrid2")
+    press("OK")
+    wait_for_ajax
+    exp = {"name"=>"abc",
+           "rule_type"=>"SimpleRule",
+           "start_dt"=>"2013-01-01T19:03:01.000Z",
+           "end_dt"=>"2030-01-01T16:03:01.000Z",
+           "other_flag"=>true,
+           "g_array"=>"G1V1,G1V3",
+           "g_single"=>"G2V2",
+           "g_string"=>"Hi Mom",
+           "g_bool"=>true,
+           "g_range"=>"<=100",
+           "g_integer"=>123,
+           "computed_guards"=>"",
+           "grids"=>"{\"grid1\":\"DataGrid1\",\"grid2\":\"DataGrid2\"}",
+           "results"=>"",
+          }
+    expect(mrv.get_row_vals(1)).to include(exp)
+    # grid edits
+    press("Edit")
+    netzke_find('Grid2', 'combobox').select_values("---")
+    press("OK")
+    wait_for_ajax
+    expect(mrv.get_row_vals(1)).to include(exp+{"grids"=>
+                                                "{\"grid1\":\"DataGrid1\"}"})
+    # computed fields
+    press("Edit")
+    fill_in(:computed_guards, with: 'sadf asdf ljsf')
+    press("OK")
+    exp = "Computed - Error in rule 'abc' field 'computed_guards': Syntax error on line 1"
+    expect(page).to have_content(exp)
+    fill_in(:computed_guards, with: 'sadf = 123j s /*fdjOIb')
+    press("OK")
+    exp = "Computed - Error in rule 'abc' field 'computed_guards': syntax error"
+    expect(page).to have_content(exp)
+    fill_in(:computed_guards, with: '')
+    fill_in(:results, with: %Q(abc = "def"\ndef = 5\nxyz=def+10\nsadf asdf lsf))
+    press("OK")
+    exp = "Computed - Error in rule 'abc' field 'results': Syntax error on line 4"
+    expect(page).to have_content(exp)
+    fill_in(:results,
+            with: %Q(abc = "def"\ndef = "abc"\nklm = "3"\nabc = "xyz"))
+    exp = "Computed - Error in rule 'abc' field 'results': Keyword 'abc' specified more"\
+          " than once (line 4)"
+    press("OK")
+    expect(page).to have_content(exp)
+    fill_in(:results,
+            with: %Q(abc = "def"\ndef = "abc"\nklm = "3"))
+    press("OK")
+
+    press("Dup in form")
+    press("OK")
+    exp = Regexp.new("Can't have rule with same name and overlapping start"\
+                     "/end dates - abc")
+    expect(page).to have_content(exp)
+    netzke_find('Single Guard', 'combobox').select_values("G2V3")
+    press("OK")
+    exp = Regexp.new("Can't have rule with same name and different "\
+                     "type/guards - abc")
+    expect(page).to have_content(exp)
+
+    press("Cancel")
+    # column sorting, etc
+    go_to_xyz_rules
+    xrv = netzke_find("xyz_rule_view")
+    expect(page).to have_content("Rule type")
+    expect(xrv.col_values(:name, 5, 0)).to eq(["ZRule1", "ZRule2",
+                                                    "ZRule3", "ZRule4",
+                                                    "ZRule5"])
+    xrv.select_row(1)
+    press("Edit")
+    fill_in("Range Guard 1", with: "[100,200)")
+    fill_in("Range Guard 2", with: "[30,40)")
+    press("OK")
+    r = Gemini::XyzRule.get_matches('infinity', {}, {"g_range1"=> 150,
+                                                     "g_range2"=> 35})
+    expect(r.to_a.count).to eq(1)
+    exp = {"user_id"=>1,
+           "o_user_id"=>nil,
+           "name"=>"ZRule1",
+           "engine"=>"Gemini::XyzRuleScriptSet",
+           "rule_type"=>"ZRule",
+           "start_dt"=>DateTime.parse("2017-1-1 08:01:00"),
+           "simple_guards"=>{"g_date"=>"2017-1-1",
+                             "g_range1"=>"[100,200)",
+                             "g_range2"=>"[30,40)",
+                             "g_string"=>"aaa",
+                             "g_integer"=>"5",
+                             "g_datetime"=>"2017-1-1 12:00:01"},
+           "computed_guards"=>{},
+           "grids"=>{"grid1"=>"DataGrid1"},
+           "results"=>
+           {"bvlen"=>"base_value.length",
+            "bv"=>"base_value"}}
+
+    expect(r.first.as_json).to include(exp)
+    expect(xrv.col_values(:g_string, 5, 0)).to eq(["aaa", "bbb", "ccc",
+                                                   "ddd", "eee"])
+    click_column(xrv, "G string")
+    expect(xrv.col_values(:g_string, 5, 0)).to eq(["eee", "ddd", "ccc",
+                                                   "bbb", "aaa"])
+    column_filter(xrv, "G string", "eee")
+    rc = xrv.row_count
+    expect(xrv.col_values(:g_string,rc,0)).to eq(["eee"])
+    column_filter_toggle(xrv, "G string")
+    rc = xrv.row_count
+    expect(xrv.col_values(:g_string,rc,0)).to eq(["eee", "ddd", "ccc",
+                                                   "bbb", "aaa"])
+    column_filter(xrv, "Grids", "Grid1")
+    rc = xrv.row_count
+                                         # netzke reports jsonb as string
+    expect(xrv.col_values(:grids,rc,0)).to eq([%Q({"grid1":"DataGrid1"}),
+                                               %Q({"grid1":"DataGrid1"})])
+    column_filter_toggle(xrv, "Grids")
+    rc = xrv.row_count
+    expect(xrv.col_values(:grids,rc,0)).to eq([%Q({"grid1":"DataGrid3"}),
+                                               %Q({"grid1":"DataGrid3"}),
+                                               %Q({"grid1":"DataGrid2"}),
+                                               %Q({"grid1":"DataGrid1"}),
+                                               %Q({"grid1":"DataGrid1"})])
+  end
+end

data/spec/fixtures/csv/rule/DataGrid.csv

@@ -0,0 +1,6 @@
+name,data,metadata,data_type,lenient
+DataGrid1,"[[9,8,7,6,5,4,3,2,1,0]]","[{""dir"": ""h"", ""attr"": ""param1"", ""type"": ""int4range"", ""keys"": [""[,10]"",""(10,20]"",""(20,30]"",""(30,40]"",""(40,50]"",""(50,60]"",""(60,70]"",""(70,80]"",""(80,90]"",""(90,100]""]}]",,t
+DataGrid2,"[[9,8,7,6,5,4,3,2,1,0],[19,18,17,16,15,14,1300,12,11,10]]","[{""dir"": ""h"", ""attr"": ""param1"", ""type"": ""int4range"", ""keys"": [""[,10]"",""(10,20]"",""(20,30]"",""(30,40]"",""(40,50]"",""(50,60]"",""(60,70]"",""(70,80]"",""(80,90]"",""(90,100]""]},{""dir"":""v"",""attr"":""paramb"",""type"":""boolean"",""keys"":[true, false]}]",,t
+DataGrid3,"[[9,8,7,6,5,4,3,2,1,0],[19,18,17,16,15,14,1300,12,11,10]]","[{""dir"": ""h"", ""attr"": ""p2"", ""type"": ""int4range"", ""keys"": [""[,10]"",""(10,20]"",""(20,30]"",""(30,40]"",""(40,50]"",""(50,60]"",""(60,70]"",""(70,80]"",""(80,90]"",""(90,100]""]},{""dir"":""v"",""attr"":""flavor"",""type"":""string"",""keys"":[[""lemon""], [""cherry""]]}]",,f
+DataGrid4,"[[9,8,7,6,5,4,3,2,1,0],[19,18,17,16,15,14,1300,12,11,10]]","[{""dir"": ""h"", ""attr"": ""param1"", ""type"": ""int4range"", ""keys"": [""[,10]"",""(10,20]"",""(20,30]"",""(30,40]"",""(40,50]"",""(50,60]"",""(60,70]"",""(70,80]"",""(80,90]"",""(90,100]""]},{""dir"":""v"",""attr"":""flavor"",""type"":""string"",""keys"":[[""lemon""], [""cherry""]]}]",,f
+

data/spec/fixtures/csv/rule/MyRule.csv

@@ -0,0 +1,14 @@
+name,rule_type,start_dt,end_dt,other_flag,simple_guards,computed_guards,grids,results
+Rule1,SimpleRule,2017-1-1 12:00:00,2017-4-1,,"{""g_has_default"":""different"",""g_array"":[""G1V1"",""G1V3""],""g_single"":""G2V2"",""g_string"":""Hi Mom"",""g_bool"":true,""g_range"":""[50,)"",""g_integer"":10}",,,"{""simple_result"":""\""a value\""""}"
+Rule2,SimpleRule,2017-2-1 14:00:00,2017-4-1,true,"{""g_array"":[""G1V2""],""g_single"":""G2V3"",""g_string"":""abc"",""g_bool"":true,""g_range"":""(,50]"",""g_integer"":11}",,,"{
+""simple_result"":""\""b value\"" # with comment "", 
+""sr2"":""true # with comment"", 
+""sr3"": ""123  # with comment "", 
+""c1"":""123 + 456  # with comment"",
+""single_quote"":""'string with single quotes'"",
+""stringwithhash"": ""\"" string that contains a # character\""""}"
+Rule2a,SimpleRule,2017-2-1 14:00:00,2017-4-1,true,"{""g_array"":[""G1V2""],""g_single"":""G2V3"",""g_string"":""abc"",""g_bool"":true,""g_range"":""(,50]"",""g_integer"":99}",,,"{""simple_result"":""\""b value\"""", ""sr2"":""true"", ""sr3"": ""123""}"
+Rule2b,SimpleRule,2017-2-1 14:00:00,2017-4-1,true,"{""g_array"":[""G1V2""],""g_single"":""G2V3"",""g_string"":""abc"",""g_bool"":true,""g_range"":""(,50]"",""g_integer"":999}",,"{""grid1"":""DataGrid1"",""grid2"":""DataGrid2""}",
+Rule3,ComplexRule,2017-3-1 00:00:00,2017-4-1,false,"{""g_array"":[""G1V2"",""G1V3""],""g_string"":""def"",""g_integer"":11}","{""cguard1"":""1==1"",""cguard2"":""param2 == 'abc'""}","{""grid1"":""DataGrid1"",""grid2"":""DataGrid2""}","{""simple_result"":""\""c value\"""",""computed_value"":""if paramb then param1 / (grid1_grid||1) else (grid2_grid||1) / param1""}"
+Rule4,ComplexRule,2017-4-1 15:00:01,2017-5-1,,"{""g_array"":[""G1V2"",""G1V3""],""g_string"":""Hi Mom"",""g_integer"":11}","{""cguard1"":""1==1"",""cguard2"":""param2 == \""abc\""""}","{""grid1"":""DataGrid1"",""grid2"":""DataGrid2""}","{""simple_result"":""\""c value\"""",""grid_sum"":""(grid1_grid||0)+(grid2_grid||0)""}"
+Rule5,ComplexRule,2017-4-2 15:00:01,2017-5-1,,"{""g_string"":""zzz"",""g_integer"":3757,""g_has_default"":""foo""}","{""cguard1"":""1==1""}",,"{""flavor"": ""[\""cherry\"",\""lemon\""][param2]"",""other_grid"": ""DataGrid4"",""final_value"": ""other_grid * 3""}"

data/spec/fixtures/csv/rule/XyzRule.csv

@@ -0,0 +1,6 @@
+name,rule_type,start_dt,simple_guards,computed_guards,grids,results
+ZRule1,ZRule,2017-1-1 08:01:00,"{""g_string"":""aaa"",""g_range1"":""[10,20)"",""g_integer"":5,""g_date"":""2017-1-1"",""g_datetime"":""2017-1-1 12:00:01""}","{}","{""grid1"":""DataGrid1""}","{""bvlen"": ""base_value.length"", ""bv"":""base_value""}"
+ZRule2,ZRule,2017-2-1 09:01:00,"{""g_string"":""bbb"",""g_range1"":""[20,30)"",""g_integer"":4,""g_date"":""2017-1-2"",""g_datetime"":""2017-1-1 12:00:02""}","{}","{""grid1"":""DataGrid1""}","{""key1"":""\""value1\"""",""bvlen"": ""base_value.length"", ""bv"":""base_value""}"
+ZRule3,ZRule,2017-3-1 10:00:00,"{""g_string"":""ccc"",""g_range1"":""[30,40)"",""g_integer"":3,""g_date"":""2017-1-3"",""g_datetime"":""2017-1-1 12:00:03""}","{}","{""grid1"":""DataGrid2""}","{""bvlen"": ""base_value.length"", ""bv"":""base_value""}"
+ZRule4,ZRule,2017-3-1 11:00:00,"{""g_string"":""ddd"",""g_range1"":""[40,50)"",""g_integer"":2,""g_date"":""2017-1-4"",""g_datetime"":""2017-1-1 12:00:04""}","{}","{""grid1"":""DataGrid3""}","{""bvlength"": ""base_value.length"", ""bv"":""base_value""}"
+ZRule5,ZRule,2017-3-1 11:00:01,"{""g_string"":""eee"",""g_range1"":""[50,60)"",""g_integer"":1,""g_date"":""2017-1-5"",""g_datetime"":""2017-1-1 12:00:05""}","{}","{""grid1"":""DataGrid3""}","{""bvlen"": ""base_value.length"", ""bv"":""base_value""}"

data/spec/models/rule_spec.rb

@@ -0,0 +1,322 @@
+require 'spec_helper'
+
+module Marty::RuleSpec
+  describe "Rule" do
+    before(:all) do
+      @save_file = "/tmp/save_#{Process.pid}.psql"
+      save_clean_db(@save_file)
+      Marty::Script.load_scripts
+      Marty::Config['RULEOPTS_MYRULE']={'simple_result'=>{},
+                                        'computed_value'=>{},
+                                        'final_value'=>{},
+                                       }
+      Marty::Config['RULEOPTS_XYZ']={'bvlength'=>{},
+                                     'bv'=>{},
+                                    }
+    end
+    after(:all) do
+      restore_clean_db(@save_file)
+    end
+    before(:each) do
+      marty_whodunnit
+      dt = DateTime.parse('2017-1-1')
+      p = File.expand_path('../../fixtures/csv/rule', __FILE__)
+      [Marty::DataGrid, Gemini::XyzRule, Gemini::MyRule].each do |klass|
+        f = "%s/%s.csv" % [p, klass.to_s.sub(/(Gemini|Marty)::/,'')]
+        Marty::DataImporter.do_import(klass, File.read(f), dt, nil, nil, ",")
+      end
+      Marty::Tag.do_create('2017-01-01', 'tag')
+    end
+    context "validation" do
+      subject do
+        guards = (@g_array   ? {"g_array"   =>@g_array}   : {}) +
+                 (@g_single  ? {"g_single"  =>@g_single}  : {}) +
+                 (@g_string  ? {"g_string"  =>@g_string}  : {}) +
+                 (@g_bool    ? {"g_bool"    =>@g_bool}    : {}) +
+                 (@g_range   ? {"g_range"   =>@g_range}   : {}) +
+                 (@g_integer ? {"g_integer" =>@g_integer} : {})
+        Gemini::MyRule.create!(name: "testrule",
+                               rule_type: @rule_type,
+                               start_dt: @start_dt || '2013-1-1',
+                               end_dt:   @end_dt,
+                               simple_guards: guards,
+                               computed_guards: @computed_guards || {},
+                               grids: @grids || {},
+                               results: @results || {}
+                              )
+      end
+      it "detects type errors" do
+        @rule_type = 'SimpleRule'
+        @g_integer = "abc"
+        expect{subject}.to raise_error(/Guards - Wrong type for 'g_integer'/)
+      end
+      it "detects value errors 1" do
+        @rule_type = "SimpleRule"
+        @g_array = ["G1V1", "abcd"]
+        expect{subject}.to raise_error(/Guards - Bad value 'abcd' for 'g_array'/)
+      end
+      it "detects value errors 2" do
+        @rule_type = "SimpleRule"
+        @g_array = ["G1V1", "xyz", "abc"]
+        exp = /Guards - Bad values 'xyz', 'abc' for 'g_array'/
+        expect{subject}.to raise_error(exp)
+      end
+      it "detects arity errors 1" do
+        @rule_type = "SimpleRule"
+        @g_single = ["G2V1","G2V2"]
+        exp = /Guards - Wrong arity for 'g_single' .expected single got multi./
+        expect{subject}.to raise_error(exp)
+      end
+      it "detects arity errors 2" do
+        @rule_type = "SimpleRule"
+        @g_array = "G1V1"
+        exp = /Guards - Wrong arity for 'g_array' .expected multi got single./
+        expect{subject}.to raise_error(exp)
+      end
+      it "detects errors in computed guards" do
+        @rule_type = "SimpleRule"
+        @computed_guards = {"guard1"=> "zvjsdf12.z8*"}
+        exp = /Computed - Error in rule 'testrule' field 'computed_guards': syntax error/
+        expect{subject}.to raise_error(exp)
+      end
+      it "detects errors in computed results" do
+        @rule_type = "SimpleRule"
+        @results = {"does_not_compute"=> "zvjsdf12.z8*"}
+        @grids = {"grid1"=>"DataGrid1","grid2"=>"DataGrid2"}
+        exp = /Computed - Error in rule 'testrule' field 'results': syntax error/
+        expect{subject}.to raise_error(exp)
+      end
+      it "detects errors in computed results 2" do
+        @rule_type = "SimpleRule"
+        @results = {"does_not_compute"=> "zvjsdf12.z8*"}
+        @grids = {"grid1"=>"DataGrid1","grid2"=>"DataGrid1","grid3"=>"DataGrid3"}
+        exp = /Computed - Error in rule 'testrule' field 'results': syntax error/
+        expect{subject}.to raise_error(exp)
+      end
+      it "detects errors in computed results 3" do
+        @rule_type = "SimpleRule"
+        @results = {"does_not_compute"=> "zvjsdf12.z8*"}
+        @grids = {"grid1"=>"DataGrid1","grid2"=>"DataGrid1","grid3"=>"DataGrid1"}
+        exp = /Computed - Error in rule 'testrule' field 'results': syntax error/
+        expect{subject}.to raise_error(exp)
+      end
+      it "reports bad grid names" do
+        @rule_type = "SimpleRule"
+        @grids = {"grid1"=>"xyz","grid2"=>"DataGrid2","grid3"=>"DataGrid1"}
+        exp = /Grids - Bad grid name 'xyz' for 'grid1'/
+        expect{subject}.to raise_error(exp)
+      end
+      it "sets guard defaults correctly" do
+        vals = Gemini::MyRule.all.map do
+          |r|
+          [r.name, r.simple_guards["g_has_default"]]
+        end
+        expect(vals).to eq([["Rule1", "different"],
+                            ["Rule2", "string default"],
+                            ["Rule2a", "string default"],
+                            ["Rule2b", "string default"],
+                            ["Rule3", "string default"],
+                            ["Rule4", "string default"],
+                            ["Rule5", "foo"]])
+      end
+    end
+    context "validation (xyz type)" do
+      subject do
+        r=Gemini::XyzRule.create!(name: "testrule",
+                                rule_type: @rule_type,
+                                start_dt: @start_dt || '2013-1-1',
+                                end_dt: @end_dt,
+                                simple_guards: {},
+                               computed_guards: @computed_guards || {},
+                               grids: @grids || {},
+                               results: @results || {}
+                               )
+        r.reload
+      end
+      it "detects script errors" do
+        @rule_type = 'XRule'
+        @results = {"x"=>"zx sdf wer"}
+        exp = /Computed - Error in rule 'testrule' field 'results': syntax error/
+        expect{subject}.to raise_error(exp)
+      end
+      it "rule script stuff overrides 1" do
+        @rule_type = 'XRule'
+        @computed_guards = {"abc"=>"true", "xyz_guard"=> "err err err"}
+        exp = /Computed - Error in rule 'testrule' field 'xyz': syntax error/
+        expect{subject}.to raise_error(exp)
+      end
+      it "rule script stuff overrides 2" do
+        @rule_type = 'XRule'
+        @computed_guards = {"abc"=>"err err err", "xyz_guard"=> "xyz_param"}
+        exp = /Computed - Error in rule 'testrule' field 'computed_guards': syntax error/
+        expect{subject}.to raise_error(exp)
+      end
+      it "rule script stuff overrides 3" do
+        @rule_type = 'XRule'
+        @computed_guards = {"abc"=>"true", "xyz_guard"=> "!xyz_param"}
+        rule = subject
+        expect(rule.compute_xyz('infinity',true)).to be false
+        expect(rule.compute_xyz('infinity',false)).to be true
+      end
+      it "no error" do
+        @rule_type = 'XRule'
+        @results = {"x"=>"1"}
+        expect{subject}.not_to raise_error
+      end
+    end
+
+    context "lookups" do
+      it "matches" do
+        lookup = Gemini::MyRule.get_matches('infinity',
+                                            {'rule_type'=>'SimpleRule'},
+                                            {'g_array'=>'G1V3'})
+        expect(lookup.to_a.count).to eq(1)
+        expect(lookup.first.name).to eq("Rule1")
+        lookup = Gemini::MyRule.get_matches('infinity',
+                                            {'rule_type'=>'SimpleRule',
+                                            'other_flag'=>true},
+                                            {})
+        expect(lookup.to_a.count).to eq(3)
+        expect(lookup.map{|l|l.name}.to_set).to eq(Set["Rule2","Rule2a","Rule2b"])
+        lookup = Gemini::MyRule.get_matches('infinity',
+                                            {'rule_type'=>'ComplexRule',
+                                            'other_flag'=>false},
+                                            {})
+        expect(lookup.to_a.count).to eq(1)
+        expect(lookup.first.name).to eq("Rule3")
+        lookup = Gemini::MyRule.get_matches('infinity',
+                                            {'rule_type'=>'ComplexRule'},
+                                            {'g_string'=>'def'})
+        expect(lookup.to_a.count).to eq(1)
+        expect(lookup.first.name).to eq("Rule3")
+        lookup = Gemini::MyRule.get_matches('infinity',
+                                            {'rule_type'=>'ComplexRule'},
+                                            {'g_string'=>'abc'})
+        expect(lookup).to eq([])
+        lookup = Gemini::MyRule.get_matches('infinity',
+                                            {'rule_type'=>'SimpleRule'},
+                                            {'g_bool'=>true, "g_range"=>25,
+                                             'g_integer'=>99})
+        expect(lookup.to_a.count).to eq(1)
+        expect(lookup.first.name).to eq("Rule2a")
+        lookup = Gemini::MyRule.get_matches('infinity',
+                                            {'rule_type'=>'SimpleRule'},
+                                            {'g_bool'=>true, "g_range"=>75})
+        expect(lookup.to_a.count).to eq(1)
+        expect(lookup.first.name).to eq("Rule1")
+        lookup = Gemini::MyRule.get_matches('infinity',
+                                            {'rule_type'=>'SimpleRule'},
+                                            {'g_bool'=>true, "g_range"=>75,
+                                             'g_integer'=>11})
+        expect(lookup).to eq([])
+        lookup = Gemini::MyRule.get_matches('infinity',
+                                            {'rule_type'=>'SimpleRule'},
+                                            {'g_bool'=>true, "g_range"=>75,
+                                             'g_integer'=>10})
+        expect(lookup.to_a.count).to eq(1)
+        expect(lookup.first.name).to eq("Rule1")
+        lookup = Gemini::MyRule.get_matches('infinity',
+                                            {'rule_type'=>'SimpleRule'},
+                                            {'g_bool'=>false, "g_range"=>75,
+                                             'g_integer'=>10})
+        expect(lookup).to eq([])
+        lookup = Gemini::MyRule.get_matches('infinity',
+                                            {'rule_type'=>'SimpleRule'}, {})
+        expect(lookup.to_a.count).to eq(4)
+        lookup = Gemini::MyRule.get_matches('infinity',
+                                            {'rule_dt'=>"2017-3-1 02:00:00"},
+                                            {})
+        expect(lookup.to_a.count).to eq(5)
+        expect(lookup.pluck(:name).to_set).to eq(Set["Rule1", "Rule2", "Rule2a",
+                                                     "Rule2b", "Rule3"])
+        lookup = Gemini::MyRule.get_matches('infinity',
+                                            {'rule_dt'=>"2017-4-1 16:00:00"},
+                                            {})
+        expect(lookup.to_a.count).to eq(1)
+        expect(lookup.pluck(:name).first).to eq("Rule4")
+        lookup = Gemini::MyRule.get_matches('infinity',
+                                            {'rule_dt'=>"2016-12-31"}, {})
+        expect(lookup.to_a).to eq([])
+        lookup = Gemini::MyRule.get_matches('infinity',
+                                            {'rule_dt'=>"2017-5-1 00:00:01"}, {})
+        expect(lookup.to_a).to eq([])
+      end
+    end
+    context "rule compute" do
+      let(:complex) { Gemini::MyRule.get_matches('infinity',
+                                            {'rule_type'=>'ComplexRule'},
+                                            {'g_string'=>'def'}).first }
+      let(:xyz) { Gemini::XyzRule.get_matches('infinity',
+                                              {'rule_type'=>'ZRule'},
+                                              {'g_integer'=> 2}).first }
+      let(:simple) {
+        Gemini::MyRule.get_matches('infinity',
+                                   {'rule_type'=>'SimpleRule'},
+                                   {'g_bool'=>true, "g_range"=>25}).first }
+      let(:simple2a) {
+        Gemini::MyRule.get_matches('infinity',
+                                   {'rule_type'=>'SimpleRule'},
+                                   {'g_bool'=>true, "g_integer"=>99}).first }
+      let(:simple2b) {
+        Gemini::MyRule.get_matches('infinity',
+                                   {'rule_type'=>'SimpleRule'},
+                                   {'g_bool'=>true, "g_integer"=>999}).first }
+      let(:altgridmethod) {
+        Gemini::MyRule.get_matches('infinity',
+                                   {'rule_type'=>'ComplexRule'},
+                                   {"g_integer"=>3757}).first }
+      it "computed guards work" do
+        c = complex.compute({"pt"=>Time.zone.now,
+                             'param2'=>'def'})
+        expect(c).to eq({"cguard2"=>false})
+      end
+      it "returns simple results via #fixed_results" do
+        expect(simple.fixed_results["simple_result"]).to eq("b value")
+        expect(simple.fixed_results["sr2"]).to eq(true)
+        expect(simple.fixed_results["sr3"]).to eq(123)
+        ssq = "string with single quotes"
+        expect(simple.fixed_results["single_quote"]).to eq(ssq)
+        swh = " string that contains a # character"
+        expect(simple.fixed_results["stringwithhash"]).to eq(swh)
+        expect(simple.fixed_results.count).to eq(5)
+        allow_any_instance_of(Delorean::Engine).
+          to receive(:evaluate).and_raise('hi mom')
+        expect{simple.compute({"pt"=>Time.now})}.to raise_error(/hi mom/)
+        # simple2a should return results without evaluation (they are all fixed)
+        expect(simple2a.compute({"pt"=>Time.zone.now})).to eq(
+                                       {"simple_result"=>"b value",
+                                        "sr2"=>true,
+                                        "sr3"=>123})
+        # simple2b should return grid results without evaluation
+        expect(simple2b.compute({"pt"=>Time.zone.now,
+                                 'param1'=> 66,
+                                 'param2'=>'abc',
+                                 'paramb'=>false})).to eq({"grid1_grid"=>3,
+                                                           "grid2_grid"=>1300})
+
+      end
+      it "returns computed results" do
+        c = complex.compute({"pt"=>Time.zone.now,
+                             'param1'=> 66,
+                             'param2'=>'abc',
+                             'paramb'=>false})
+        expect(c).to eq({"simple_result"=>"c value",
+                         "computed_value"=>19, "grid1_grid"=>3, "grid2_grid"=>1300})
+      end
+      it "returns computed results (with delorean import)" do
+        c = xyz.compute({"pt"=>Time.zone.now+1,
+                         "p1"=>12,
+                         "p2"=>3,
+                         "flavor"=>"cherry"})
+        expect(c).to eq({"bvlength"=>13,"bv"=>"cherry --> 36",
+                         "grid1_grid"=>19})
+      end
+      it "grids embedded in result work properly and receive prior attrs" do
+        v = altgridmethod.compute({"pt"=>Time.zone.now,
+                                   'param1'=> 45,
+                                   'param2' => 1})
+        expect(v["final_value"]).to eq(15)
+      end
+    end
+  end
+end