marty 2.9.3 → 3.0.0

data/spec/fixtures/misc/grid_log_errs.json

@@ -0,0 +1,418 @@
+[
+  {
+    "message": "save_grid: entered with view permissions",
+    "details": {
+      "data": [
+        {
+          "a0": "",
+          "a1": "",
+          "a2": "Conventional",
+          "a3": "Conventional",
+          "a4": "FHA",
+          "a5": "FHA",
+          "a6": "FHA",
+          "a7": "FHA",
+          "a8": "VA",
+          "a9": "VA",
+          "a10": "VA",
+          "a11": "VA",
+          "a12": "VA",
+          "a13": "VA"
+        },
+        {
+          "a0": "",
+          "a1": "",
+          "a2": null,
+          "a3": null,
+          "a4": null,
+          "a5": "Condominium",
+          "a6": null,
+          "a7": null,
+          "a8": "Condominium",
+          "a9": null,
+          "a10": null,
+          "a11": null,
+          "a12": null,
+          "a13": null
+        },
+        {
+          "a0": "",
+          "a1": "",
+          "a2": "<=1",
+          "a3": ">1",
+          "a4": "<1",
+          "a5": ">=1",
+          "a6": "<=1",
+          "a7": ">1",
+          "a8": ">=1",
+          "a9": "<=1",
+          "a10": ">1<=2",
+          "a11": ">2<=3",
+          "a12": ">3<=4",
+          "a13": ">5"
+        },
+        {
+          "a0": "AK",
+          "a1": null,
+          "a2": "123.456",
+          "a3": 2.2,
+          "a4": 100,
+          "a5": 3.3,
+          "a6": 4.4,
+          "a7": 5.5,
+          "a8": 6.6,
+          "a9": 7.7,
+          "a10": 8.8,
+          "a11": 9.9,
+          "a12": 10.1,
+          "a13": 100
+        },
+        {
+          "a0": "AR",
+          "a1": "Dallas",
+          "a2": 23.23,
+          "a3": 24.24,
+          "a4": 100,
+          "a5": 25.25,
+          "a6": 26.26,
+          "a7": 27.27,
+          "a8": 28.28,
+          "a9": 29.29,
+          "a10": 30.3,
+          "a11": 31.31,
+          "a12": 32.32,
+          "a13": 100
+        },
+        {
+          "a0": "AR",
+          "a1": "Montgomery",
+          "a2": 34.34,
+          "a3": 35.35,
+          "a4": 100,
+          "a5": 36.36,
+          "a6": 37.37,
+          "a7": 38.38,
+          "a8": 39.39,
+          "a9": 40.4,
+          "a10": 41.41,
+          "a11": 42.42,
+          "a12": 43.43,
+          "a13": 100
+        },
+        {
+          "a0": "AR",
+          "a1": "Nevada",
+          "a2": 45.45,
+          "a3": 46.46,
+          "a4": 100,
+          "a5": 47.47,
+          "a6": 48.48,
+          "a7": 49.49,
+          "a8": 50.5,
+          "a9": 51.51,
+          "a10": 52.52,
+          "a11": 53.53,
+          "a12": 54.54,
+          "a13": 100
+        },
+        {
+          "a0": "AR",
+          "a1": "Newton",
+          "a2": 56.56,
+          "a3": 57.57,
+          "a4": 100,
+          "a5": 58.58,
+          "a6": 59.59,
+          "a7": 60.6,
+          "a8": 61.61,
+          "a9": 62.62,
+          "a10": 63.63,
+          "a11": 64.64,
+          "a12": 65.65,
+          "a13": 100
+        },
+        {
+          "a0": "AR",
+          "a1": "Pike",
+          "a2": 67.67,
+          "a3": 68.68,
+          "a4": 100,
+          "a5": 69.69,
+          "a6": 70.7,
+          "a7": 71.71,
+          "a8": 72.72,
+          "a9": 73.73,
+          "a10": 74.74,
+          "a11": 75.75,
+          "a12": 76.76,
+          "a13": 100
+        },
+        {
+          "a0": "AR",
+          "a1": "Abc",
+          "a2": 2,
+          "a3": 3,
+          "a4": 100,
+          "a5": 4,
+          "a6": 5,
+          "a7": 6,
+          "a8": 7,
+          "a9": 8,
+          "a10": 9,
+          "a11": 10,
+          "a12": 11,
+          "a13": 100
+        },
+        {
+          "a0": "AR",
+          "a1": null,
+          "a2": 78.78,
+          "a3": 79.79,
+          "a4": 100,
+          "a5": 80.8,
+          "a6": 81.81,
+          "a7": 82.82,
+          "a8": 83.83,
+          "a9": 84.84,
+          "a10": 85.85,
+          "a11": 86.86,
+          "a12": 87.87,
+          "a13": 100
+        },
+        {
+          "a0": "TN",
+          "a1": "Xyz",
+          "a2": 10,
+          "a3": 9,
+          "a4": 100,
+          "a5": 8,
+          "a6": 7,
+          "a7": 6,
+          "a8": 5,
+          "a9": 4,
+          "a10": 3,
+          "a11": 2,
+          "a12": 1,
+          "a13": 100
+        },
+        {
+          "a0": "AZ",
+          "a1": "Apache",
+          "a2": 89.89,
+          "a3": 90.9,
+          "a4": 100,
+          "a5": 91.91,
+          "a6": 92.92,
+          "a7": 93.93,
+          "a8": 94.94,
+          "a9": 95.95,
+          "a10": 96.96,
+          "a11": 97.97,
+          "a12": 98.98,
+          "a13": 100
+        }
+      ],
+      "perm": "view"
+    }
+  },
+  {
+    "message": "save_grid: grid modification not allowed",
+    "details": {
+      "data": [
+        [
+          "",
+          "",
+          "Conventional",
+          "Conventional",
+          "FHA",
+          "FHA",
+          "FHA",
+          "FHA",
+          "VA",
+          "VA",
+          "VA",
+          "VA",
+          "VA",
+          "VA"
+        ],
+        [
+          "",
+          "",
+          null,
+          null,
+          null,
+          "Condominium",
+          null,
+          null,
+          "Condominium",
+          null,
+          null,
+          null,
+          null,
+          null
+        ],
+        [
+          "",
+          "",
+          "<=1",
+          ">1",
+          "<1",
+          ">=1",
+          "<=1",
+          ">1",
+          ">=1",
+          "<=1",
+          ">1<=2",
+          ">2<=3",
+          ">3<=4",
+          ">5"
+        ],
+        [
+          "AK",
+          null,
+          "123.456",
+          2.2,
+          100,
+          3.3,
+          4.4,
+          5.5,
+          6.6,
+          7.7,
+          8.8,
+          9.9,
+          10.1,
+          100
+        ],
+        [
+          "AR",
+          "Montgomery",
+          34.34,
+          35.35,
+          100,
+          36.36,
+          37.37,
+          38.38,
+          39.39,
+          40.4,
+          41.41,
+          42.42,
+          43.43,
+          100
+        ],
+        [
+          "AR",
+          "Nevada",
+          45.45,
+          46.46,
+          100,
+          47.47,
+          48.48,
+          49.49,
+          50.5,
+          51.51,
+          52.52,
+          53.53,
+          54.54,
+          100
+        ],
+        [
+          "AR",
+          "Newton",
+          56.56,
+          57.57,
+          100,
+          58.58,
+          59.59,
+          60.6,
+          61.61,
+          62.62,
+          63.63,
+          64.64,
+          65.65,
+          100
+        ],
+        [
+          "AR",
+          "Pike",
+          67.67,
+          68.68,
+          100,
+          69.69,
+          70.7,
+          71.71,
+          72.72,
+          73.73,
+          74.74,
+          75.75,
+          76.76,
+          100
+        ],
+        [
+          "AR",
+          "Abc",
+          2,
+          3,
+          100,
+          4,
+          5,
+          6,
+          7,
+          8,
+          9,
+          10,
+          11,
+          100
+        ],
+        [
+          "AR",
+          null,
+          78.78,
+          79.79,
+          100,
+          80.8,
+          81.81,
+          82.82,
+          83.83,
+          84.84,
+          85.85,
+          86.86,
+          87.87,
+          100
+        ],
+        [
+          "TN",
+          "Xyz",
+          10,
+          9,
+          100,
+          8,
+          7,
+          6,
+          5,
+          4,
+          3,
+          2,
+          1,
+          100
+        ],
+        [
+          "AZ",
+          "Apache",
+          89.89,
+          90.9,
+          100,
+          91.91,
+          92.92,
+          93.93,
+          94.94,
+          95.95,
+          96.96,
+          97.97,
+          98.98,
+          100
+        ]
+      ],
+      "perm": "edit_data"
+    }
+  }
+]

data/spec/models/data_grid_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
-module Marty::DataGridSpec
+module Marty::DataGridSpec # rubocop:disable Metrics/ModuleLength
   describe DataGrid do
-G1 = <<EOS
+    G1 = <<EOS
 state\tstring\tv\t\t
 ltv\tnumrange\tv\t\t
 fico\tnumrange\th\t\t
@@ -15,7 +15,7 @@ MA\t>80<=105\t4.5\t5.6\t
 \t<=80\t11\t22\t33
 EOS
 
-G2 = <<EOS
+    G2 = <<EOS
 units\tinteger\tv\t\t
 ltv\tnumrange\tv\t\t
 cltv\tnumrange\th\t\t
@@ -29,9 +29,9 @@ fico\tnumrange\th\t\t
 3|4\t>80<=105\t4.5\t5.6\t6.7
 EOS
 
-G3 = File.open(File.expand_path('../srp_data.csv', __FILE__)).read
+    G3 = File.open(File.expand_path('../srp_data.csv', __FILE__)).read
 
-G4 = <<EOS
+    G4 = <<EOS
 lenient
 hb_indicator\tboolean\tv
 cltv\tnumrange\th
@@ -40,21 +40,21 @@ cltv\tnumrange\th
 true\t-0.750\t-0.750\t-0.750\t-1.500\t-1.500\t-1.500\t\t
 EOS
 
-G5 = <<EOS
+    G5 = <<EOS
 ltv\tnumrange\tv\t\t
 
 <=115\t-0.375
 >115<=135\t-0.750
 EOS
 
-G6 = <<EOS
+    G6 = <<EOS
 ltv\tnumrange\th
 
 <=115\t>115<=135
 -0.375\t-0.750
 EOS
 
-G7 = <<EOS
+    G7 = <<EOS
 string
 hb_indicator\tboolean\tv
 cltv\tnumrange\th
@@ -63,7 +63,7 @@ cltv\tnumrange\th
 true\tThis\tis\ta\ttest\tof\tstring type\t\t
 EOS
 
-G8 = <<EOS
+    G8 = <<EOS
 Marty::DataGrid
 ltv\tnumrange\tv\t\t
 
@@ -72,7 +72,7 @@ ltv\tnumrange\tv\t\t
 >135<=140\tG3
 EOS
 
-G9 = <<EOS
+    G9 = <<EOS
 state\tstring\tv
 ltv\tnumrange\tv
 
@@ -80,14 +80,14 @@ CA|TX\t>80\t123
 \t>80\t456
 EOS
 
-Ga = <<EOS
+    Ga = <<EOS
 dg\tMarty::DataGrid\tv\t\t
 
 G1|G2\t7
 G3\t8
 EOS
 
-Gb = <<EOS
+    Gb = <<EOS
 property_state\tGemini::State\tv\t\t
 
 CA|TX\t70
@@ -95,28 +95,28 @@ GA\t80
 MN\t90
 EOS
 
-Gc = <<EOS
+    Gc = <<EOS
 Marty::DataGrid
 property_state\tGemini::State\tv\t\t
 
 CA|TX\tGb
 EOS
 
-Gd = <<EOS
+    Gd = <<EOS
 hb_indicator\tboolean\tv
 
 true\t456
 false\t123
 EOS
 
-Ge = <<EOS
+    Ge = <<EOS
 ltv\tnumrange\th
 
 >110\t>120
 1.1\t1.1
 EOS
 
-Gf = <<EOS
+    Gf = <<EOS
 lenient string
 b\tboolean\tv
 i\tinteger\tv
@@ -128,7 +128,7 @@ true\t1\t<10\t<10.0\tY
 false\t\t>10\t\tN
 EOS
 
-Gg = <<EOS
+    Gg = <<EOS
 lenient
 i1\tinteger\tv
 i2\tinteger\tv
@@ -138,7 +138,7 @@ i2\tinteger\tv
 2\t\t20
 EOS
 
-Gh = <<EOS
+    Gh = <<EOS
 lenient
 property_state\tstring\tv
 county_name\tstring\tv
@@ -147,7 +147,7 @@ NY\t\t10
 \tR\t8
 EOS
 
-Gi = <<EOS
+    Gi = <<EOS
 units\tinteger\tv\t\t
 ltv\tfloat\tv\t\t
 cltv\tfloat\th\t\t
@@ -161,7 +161,7 @@ fico\tnumrange\th\t\t
 3|4\t105.5\t4.5\t5.6\t6.7
 EOS
 
-Gj = <<EOS
+    Gj = <<EOS
 lenient
 client_id\tinteger\tv
 property_state\tstring\tv
@@ -170,7 +170,7 @@ property_state\tstring\tv
 700127\tCA\t0.35
 EOS
 
-Gk = <<EOS
+    Gk = <<EOS
 fha_203k_option\tstring\tv\tfha_203k_option
 
 Investor Services\t-0.625
@@ -179,632 +179,695 @@ Admin Services Plus\t-1.625
 Investor Services Acadamy\t-0.5
 EOS
 
-before(:each) do
-  # Mcfly.whodunnit = Marty::User.find_by_login('marty')
-  marty_whodunnit
-end
-
-def lookup_grid_helper(pt, gridname, params, follow = false, distinct = true)
-  dgh = Marty::DataGrid.lookup_h(pt, gridname)
-  res = Marty::DataGrid.lookup_grid_distinct_entry_h(pt, params, dgh, nil, follow,
-                                                     false, distinct)
-  [res['result'], res['name']]
-end
-
-describe 'imports' do
-  it 'should not allow imports with trailing blank columns' do
-    expect do
-      dg_from_import('G1', G1.gsub("\n", "\t\n"))
-    end.to raise_error(RuntimeError)
-  end
-
-  it 'should not allow imports with last blank row' do
-    expect do
-      dg_from_import('Gh', Gh + "\t\t\n")
-    end.to raise_error(RuntimeError)
-  end
-end
-
-describe 'validations' do
-  it 'should not allow bad axis types' do
-    expect do
-      dg_from_import('Gi', Gi)
-    end.to raise_error(/unknown metadata type float/)
-    expect do
-      dg_from_import('Gi', Gi.sub(/float/, 'abcdef'))
-    end.to raise_error(/unknown metadata type abcdef/)
-  end
-
-  it 'should not allow dup attr names' do
-    g_bad = G1.sub(/fico/, 'ltv')
-
-    expect do
-      dg_from_import('G2', g_bad)
-    end.to raise_error(ActiveRecord::RecordInvalid)
-  end
-
-  it 'should not allow dup grid names' do
-    dg_from_import('G1', G1)
-
-    expect do
-      dg_from_import('G1', G2)
-    end.to raise_error(ActiveRecord::RecordInvalid)
-  end
-
-  it 'should not allow extra attr rows' do
-    g_bad = "x\tnumrange\th\t\t\n" + G1
-
-    expect do
-      dg_from_import('G2', g_bad)
-    end.to raise_error(RuntimeError)
-  end
-
-  it 'should not allow dup row/col key combos' do
-    g_bad = G1 + G1.split("\n").last + "\n"
-    expect do
-      dg_from_import('G2', g_bad)
-    end.to raise_error(ActiveRecord::RecordInvalid)
-
-    g_bad = G2 + G2.split("\n").last + "\n"
-    expect do
-      dg_from_import('G2', g_bad)
-    end.to raise_error(ActiveRecord::RecordInvalid)
-  end
-
-  it 'Unknown keys for typed grids should raise error' do
-    g_bad = G8.sub(/G3/, 'XXXXX')
-
-    expect do
-      dg_from_import('G8', g_bad)
-    end.to raise_error(RuntimeError)
-
-    g_bad = G8.sub(/DataGrid/, 'Division')
-
-    expect do
-      dg_from_import('G8', g_bad)
-    end.to raise_error(RuntimeError)
-  end
-
-  it 'Unknown keys for grid headers should raise error' do
-    g_bad = Ga.sub(/G3/, 'XXXXX')
-
-    expect do
-      dg_from_import('Ga', g_bad)
-    end.to raise_error(RuntimeError)
-
-    g_bad = Ga.sub(/DataGrid/, 'Division')
-
-    expect do
-      dg_from_import('Ga', g_bad)
-    end.to raise_error(RuntimeError)
-  end
-
-  it 'validates grid modifier' do
-    bad = ': abc def'
-    g_bad = Gk.sub(/fha_203k_option$/, bad)
-    expect do
-      dg_from_import('Gk', g_bad)
-    end.to raise_error(/invalid grid modifier expression: #{bad}/)
-    expect do
-      dg_from_import('Gk', Gk)
-    end.not_to raise_error
-  end
-end
-
-describe 'lookups for infinity' do
-  let(:pt) { 'infinity' }
-
-  before(:each) do
-    ['G1', 'G2', 'G3', 'G4', 'G5', 'G6', 'G7', 'G8', 'Ga', 'Gb',
-     'Gc', 'Gd', 'Ge', 'Gf', 'Gg', 'Gh', 'Gj'].each do |g|
-      dg_from_import(g, "Marty::DataGridSpec::#{g}".constantize)
+    before(:each) do
+      # Mcfly.whodunnit = Marty::User.find_by_login('marty')
+      marty_whodunnit
     end
-  end
-
-  context 'should handle NULL key values' do
-    let(:dgh) { 'Gf' }
 
-    it 'true returns Y' do
-      res = Marty::DataGrid.lookup_grid_h(pt, dgh, { 'b' => true }, false)
-      expect(res).to eq('Y')
+    def lookup_grid_helper(pt, gridname, params, follow = false, distinct = true)
+      dgh = Marty::DataGrid.lookup_h(pt, gridname)
+      res = Marty::DataGrid.lookup_grid_distinct_entry_h(pt, params, dgh, nil, follow,
+                                                         false, distinct)
+      [res['result'], res['name']]
     end
 
-    it '13 returns N' do
-      res = Marty::DataGrid.lookup_grid_h(pt, dgh, { 'i' => 13 }, true)
-      expect(res).to eq('N')
+    describe 'imports' do
+      it 'should not allow imports with trailing blank columns' do
+        expect do
+          dg_from_import('G1', G1.gsub("\n", "\t\n"))
+        end.to raise_error(RuntimeError)
+      end
+
+      it 'should not allow imports with last blank row' do
+        expect do
+          dg_from_import('Gh', Gh + "\t\t\n")
+        end.to raise_error(RuntimeError)
+      end
     end
 
-    it '13 & numrange 0 returns nil' do
-      res = Marty::DataGrid.lookup_grid_h(pt, dgh, { 'i' => 13, 'n' => 0 }, true)
-      expect(res).to eq('N')
+    describe 'validations' do
+      it 'should not allow bad axis types' do
+        expect do
+          dg_from_import('Gi', Gi)
+        end.to raise_error(/unknown metadata type float/)
+        expect do
+          dg_from_import('Gi', Gi.sub(/float/, 'abcdef'))
+        end.to raise_error(/unknown metadata type abcdef/)
+      end
+
+      it 'should not allow dup attr names' do
+        g_bad = G1.sub(/fico/, 'ltv')
+
+        expect do
+          dg_from_import('G2', g_bad)
+        end.to raise_error(ActiveRecord::RecordInvalid)
+      end
+
+      it 'should not allow dup grid names' do
+        dg_from_import('G1', G1)
+
+        expect do
+          dg_from_import('G1', G2)
+        end.to raise_error(ActiveRecord::RecordInvalid)
+      end
+
+      it 'should not allow extra attr rows' do
+        g_bad = "x\tnumrange\th\t\t\n" + G1
+
+        expect do
+          dg_from_import('G2', g_bad)
+        end.to raise_error(RuntimeError)
+      end
+
+      it 'should not allow dup row/col key combos' do
+        g_bad = G1 + G1.split("\n").last + "\n"
+        expect do
+          dg_from_import('G2', g_bad)
+        end.to raise_error(ActiveRecord::RecordInvalid)
+
+        g_bad = G2 + G2.split("\n").last + "\n"
+        expect do
+          dg_from_import('G2', g_bad)
+        end.to raise_error(ActiveRecord::RecordInvalid)
+      end
+
+      it 'Unknown keys for typed grids should raise error' do
+        g_bad = G8.sub(/G3/, 'XXXXX')
+
+        expect do
+          dg_from_import('G8', g_bad)
+        end.to raise_error(RuntimeError)
+
+        g_bad = G8.sub(/DataGrid/, 'Division')
+
+        expect do
+          dg_from_import('G8', g_bad)
+        end.to raise_error(RuntimeError)
+      end
+
+      it 'Unknown keys for grid headers should raise error' do
+        g_bad = Ga.sub(/G3/, 'XXXXX')
+
+        expect do
+          dg_from_import('Ga', g_bad)
+        end.to raise_error(RuntimeError)
+
+        g_bad = Ga.sub(/DataGrid/, 'Division')
+
+        expect do
+          dg_from_import('Ga', g_bad)
+        end.to raise_error(RuntimeError)
+      end
+
+      it 'validates grid modifier' do
+        bad = ': abc def'
+        g_bad = Gk.sub(/fha_203k_option$/, bad)
+        expect do
+          dg_from_import('Gk', g_bad)
+        end.to raise_error(/invalid grid modifier expression: #{bad}/)
+        expect do
+          dg_from_import('Gk', Gk)
+        end.not_to raise_error
+      end
     end
 
-    it '13 & int4range 15 returns N' do
-      res = Marty::DataGrid.lookup_grid_h(pt, dgh, { 'i' => 13, 'i4' => 15 }, true)
-      expect(res).to eq('N')
-    end
-
-    it '13 & int4range 1 returns nil' do
-      res = Marty::DataGrid.lookup_grid_h(pt, dgh, { 'i' => 13, 'i4' => 1 }, true)
-      expect(res).to be_nil
-    end
-
-    it 'false, 3, numrange 15 returns N' do
-      res = Marty::DataGrid.
-            lookup_grid_h(pt, dgh, { 'b' => false, 'i' => 3, 'n' => 15 }, true)
-      expect(res).to eq('N')
-    end
-
-    it '13, numrange 15 returns N' do
-      res = Marty::DataGrid.lookup_grid_h(pt, dgh, { 'i' => 13, 'n' => 15 }, true)
-      expect(res).to eq('N')
-    end
-  end
-
-  it 'should handle ambiguous lookups' do
-    h1 = {
-      'property_state' => 'NY',
-      'county_name'    => 'R',
-    }
-
-    res = Marty::DataGrid.lookup_grid_h(pt, 'Gh', h1, false)
-    expect(res).to eq(10)
-  end
-
-  it 'should handle ambiguous lookups (2)' do
-    res = Marty::DataGrid.
-          lookup_grid_h(pt, 'Gg', { 'i1' => 2, 'i2' => 1 }, false)
-    expect(res).to eq(1)
-
-    res = Marty::DataGrid.
-          lookup_grid_h(pt, 'Gg', { 'i1' => 3, 'i2' => 1 }, false)
-    expect(res).to eq(1)
-
-    res = Marty::DataGrid.
-          lookup_grid_h(pt, 'Gg', { 'i1' => 2, 'i2' => 3 }, false)
-    expect(res).to eq(20)
-  end
-
-  it 'should handle non-distinct lookups' do
-    res = Marty::DataGrid.lookup_grid_h(pt, 'Ge', { 'ltv' => 500 }, false)
-
-    expect(res).to eq(1.1)
-
-    expect do
-      Marty::DataGrid.lookup_grid_h(pt, 'Ge', { 'ltv' => 500 }, true)
-    end.to raise_error(RuntimeError)
-  end
-
-  it 'should handle non-distinct lookups (2)' do
-    params = {
-      'client_id' => 700127,
-      'property_state' => 'CA',
-    }
-    res = Marty::DataGrid.lookup_grid_h(pt, 'Gj', params, false)
-
-    # should return the upper left corner match
-    expect(res).to eq(0.25)
-
-    expect do
-      Marty::DataGrid.lookup_grid_h(pt, 'Gj', params, true)
-    end.to raise_error(RuntimeError)
-  end
-
-  it 'should handle boolean lookups' do
-    res = [true, false].map do |hb_indicator|
-      lookup_grid_helper('infinity',
-                         'Gd',
-                         'hb_indicator' => hb_indicator,
-                        )
-    end
-    expect(res).to eq [[456.0, 'Gd'], [123.0, 'Gd']]
-  end
-
-  it 'should handle basic lookups' do
-    res = lookup_grid_helper('infinity',
-                             'G3',
-                             'amount' => 160300,
-                             'state' => 'HI',
-                            )
-    expect(res).to eq [1.655, 'G3']
-
-    [3, 4].each do |units|
-      res = lookup_grid_helper('infinity',
-                               'G2',
-                               'fico' => 720,
-                               'units' => units,
-                               'ltv' => 100,
-                               'cltv' => 110.1,
-                              )
-      expect(res).to eq [5.6, 'G2']
-    end
-
-    dg = Marty::DataGrid.find_by(obsoleted_dt: 'infinity', name: 'G1')
-
-    h = {
-      'fico' => 600,
-      'state' => 'RI',
-      'ltv' => 10,
-    }
-
-    res = lookup_grid_helper('infinity', 'G1', h)
-    expect(res).to eq [11, 'G1']
-
-    dg.update_from_import('G1', G1.sub(/11/, '111'))
-
-    res = lookup_grid_helper('infinity', 'G1', h)
-    expect(res).to eq [111, 'G1']
-  end
-
-  it 'should result in error when there are multiple cell hits' do
-    expect do
-      lookup_grid_helper('infinity',
-                         'G2',
-                         'fico' => 720,
-                         'ltv' => 100,
-                         'cltv' => 110.1,
-                        )
-    end.to raise_error(RuntimeError)
-  end
-
-  it 'should return nil when matching data grid cell is nil' do
-    res = lookup_grid_helper('infinity',
-                             'G1',
-                             'fico' => 800,
-                             'state' => 'MA',
-                             'ltv' => 81,
+    describe 'lookups for infinity' do
+      let(:pt) { 'infinity' }
+
+      before(:each) do
+        ['G1', 'G2', 'G3', 'G4', 'G5', 'G6', 'G7', 'G8', 'Ga', 'Gb',
+         'Gc', 'Gd', 'Ge', 'Gf', 'Gg', 'Gh', 'Gj'].each do |g|
+          dg_from_import(g, "Marty::DataGridSpec::#{g}".constantize)
+        end
+      end
+
+      context 'should handle NULL key values' do
+        let(:dgh) { 'Gf' }
+
+        it 'true returns Y' do
+          res = Marty::DataGrid.lookup_grid_h(pt, dgh, { 'b' => true }, false)
+          expect(res).to eq('Y')
+        end
+
+        it '13 returns N' do
+          res = Marty::DataGrid.lookup_grid_h(pt, dgh, { 'i' => 13 }, true)
+          expect(res).to eq('N')
+        end
+
+        it '13 & numrange 0 returns nil' do
+          res = Marty::DataGrid.lookup_grid_h(pt, dgh, { 'i' => 13, 'n' => 0 }, true)
+          expect(res).to eq('N')
+        end
+
+        it '13 & int4range 15 returns N' do
+          res = Marty::DataGrid.lookup_grid_h(pt, dgh, { 'i' => 13, 'i4' => 15 }, true)
+          expect(res).to eq('N')
+        end
+
+        it '13 & int4range 1 returns nil' do
+          res = Marty::DataGrid.lookup_grid_h(pt, dgh, { 'i' => 13, 'i4' => 1 }, true)
+          expect(res).to be_nil
+        end
+
+        it 'false, 3, numrange 15 returns N' do
+          res = Marty::DataGrid.
+                  lookup_grid_h(pt, dgh, { 'b' => false, 'i' => 3, 'n' => 15 }, true)
+          expect(res).to eq('N')
+        end
+
+        it '13, numrange 15 returns N' do
+          res = Marty::DataGrid.lookup_grid_h(pt, dgh, { 'i' => 13, 'n' => 15 }, true)
+          expect(res).to eq('N')
+        end
+      end
+
+      it 'should handle ambiguous lookups' do
+        h1 = {
+          'property_state' => 'NY',
+          'county_name'    => 'R',
+        }
+
+        res = Marty::DataGrid.lookup_grid_h(pt, 'Gh', h1, false)
+        expect(res).to eq(10)
+      end
+
+      it 'should handle ambiguous lookups (2)' do
+        res = Marty::DataGrid.
+                lookup_grid_h(pt, 'Gg', { 'i1' => 2, 'i2' => 1 }, false)
+        expect(res).to eq(1)
+
+        res = Marty::DataGrid.
+                lookup_grid_h(pt, 'Gg', { 'i1' => 3, 'i2' => 1 }, false)
+        expect(res).to eq(1)
+
+        res = Marty::DataGrid.
+                lookup_grid_h(pt, 'Gg', { 'i1' => 2, 'i2' => 3 }, false)
+        expect(res).to eq(20)
+      end
+
+      it 'should handle non-distinct lookups' do
+        res = Marty::DataGrid.lookup_grid_h(pt, 'Ge', { 'ltv' => 500 }, false)
+
+        expect(res).to eq(1.1)
+
+        expect do
+          Marty::DataGrid.lookup_grid_h(pt, 'Ge', { 'ltv' => 500 }, true)
+        end.to raise_error(RuntimeError)
+      end
+
+      it 'should handle non-distinct lookups (2)' do
+        params = {
+          'client_id' => 700127,
+          'property_state' => 'CA',
+        }
+        res = Marty::DataGrid.lookup_grid_h(pt, 'Gj', params, false)
+
+        # should return the upper left corner match
+        expect(res).to eq(0.25)
+
+        expect do
+          Marty::DataGrid.lookup_grid_h(pt, 'Gj', params, true)
+        end.to raise_error(RuntimeError)
+      end
+
+      it 'should handle boolean lookups' do
+        res = [true, false].map do |hb_indicator|
+          lookup_grid_helper('infinity',
+                             'Gd',
+                             'hb_indicator' => hb_indicator,
                             )
-    expect(res).to eq [nil, 'G1']
-  end
-
-  it 'should handle string wildcards' do
-    res = lookup_grid_helper('infinity',
-                             'G1',
+        end
+        expect(res).to eq [[456.0, 'Gd'], [123.0, 'Gd']]
+      end
+
+      it 'should handle basic lookups' do
+        res = lookup_grid_helper('infinity',
+                                 'G3',
+                                 'amount' => 160300,
+                                 'state' => 'HI',
+                                )
+        expect(res).to eq [1.655, 'G3']
+
+        [3, 4].each do |units|
+          res = lookup_grid_helper('infinity',
+                                   'G2',
+                                   'fico' => 720,
+                                   'units' => units,
+                                   'ltv' => 100,
+                                   'cltv' => 110.1,
+                                  )
+          expect(res).to eq [5.6, 'G2']
+        end
+
+        dg = Marty::DataGrid.find_by(obsoleted_dt: 'infinity', name: 'G1')
+
+        h = {
+          'fico' => 600,
+          'state' => 'RI',
+          'ltv' => 10,
+        }
+
+        res = lookup_grid_helper('infinity', 'G1', h)
+        expect(res).to eq [11, 'G1']
+
+        dg.update_from_import('G1', G1.sub(/11/, '111'))
+
+        res = lookup_grid_helper('infinity', 'G1', h)
+        expect(res).to eq [111, 'G1']
+      end
+
+      it 'should result in error when there are multiple cell hits' do
+        expect do
+          lookup_grid_helper('infinity',
+                             'G2',
                              'fico' => 720,
-                             'state' => 'GU',
-                             'ltv' => 80,
+                             'ltv' => 100,
+                             'cltv' => 110.1,
                             )
-    expect(res).to eq [22, 'G1']
-  end
-
-  it 'should handle matches which also have a wildcard match' do
-    dg_from_import('G9', G9)
-
-    expect do
-      res = lookup_grid_helper('infinity',
-                               'G9',
-                               'state' => 'CA', 'ltv' => 81,
-                              )
-    end.to raise_error(RuntimeError)
-
-    res = lookup_grid_helper('infinity',
+        end.to raise_error(RuntimeError)
+      end
+
+      it 'should return nil when matching data grid cell is nil' do
+        res = lookup_grid_helper('infinity',
+                                 'G1',
+                                 'fico' => 800,
+                                 'state' => 'MA',
+                                 'ltv' => 81,
+                                )
+        expect(res).to eq [nil, 'G1']
+      end
+
+      it 'should handle string wildcards' do
+        res = lookup_grid_helper('infinity',
+                                 'G1',
+                                 'fico' => 720,
+                                 'state' => 'GU',
+                                 'ltv' => 80,
+                                )
+        expect(res).to eq [22, 'G1']
+      end
+
+      it 'should handle matches which also have a wildcard match' do
+        dg_from_import('G9', G9)
+
+        expect do
+          res = lookup_grid_helper('infinity',
+                                   'G9',
+                                   'state' => 'CA', 'ltv' => 81,
+                                  )
+        end.to raise_error(RuntimeError)
+
+        res = lookup_grid_helper('infinity',
+                                 'G9',
+                                 'state' => 'GU', 'ltv' => 81,
+                                )
+        expect(res).to eq [456, 'G9']
+      end
+
+      it 'should raise on nil attr values' do
+        dg_from_import('G9', G9)
+
+        expect do
+          lookup_grid_helper('infinity',
                              'G9',
-                             'state' => 'GU', 'ltv' => 81,
+                             'ltv' => 81,
                             )
-    expect(res).to eq [456, 'G9']
-  end
+        end.to raise_error(/matches > 1/)
 
-  it 'should raise on nil attr values' do
-    dg_from_import('G9', G9)
-
-    expect do
-      lookup_grid_helper('infinity',
-                         'G9',
-                         'ltv' => 81,
-                        )
-    end        .to raise_error(/matches > 1/)
-
-    err = /Data Grid lookup failed/
-    expect do
-      lookup_grid_helper('infinity',
-                         'G9',
-                         { 'state' => 'CA', 'ltv' => nil },
-                         false, false)
-    end        .to raise_error(err)
-
-    res = lookup_grid_helper('infinity',
+        err = /Data Grid lookup failed/
+        expect do
+          lookup_grid_helper('infinity',
                              'G9',
-                             { 'state' => nil, 'ltv' => 81 },
+                             { 'state' => 'CA', 'ltv' => nil },
                              false, false)
-
-    expect(res).to eq [456, 'G9']
-  end
-
-  it 'should handle boolean keys' do
-    res = lookup_grid_helper('infinity',
-                             'G4',
-                             'hb_indicator' => true,
-                             'cltv' => 80,
-                            )
-    expect(res).to eq [-1.5, 'G4']
-
-    res = lookup_grid_helper('infinity',
-                             'G4',
-                             'hb_indicator' => false,
-                             'cltv' => 80,
-                            )
-    expect(res).to eq [nil, 'G4']
-  end
-
-  it 'should handle vertical-only grids' do
-    res = lookup_grid_helper('infinity',
-                             'G5',
-                             'ltv' => 80,
-                            )
-    expect(res).to eq [-0.375, 'G5']
-  end
-
-  it 'should handle horiz-only grids' do
-    res = lookup_grid_helper('infinity',
-                             'G6',
-                             'ltv' => 80, 'conforming' => true,
-                            )
-    expect(res).to eq [-0.375, 'G6']
-  end
-
-  it 'should handle string typed data grids' do
-    expect(Marty::DataGrid.lookup('infinity', 'G7').data_type).to eq 'string'
-
-    res = lookup_grid_helper('infinity',
-                             'G7',
-                             'hb_indicator' => true,
-                             'cltv' => 80,
-                            )
-    expect(res).to eq ['test', 'G7']
-  end
-
-  it 'should handle DataGrid typed data grids' do
-    expect(Marty::DataGrid.lookup('infinity', 'G8').data_type).
-      to eq 'Marty::DataGrid'
-    g1 = Marty::DataGrid.lookup('infinity', 'G1')
-
-    res = lookup_grid_helper('infinity', 'G8', 'ltv' => 80)
-    expect(res).to eq [g1, 'G8']
-  end
-
-  it 'should handle multi DataGrid lookups' do
-    expect(Marty::DataGrid.lookup('infinity', 'G8').data_type).
-      to eq 'Marty::DataGrid'
-
-    h = {
-      'fico' => 600,
-      'state' => 'RI',
-      'ltv' => 10,
-    }
-
-    g1_res = lookup_grid_helper('infinity', 'G1', h)
-    expect(g1_res).to eq [11, 'G1']
-
-    res = lookup_grid_helper('infinity', 'G8', h, true)
-
-    expect(g1_res).to eq res
-
-    # make sure lookup_grid_h works too
-    res_h = Marty::DataGrid.lookup_grid_h('infinity', 'G8', h, true)
-
-    expect(g1_res[0]).to eq res_h
-  end
-
-  it 'should handle DataGrid typed data grids' do
-    g1 = Marty::DataGrid.find_by(obsoleted_dt: 'infinity', name: 'G1')
-
-    res = lookup_grid_helper('infinity', 'Ga', 'dg' => g1)
-    expect(res).to eq [7, 'Ga']
-
-    # should be able to lookup bu name as well
-    res = lookup_grid_helper('infinity', 'Ga', 'dg' => 'G2')
-
-    expect(res).to eq [7, 'Ga']
-  end
-
-  it 'should handle DataGrid typed data grids -- non mcfly' do
-    ca = Gemini::State.find_by_name('CA')
-
-    res = lookup_grid_helper('infinity', 'Gb', 'property_state' => ca)
-    expect(res).to eq [70, 'Gb']
-
-    # should be able to lookup bu name as well
-    res = lookup_grid_helper('infinity', 'Gb', 'property_state' => 'CA')
-    expect(res).to eq [70, 'Gb']
-  end
-
-  it 'should handle typed (enum) data lookup_grid' do
-    pt = 'infinity'
-    ca = Gemini::State.find_by_name('CA')
-
-    res = Marty::DataGrid.
-          lookup_grid_h(pt, 'Gb', { 'property_state' => ca }, false)
-
-    expect(res).to eq 70
-  end
-
-  it 'should return grid data and metadata simple' do
-    expected_data = [[1.1, 2.2, 3.3], [4.4, 5.5, 6.6], [1.2, 2.3, 3.4],
-                     [4.5, 5.6, 6.7]]
-    expected_metadata = [{ 'dir' => 'v',
-                          'attr' => 'units',
-                          'keys' => [[1, 2], [1, 2], [3, 4], [3, 4]],
-                          'type' => 'integer' },
-                         { 'dir' => 'v',
-                          'attr' => 'ltv',
-                          'keys' => ['[,80]', '(80,105]', '[,80]', '(80,105]'],
-                          'type' => 'numrange' },
-                         { 'dir' => 'h',
-                          'attr' => 'cltv',
-                          'keys' => ['[100,110)', '[110,120)', '[120,]'],
-                          'type' => 'numrange' },
-                         { 'dir' => 'h',
-                          'attr' => 'fico',
-                          'keys' => ['[600,700)', '[700,750)', '[750,]'],
-                          'type' => 'numrange' }]
-
-    dgh = Marty::DataGrid.lookup_h(pt, 'G2')
-    res = Marty::DataGrid.lookup_grid_distinct_entry_h(pt, {}, dgh,
-                                                       nil, true, true)
-    expect(res['data']).to eq expected_data
-    expect(res['metadata']).to eq expected_metadata
-  end
-
-  it 'should return grid data and metadata multi (following)' do
-    expected_data = [[1.1, 2.2, 3.3], [4.4, 5.5, 6.6], [1.2, 2.3, 3.4],
-                     [4.5, 5.6, nil], [11.0, 22.0, 33.0]]
-    expected_metadata = [{ 'dir' => 'v',
-                          'attr' => 'state',
-                          'keys' => [['CA'], ['HI', 'TX'], ['NM'], ['MA'], nil],
-                          'type' => 'string' },
-                         { 'dir' => 'v',
-                          'attr' => 'ltv',
-                          'keys' => ['[,80]', '(80,105]', '[,80]', '(80,105]',
-                                     '[,80]'],
-                          'type' => 'numrange' },
-                         { 'dir' => 'h',
-                          'attr' => 'fico',
-                          'keys' => ['[600,700)', '[700,750)', '[750,]'],
-                          'type' => 'numrange' }]
-    dgh = Marty::DataGrid.lookup_h(pt, 'G8')
-    res = Marty::DataGrid.lookup_grid_distinct_entry_h(pt,
-                                                       { 'ltv' => 10,
-                                                         'state' => 'RI' },
-                                                       dgh, nil, true,
-                                                       true)
-    expect(res['data']).to eq expected_data
-    expect(res['metadata']).to eq expected_metadata
-  end
-
-  it 'should return grid data and metadata multi (not following)' do
-    expected_data = [['G1'], ['G2'], ['G3']]
-    expected_metadata = [{ 'dir' => 'v',
-                          'attr' => 'ltv',
-                          'keys' => ['[,115]', '(115,135]', '(135,140]'],
-                          'type' => 'numrange' }]
-    dgh = Marty::DataGrid.lookup_h(pt, 'G8')
-    res = Marty::DataGrid.lookup_grid_distinct_entry_h(pt,
-                                                       { 'ltv' => 10,
-                                                         'state' => 'RI' },
-                                                       dgh, nil, false,
-                                                       true)
-    expect(res['data']).to eq expected_data
-    expect(res['metadata']).to eq expected_metadata
-  end
-
-  it 'should handle all characters in grid inputs' do
-    dgh = Marty::DataGrid.lookup_h(pt, 'G1')
-    5000.times do
-      st = 30.times.map { rand(32..255) }.pack('U*')
-      res = Marty::DataGrid.lookup_grid_distinct_entry_h(pt,
-                                                         { 'ltv' => 10,
-                                                           'fico' => 690,
-                                                           'state' => st },
-                                                         dgh, nil, false, true)
+        end.to raise_error(err)
+
+        res = lookup_grid_helper('infinity',
+                                 'G9',
+                                 { 'state' => nil, 'ltv' => 81 },
+                                 false, false)
+
+        expect(res).to eq [456, 'G9']
+      end
+
+      it 'should handle boolean keys' do
+        res = lookup_grid_helper('infinity',
+                                 'G4',
+                                 'hb_indicator' => true,
+                                 'cltv' => 80,
+                                )
+        expect(res).to eq [-1.5, 'G4']
+
+        res = lookup_grid_helper('infinity',
+                                 'G4',
+                                 'hb_indicator' => false,
+                                 'cltv' => 80,
+                                )
+        expect(res).to eq [nil, 'G4']
+      end
+
+      it 'should handle vertical-only grids' do
+        res = lookup_grid_helper('infinity',
+                                 'G5',
+                                 'ltv' => 80,
+                                )
+        expect(res).to eq [-0.375, 'G5']
+      end
+
+      it 'should handle horiz-only grids' do
+        res = lookup_grid_helper('infinity',
+                                 'G6',
+                                 'ltv' => 80, 'conforming' => true,
+                                )
+        expect(res).to eq [-0.375, 'G6']
+      end
+
+      it 'should handle string typed data grids' do
+        expect(Marty::DataGrid.lookup('infinity', 'G7').data_type).to eq 'string'
+
+        res = lookup_grid_helper('infinity',
+                                 'G7',
+                                 'hb_indicator' => true,
+                                 'cltv' => 80,
+                                )
+        expect(res).to eq ['test', 'G7']
+      end
+
+      it 'should handle DataGrid typed data grids' do
+        expect(Marty::DataGrid.lookup('infinity', 'G8').data_type).
+          to eq 'Marty::DataGrid'
+        g1 = Marty::DataGrid.lookup('infinity', 'G1')
+
+        res = lookup_grid_helper('infinity', 'G8', 'ltv' => 80)
+        expect(res).to eq [g1, 'G8']
+      end
+
+      it 'should handle multi DataGrid lookups' do
+        expect(Marty::DataGrid.lookup('infinity', 'G8').data_type).
+          to eq 'Marty::DataGrid'
+
+        h = {
+          'fico' => 600,
+          'state' => 'RI',
+          'ltv' => 10,
+        }
+
+        g1_res = lookup_grid_helper('infinity', 'G1', h)
+        expect(g1_res).to eq [11, 'G1']
+
+        res = lookup_grid_helper('infinity', 'G8', h, true)
+
+        expect(g1_res).to eq res
+
+        # make sure lookup_grid_h works too
+        res_h = Marty::DataGrid.lookup_grid_h('infinity', 'G8', h, true)
+
+        expect(g1_res[0]).to eq res_h
+      end
+
+      it 'should handle DataGrid typed data grids' do
+        g1 = Marty::DataGrid.find_by(obsoleted_dt: 'infinity', name: 'G1')
+
+        res = lookup_grid_helper('infinity', 'Ga', 'dg' => g1)
+        expect(res).to eq [7, 'Ga']
+
+        # should be able to lookup bu name as well
+        res = lookup_grid_helper('infinity', 'Ga', 'dg' => 'G2')
+
+        expect(res).to eq [7, 'Ga']
+      end
+
+      it 'should handle DataGrid typed data grids -- non mcfly' do
+        ca = Gemini::State.find_by_name('CA')
+
+        res = lookup_grid_helper('infinity', 'Gb', 'property_state' => ca)
+        expect(res).to eq [70, 'Gb']
+
+        # should be able to lookup bu name as well
+        res = lookup_grid_helper('infinity', 'Gb', 'property_state' => 'CA')
+        expect(res).to eq [70, 'Gb']
+      end
+
+      it 'should handle typed (enum) data lookup_grid' do
+        pt = 'infinity'
+        ca = Gemini::State.find_by_name('CA')
+
+        res = Marty::DataGrid.
+                lookup_grid_h(pt, 'Gb', { 'property_state' => ca }, false)
+
+        expect(res).to eq 70
+      end
+
+      it 'should return grid data and metadata simple' do
+        expected_data = [[1.1, 2.2, 3.3], [4.4, 5.5, 6.6], [1.2, 2.3, 3.4],
+                         [4.5, 5.6, 6.7]]
+        expected_metadata = [{ 'dir' => 'v',
+                               'attr' => 'units',
+                               'keys' => [[1, 2], [1, 2], [3, 4], [3, 4]],
+                               'type' => 'integer' },
+                             { 'dir' => 'v',
+                               'attr' => 'ltv',
+                               'keys' => ['[,80]', '(80,105]', '[,80]', '(80,105]'],
+                               'type' => 'numrange' },
+                             { 'dir' => 'h',
+                               'attr' => 'cltv',
+                               'keys' => ['[100,110)', '[110,120)', '[120,]'],
+                               'type' => 'numrange' },
+                             { 'dir' => 'h',
+                               'attr' => 'fico',
+                               'keys' => ['[600,700)', '[700,750)', '[750,]'],
+                               'type' => 'numrange' }]
+
+        dgh = Marty::DataGrid.lookup_h(pt, 'G2')
+        res = Marty::DataGrid.lookup_grid_distinct_entry_h(pt, {}, dgh,
+                                                           nil, true, true)
+        expect(res['data']).to eq expected_data
+        expect(res['metadata']).to eq expected_metadata
+      end
+
+      it 'should return grid data and metadata multi (following)' do
+        expected_data = [[1.1, 2.2, 3.3], [4.4, 5.5, 6.6], [1.2, 2.3, 3.4],
+                         [4.5, 5.6, nil], [11.0, 22.0, 33.0]]
+        expected_metadata = [{ 'dir' => 'v',
+                               'attr' => 'state',
+                               'keys' => [['CA'], ['HI', 'TX'], ['NM'], ['MA'], nil],
+                               'type' => 'string' },
+                             { 'dir' => 'v',
+                               'attr' => 'ltv',
+                               'keys' => ['[,80]', '(80,105]', '[,80]', '(80,105]',
+                                          '[,80]'],
+                               'type' => 'numrange' },
+                             { 'dir' => 'h',
+                               'attr' => 'fico',
+                               'keys' => ['[600,700)', '[700,750)', '[750,]'],
+                               'type' => 'numrange' }]
+        dgh = Marty::DataGrid.lookup_h(pt, 'G8')
+        res = Marty::DataGrid.lookup_grid_distinct_entry_h(pt,
+                                                           { 'ltv' => 10,
+                                                             'state' => 'RI' },
+                                                           dgh, nil, true,
+                                                           true)
+        expect(res['data']).to eq expected_data
+        expect(res['metadata']).to eq expected_metadata
+      end
+
+      it 'should return grid data and metadata multi (not following)' do
+        expected_data = [['G1'], ['G2'], ['G3']]
+        expected_metadata = [{ 'dir' => 'v',
+                               'attr' => 'ltv',
+                               'keys' => ['[,115]', '(115,135]', '(135,140]'],
+                               'type' => 'numrange' }]
+        dgh = Marty::DataGrid.lookup_h(pt, 'G8')
+        res = Marty::DataGrid.lookup_grid_distinct_entry_h(pt,
+                                                           { 'ltv' => 10,
+                                                             'state' => 'RI' },
+                                                           dgh, nil, false,
+                                                           true)
+        expect(res['data']).to eq expected_data
+        expect(res['metadata']).to eq expected_metadata
+      end
+
+      it 'should handle all characters in grid inputs' do
+        dgh = Marty::DataGrid.lookup_h(pt, 'G1')
+        5000.times do
+          st = 30.times.map { rand(32..255) }.pack('U*')
+          res = Marty::DataGrid.lookup_grid_distinct_entry_h(pt,
+                                                             { 'ltv' => 10,
+                                                               'fico' => 690,
+                                                               'state' => st },
+                                                             dgh, nil, false, true)
+        end
+      end
+      it 'should handle all quote chars in grid inputs' do
+        dgh = Marty::DataGrid.lookup_h(pt, 'G1')
+        # single, double, backslash, grave, acute, unicode quotes: left single,
+        # right single, left double, right double
+        quotes = ["'", '"', '\\', '`', "\u00b4", "\u2018", "\u2019",
+                  "\u201C", "\u201D"]
+        100.times do
+          st = 30.times.map { quotes[rand(9)] }.join
+          res = Marty::DataGrid.lookup_grid_distinct_entry_h(
+            pt, { 'ltv' => 10, 'fico' => 690, 'state' => st }, dgh, nil, false, true)
+        end
+      end
+      it 'should handle quote chars in object name' do
+        dgh = Marty::DataGrid.lookup_h(pt, 'G1')
+        st = Gemini::State.new(name: "'\\")
+        res = Marty::DataGrid.lookup_grid_distinct_entry_h(
+          pt, { 'ltv' => 10, 'fico' => 690, 'state' => st }, dgh, nil, false, true)
+      end
     end
-  end
-  it 'should handle all quote chars in grid inputs' do
-    dgh = Marty::DataGrid.lookup_h(pt, 'G1')
-    # single, double, backslash, grave, acute, unicode quotes: left single,
-    # right single, left double, right double
-    quotes = ["'", '"', '\\', '`', "\u00b4", "\u2018", "\u2019",
-              "\u201C", "\u201D"]
-    100.times do
-      st = 30.times.map { quotes[rand(9)] }.join
-      res = Marty::DataGrid.lookup_grid_distinct_entry_h(
-        pt, { 'ltv' => 10, 'fico' => 690, 'state' => st }, dgh, nil, false, true)
-    end
-  end
-  it 'should handle quote chars in object name' do
-    dgh = Marty::DataGrid.lookup_h(pt, 'G1')
-    st = Gemini::State.new(name: "'\\")
-    res = Marty::DataGrid.lookup_grid_distinct_entry_h(
-      pt, { 'ltv' => 10, 'fico' => 690, 'state' => st }, dgh, nil, false, true)
-  end
-end
-
-describe 'exports' do
-  it 'should export lenient grids correctly' do
-    dg = dg_from_import('Gf', Gf)
-    dg2 = dg_from_import('Gf2', dg.export)
-
-    expect(dg.export).to eq(dg2.export)
-  end
-end
-
-describe 'updates' do
-  it 'should be possible to modify a grid referenced from a multi-grid' do
-    dgb = dg_from_import('Gb', Gb, '1/1/2014')
-    dgc = dg_from_import('Gc', Gc, '2/2/2014')
-
-    dgb.update_from_import('Gb', Gb.sub(/70/, '333'), '1/1/2015')
-    dgb.update_from_import('Gb', Gb.sub(/70/, '444'), '1/1/2016')
 
-    dgch = dgc.attributes.
-           slice('id', 'group_id', 'created_dt',  'metadata', 'data_type')
-    res = Marty::DataGrid.lookup_grid_distinct_entry_h(
-      '2/2/2014', { 'property_state' => 'CA' }, dgch)
-    expect(res['result']).to eq(70)
+    describe 'exports' do
+      it 'should export lenient grids correctly' do
+        dg = dg_from_import('Gf', Gf)
+        dg2 = dg_from_import('Gf2', dg.export)
 
-    res = Marty::DataGrid.lookup_grid_distinct_entry_h(
-      '2/2/2015', { 'property_state' => 'CA' }, dgch)
-    expect(res['result']).to eq(333)
-
-    res = Marty::DataGrid.lookup_grid_distinct_entry_h(
-      '2/2/2016', { 'property_state' => 'CA' }, dgch)
-    expect(res['result']).to eq(444)
-  end
-
-  it 'should not create a new version if no change has been made' do
-    dg = dg_from_import('G4', G1)
-    dg.update_from_import('G4', G1)
-    expect(Marty::DataGrid.where(group_id: dg.group_id).count).to eq 1
-  end
-
-  it 'should be able to export and import back grids' do
-    [G1, G2, G3, G4, G5, G6, G7, G8, G9, Ga, Gb].each_with_index do |grid, i|
-      dg = dg_from_import("G#{i}", grid)
-      g1 = dg.export
-      dg = dg_from_import("Gx#{i}", g1)
-      g2 = dg.export
-      expect(g1).to eq g2
+        expect(dg.export).to eq(dg2.export)
+      end
     end
-  end
-
-  it 'should be able to externally export/import grids' do
-    load_scripts(nil, Date.today)
-
-    dg = dg_from_import('G1', G1)
-
-    p = posting('BASE', DateTime.tomorrow, '?')
-
-    engine = Marty::ScriptSet.new.get_engine('DataReport')
-    res = engine.evaluate('TableReport',
-                          'result',
-                          'pt_name'    => p.name,
-                          'class_name' => 'Marty::DataGrid',
-                         )
 
-    # FIXME: really hacky removing "" (data_grid) -- This is a bug
-    # in TableReport/CSV generation.
-    res.gsub!(/\"\"/, '')
-    sum = do_import_summary(Marty::DataGrid,
-                            res,
-                            'infinity',
-                            nil,
-                            nil,
-                            ',',
-                           )
-
-    expect(sum).to eq(same: 1)
-
-    res11 = res.sub(/G1/, 'G11')
-
-    sum = do_import_summary(
-      Marty::DataGrid, res11, 'infinity', nil, nil, ',')
-
-    expect(sum).to eq(create: 1)
-
-    g1  = Marty::DataGrid.find_by(obsoleted_dt: 'infinity', name: 'G1')
-    g11 = Marty::DataGrid.find_by(obsoleted_dt: 'infinity', name: 'G11')
+    describe 'updates' do
+      it 'should be possible to modify a grid referenced from a multi-grid' do
+        dgb = dg_from_import('Gb', Gb, '1/1/2014')
+        dgc = dg_from_import('Gc', Gc, '2/2/2014')
+
+        dgb.update_from_import('Gb', Gb.sub(/70/, '333'), '1/1/2015')
+        dgb.update_from_import('Gb', Gb.sub(/70/, '444'), '1/1/2016')
+
+        dgch = dgc.attributes.
+                 slice('id', 'group_id', 'created_dt',  'metadata', 'data_type')
+        res = Marty::DataGrid.lookup_grid_distinct_entry_h(
+          '2/2/2014', { 'property_state' => 'CA' }, dgch)
+        expect(res['result']).to eq(70)
+
+        res = Marty::DataGrid.lookup_grid_distinct_entry_h(
+          '2/2/2015', { 'property_state' => 'CA' }, dgch)
+        expect(res['result']).to eq(333)
+
+        res = Marty::DataGrid.lookup_grid_distinct_entry_h(
+          '2/2/2016', { 'property_state' => 'CA' }, dgch)
+        expect(res['result']).to eq(444)
+      end
+
+      it 'should not create a new version if no change has been made' do
+        dg = dg_from_import('G4', G1)
+        dg.update_from_import('G4', G1)
+        expect(Marty::DataGrid.where(group_id: dg.group_id).count).to eq 1
+      end
+
+      it 'should be able to export and import back grids' do
+        [G1, G2, G3, G4, G5, G6, G7, G8, G9, Ga, Gb].each_with_index do |grid, i|
+          dg = dg_from_import("G#{i}", grid)
+          g1 = dg.export
+          dg = dg_from_import("Gx#{i}", g1)
+          g2 = dg.export
+          expect(g1).to eq g2
+        end
+      end
+
+      it 'should be able to externally export/import grids' do
+        load_scripts(nil, Date.today)
+
+        dg = dg_from_import('G1', G1)
+
+        p = posting('BASE', DateTime.tomorrow, '?')
+
+        engine = Marty::ScriptSet.new.get_engine('DataReport')
+        res = engine.evaluate('TableReport',
+                              'result',
+                              'pt_name'    => p.name,
+                              'class_name' => 'Marty::DataGrid',
+                             )
+
+        # FIXME: really hacky removing "" (data_grid) -- This is a bug
+        # in TableReport/CSV generation.
+        res.gsub!(/\"\"/, '')
+        sum = do_import_summary(Marty::DataGrid,
+                                res,
+                                'infinity',
+                                nil,
+                                nil,
+                                ',',
+                               )
+
+        expect(sum).to eq(same: 1)
+
+        res11 = res.sub(/G1/, 'G11')
+
+        sum = do_import_summary(
+          Marty::DataGrid, res11, 'infinity', nil, nil, ',')
+
+        expect(sum).to eq(create: 1)
+
+        g1  = Marty::DataGrid.find_by(obsoleted_dt: 'infinity', name: 'G1')
+        g11 = Marty::DataGrid.find_by(obsoleted_dt: 'infinity', name: 'G11')
+
+        expect(g1.export).to eq g11.export
+      end
+    end
 
-    expect(g1.export).to eq g11.export
-  end
-end
+    # write a grid of varying type and leniency;  also allow implicit
+    # or explicit declaration of type (for float which is the default)
+    def type_grid(lenient, type, constraint, values3, explicit_float: false)
+      lenient_str = lenient ? 'lenient' : nil
+      # rubocop:disable Style/NestedTernaryOperator
+      type_str = type == 'float' ? (explicit_float ? 'float' : nil) : type
+      # rubocop:enable Style/NestedTernaryOperator
+      top = [lenient_str, type_str].compact.join(' ') + "\t" + constraint + "\n"
+      (top =~ /\A\s*\z/ ? '' : top) +
+        <<~EOS
+          b\tboolean\tv
+          i\tinteger\tv
+          i4\tint4range\tv
+          n\tnumrange\tv
+
+          true\t1\t<10\t<10.0\t#{values3[0]}
+          \t2\t\t\t#{values3[1]}
+          false\t\t>10\t\t#{values3[2]}
+        EOS
+    end
+    describe 'constraint' do
+      it 'constraint' do
+        Mcfly.whodunnit = system_user
+        Gemini::BudCategory.create!(name: 'cat1')
+        Gemini::BudCategory.create!(name: 'cat2')
+        Gemini::BudCategory.create!(name: 'cat3')
+        tests = JSON.parse(File.read('spec/fixtures/json/data_grid.json'))
+        aggregate_failures do
+          tests.each do |test|
+            keys = %w[id type constraint values error]
+            id, type, constraint, values, error = test.values_at(*keys)
+            err_re = Regexp.new(error) if error
+            # for float, do both ex- and implicit declaration
+            exfls = type == 'float' ? [true, false] : [true]
+            [true, false].each do |lenient|
+              exfls.each do |exfl|
+                grid = type_grid(lenient, type, constraint, values,
+                                 explicit_float: exfl)
+                got = nil
+                tnam = "Test #{id} lenient=#{lenient} exfl=#{exfl}"
+                begin
+                  dg_from_import(tnam, grid)
+                rescue StandardError => e
+                  got = e.message
+                end
+                ne = 'no error'
+                if error
+                  # rubocop:disable Lint/Debugger
+                  binding.pry if ENV['PRY'] && !err_re.match(got)
+                  expect(got).to match(err_re), tnam + ' failed: got ' +
+                                                got || ne
+                else
+                  binding.pry if ENV['PRY'] && got
+                  # rubocop:enable Lint/Debugger
+                  expect(got).to be_nil, tnam + ' failed: got ' + (got || '')
+                end
+              end
+            end
+          end
+        end
+      end
+    end
   end
 end