data_grid_spec.rb in marty-1.0.3

- old
+ new

@@ -127,10 +127,29 @@
 true\t1\t<10\t<10.0\tY
 \t2\t\t\tM
 false\t\t>10\t\tN
 EOS
 
+Gg = <<EOS
+lenient
+i1\tinteger\tv
+i2\tinteger\tv
+
+\t1\t1
+2\t1\t21
+2\t\t20
+EOS
+
+Gh = <<EOS
+lenient
+property_state\tstring\tv
+county_name\tstring\tv
+
+NY\t\t10
+\tR\t8
+EOS
+
     before(:each) do
       #Mcfly.whodunnit = Marty::User.find_by_login('marty')
       marty_whodunnit
     end
 
@@ -138,10 +157,24 @@
       dg=Marty::DataGrid.lookup(pt, gridname)
       res=dg.lookup_grid_distinct_entry(pt, params, nil, follow)
       [res["result"], res["name"]]
     end
 
+    describe "imports" do
+      it "should not allow imports with trailing blank columns" do
+        expect {
+          dg_from_import("G1", G1.gsub("\n", "\t\n"))
+        }.to raise_error(RuntimeError)
+      end
+
+      it "should not allow imports with last blank row" do
+        expect {
+          dg_from_import("Gh", Gh+"\t\t\n")
+        }.to raise_error(RuntimeError)
+      end
+    end
+
     describe "validations" do
       it "a basic data grid should load ok" do
         dg_from_import("G1", G1)
         dg_from_import("G2", G2)
         dg_from_import("G3", G3)
@@ -221,61 +254,82 @@
     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"].each { |g|
+         "Gc", "Gd", "Ge", "Gf", "Gg", "Gh"].each { |g|
           dg_from_import(g, "Marty::DataGridSpec::#{g}".constantize)
         }
       end
 
       context "should handle NULL key values" do
         let(:dg) { Marty::DataGrid.lookup(pt, "Gf") }
 
         it 'true returns Y' do
-          res = Marty::DataGrid.
-                lookup_grid(pt, dg, {"b"=>true}, true)
+          res = Marty::DataGrid.lookup_grid(pt, dg, {"b"=>true}, false)
           expect(res).to eq('Y')
         end
 
         it '13 returns N' do
-          res = Marty::DataGrid.
-                lookup_grid(pt, dg, {"i"=>13}, true)
+          res = Marty::DataGrid.lookup_grid(pt, dg, {"i"=>13}, true)
           expect(res).to eq('N')
         end
 
         it '13 & numrange 0 returns nil' do
-          res = Marty::DataGrid.
-                lookup_grid(pt, dg, {"i"=>13, "n"=>0}, true)
-          expect(res).to be_nil
+          res = Marty::DataGrid.lookup_grid(pt, dg, {"i"=>13, "n"=>0}, true)
+          expect(res).to eq('N')
         end
 
         it '13 & int4range 15 returns N' do
-          res = Marty::DataGrid.
-                lookup_grid(pt, dg, {"i"=>13, "i4"=>15}, true)
+          res = Marty::DataGrid.lookup_grid(pt, dg, {"i"=>13, "i4"=>15}, true)
           expect(res).to eq('N')
         end
 
         it '13 & int4range 1 returns nil' do
-          res = Marty::DataGrid.
-                lookup_grid(pt, dg, {"i"=>13, "i4"=>1}, true)
+          res = Marty::DataGrid.lookup_grid(pt, dg, {"i"=>13, "i4"=>1}, true)
           expect(res).to be_nil
         end
 
         it 'false, 3, numrange 15 returns N' do
           res = Marty::DataGrid.
                 lookup_grid(pt, dg, {"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(pt, dg, {"i"=>13, "n"=>15}, true)
+          res = Marty::DataGrid.lookup_grid(pt, dg, {"i"=>13, "n"=>15}, true)
           expect(res).to eq('N')
         end
       end
 
+      it "should handle ambiguous lookups" do
+        dg = Marty::DataGrid.lookup(pt, "Gh")
+
+        h1 = {
+          "property_state" => "NY",
+          "county_name"    => "R",
+        }
+
+        res = Marty::DataGrid.lookup_grid(pt, dg, h1, false)
+        expect(res).to eq(10)
+      end
+
+      it "should handle ambiguous lookups (2)" do
+        dg = Marty::DataGrid.lookup(pt, "Gg")
+        res = Marty::DataGrid.
+              lookup_grid(pt, dg, {"i1"=>2, "i2"=>1}, false)
+        expect(res).to eq(1)
+
+        res = Marty::DataGrid.
+              lookup_grid(pt, dg, {"i1"=>3, "i2"=>1}, false)
+        expect(res).to eq(1)
+
+        res = Marty::DataGrid.
+              lookup_grid(pt, dg, {"i1"=>2, "i2"=>3}, false)
+        expect(res).to eq(20)
+      end
+
       it "should handle non-distinct lookups" do
         dg = Marty::DataGrid.lookup(pt, "Ge")
         res = Marty::DataGrid.lookup_grid(pt, dg, {"ltv"=>500}, false)
 
         expect(res).to eq(1.1)
@@ -370,15 +424,16 @@
       end
 
       it "should handle matches which also have a wildcard match" do
         dg_from_import("G9", G9)
 
-        res = lookup_grid_helper('infinity',
-                                 "G9",
-                                 {"state" => "CA", "ltv" => 81},
-                                )
-        expect(res).to eq [123,"G9"]
+        expect {
+          res = lookup_grid_helper('infinity',
+                                   "G9",
+                                   {"state" => "CA", "ltv" => 81},
+                                  )
+        }.to raise_error(RuntimeError)
 
         res = lookup_grid_helper('infinity',
                                  "G9",
                                  {"state" => "GU", "ltv" => 81},
                                 )
@@ -447,11 +502,12 @@
                                 )
         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"
+        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,
@@ -459,10 +515,11 @@
                                 )
         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"
+        expect(Marty::DataGrid.lookup('infinity', "G8").data_type).
+          to eq "Marty::DataGrid"
         g1 = Marty::DataGrid.lookup('infinity', "G1")
 
         h = {
           "fico" => 600,
           "state" => "RI",