def test_all_unknown_fuzzy_on_off(self):
ctx = Ctx(acura, True)
all_ = Criteria().Eq("x", "x").Eq("y",
"y").Eq("z",
"z").Eq("w",
"w").All().Done()
(ans, err) = all_(ctx)
self.assertEqual(ans, Const.UNKNOWN)
self.assertIsInstance(err, KeyError)
and_ = Criteria().Eq("x", "x").Eq("y",
"y").And().Eq("z", "z").And().Eq(
"w", "w").And().Done()
(ans_, err_) = and_(ctx)
self.assertEqual(ans, ans_)
self.assertEqual(err.message, err_.message)
ctx = Ctx(acura, False)
all_ = Criteria().Eq("x", "x").Eq("y",
"y").Eq("z",
"z").Eq("w",
"w").All().Done()
(ans, err) = all_(ctx)
self.assertEqual(ans, Const.ERROR)
self.assertIsInstance(err, KeyError)
and_ = Criteria().Eq("x", "x").Eq("y",
"y").And().Eq("z", "z").And().Eq(
"w", "w").And().Done()
(ans_, err_) = and_(ctx)
self.assertEqual(ans, ans_)
self.assertEqual(err.message, err_.message)
def test_precise_vs_fuzzy(self):
""" test all """
with acura:
""" mock so that 'make' causing comparison error """
acura.set_compare_error("make",
CompareError(Exception("left first")))
for all_ in (Criteria().Eq("make", "Acura").Between(15, "maxprice", 20.1).NotEq("source", "USA").Eq("type", "Small").All().Done(), \
Criteria().Between(15, "maxprice", 20.1).NotEq("source", "USA").Eq("type", "Small").Eq("make", "Acura").All().Done(),):
""" precise match """
ctx = Ctx(acura, False)
(ans, err) = all_(ctx)
self.assertEqual(ans, Const.ERROR)
""" fuzzy match """
ctx = Ctx(acura, True)
(ans_, err_) = all_(ctx)
self.assertTrue(ans_)
self.assertEqual(err.message, err_.message)
""" similarly, test for Any """
with acura:
""" mock so that 'make' causing comparison error """
acura.set_compare_error("make",
CompareError(Exception("left first")))
any_ = Criteria().Eq("make", "Acura").Between(
15, "maxprice",
20.1).NotEq("source", "USA").Eq("type", "Small").Any().Done()
""" precise match """
ctx = Ctx(acura, False)
(ans, err) = any_(ctx)
self.assertEqual(ans, Const.ERROR)
""" fuzzy match """
ctx = Ctx(acura, True)
(ans_, err_) = any_(ctx)
self.assertTrue(ans_)
self.assertEqual(err.message, err_.message)
any_ = Criteria().Between(15, "maxprice", 20.1).NotEq(
"source", "USA").Eq("type", "Small").Eq("make",
"Acura").Any().Done()
""" precise match """
ctx = Ctx(acura, False)
(ans, err) = any_(ctx)
self.assertTrue(ans)
self.assertIsNone(err)
""" fuzzy match """
ctx = Ctx(acura, True)
(ans_, err_) = any_(ctx)
self.assertTrue(ans)
self.assertIsNone(err)
def test_all_negative(self):
ctx = Ctx(acura)
all_ = Criteria().Eq("make", "Mazda").Between(15, "maxprice", 18).Eq(
"source", "USA").Eq("type", "Midsize").All().Done()
(ans, err) = all_(ctx)
self.assertFalse(ans)
self.assertIsNone(err)
and_ = Criteria().Eq("make",
"Mazda").Between(15, "maxprice", 18).And().Eq(
"source",
"USA").And().Eq("type",
"Midsize").And().Done()
(ans_, err_) = and_(ctx)
self.assertEqual(ans, ans_)
self.assertEqual(err, err_)
def test_and_nesting_err(self):
with acura:
acura.set_access_error("make", Exception("left first"))
acura.set_access_error("source", KeyError("right 2nd"))
ctx = Ctx(acura, True)
and_ = Criteria().Eq("make", "Acura").Eq("type", "Small").And().Eq("source", "nonUSA").And().Done()
(obj, err) = and_(ctx)
self.assertTrue(obj)
self.assertIsNotNone(err)
self.assertEqual(err.message, "cannot find key 'make'")
and_ = Criteria().Eq("source", "nonUSA").Eq("make", "Acura").Eq("type", "Small").And().And().Done()
(obj, err) = and_(ctx)
self.assertTrue(obj)
self.assertIsNotNone(err)
self.assertEqual(err.message, "cannot find key 'source'")
def test_all_positive(self):
ctx = Ctx(acura)
all_ = Criteria().Eq("make",
"Acura").Between(15, "maxprice", 20.1).NotEq(
"source", "USA").Eq("type",
"Small").All().Done()
(ans, err) = all_(ctx)
self.assertTrue(ans)
self.assertIsNone(err)
and_ = Criteria().Eq("make", "Acura").Between(
15, "maxprice",
20.1).And().NotEq("source", "USA").And().Eq("type",
"Small").And().Done()
(ans_, err_) = and_(ctx)
self.assertEqual(ans, ans_)
self.assertEqual(err, err_)
def test_filter_cars(self):
""" create criteria either through api or text """
expected = "((17 <= maxprice < 21 and make == 'Chevrolet') and type == 'Compact')"
car_search_criteria = Criteria().Between(17, "maxprice", 21).Eq("make", "Chevrolet").And().Eq("type", "Compact").And().Done()
car_search_criteria2 = to_criteria(expected)
self.assertEqual(str(car_search_criteria), expected)
self.assertEqual(str(car_search_criteria2), expected)
""" test that one of the cars below matches the criteria """
ctx = Ctx(chevrolet_compact_e)
(ans, err) = car_search_criteria(ctx)
self.assertTrue(ans)
self.assertIsNone(err)
ctx = Ctx(chevrolet_compact_c)
(ans, err) = car_search_criteria(ctx)
self.assertFalse(ans)
self.assertIsNone(err)
""" to conform to built-in filter function's requirement """
def predicate(car):
(ans, _) = car_search_criteria(Ctx(car))
return ans
""" there should be only be one match """
potential = filter(predicate, CARS)
self.assertEqual(len(potential), 1)
""" change search criteria a bit """
car_search_criteria = Criteria().Eq("make", "Chevrolet").Eq("type", "Compact").Eq("source", "USA").All().Done()
def predicate(car):
(ans, _) = car_search_criteria(Ctx(car))
return ans
potential = filter(predicate, CARS)
self.assertEqual(len(potential), 2)
def test_ser_all(self):
ctx = Ctx(acura)
expected = "make == 'Acura' and 15 <= maxprice < 20.1 and source != 'USA' and type == 'Small'"
all_ = to_criteria(expected)
all2_ = Criteria().Eq("make",
"Acura").Between(15, "maxprice", 20.1).NotEq(
"source", "USA").Eq("type",
"Small").All().Done()
self.assertEqual(expected, str(all_))
self.assertEqual(expected, str(all2_))
(ans, err) = all_(ctx)
(ans_, err_) = all2_(ctx)
self.assertEqual(ans, ans_)
self.assertEqual(err, err_)
def test_and_left_cmp_error(self):
with acura:
ctx = Ctx(acura, True)
acura.set_compare_error("make", CompareError(Exception("left first")))
acura.set_compare_error("source", CompareError(KeyError("right first")))
make = ctx["make"]
source = ctx["source"]
(obj, err) = Eq("make", "xxx")(ctx)
self.assertEqual(obj, Const.UNKNOWN)
self.assertIsInstance(err, Exception)
self.assertEqual(err.message, "left first")
(obj, err) = Eq("source", "xxx")(ctx)
self.assertEqual(obj, Const.UNKNOWN)
self.assertIsInstance(err, KeyError)
self.assertEqual(err.message, "right first")
and_ = Criteria().Eq("make", "xxx").Eq("source", "yyy").And().Done()
(obj, err) = and_(ctx)
self.assertEqual(obj, Const.UNKNOWN)
self.assertIsInstance(err, Exception)
self.assertEqual(err.message, "left first")
with acura:
ctx = Ctx(acura, True)
acura.set_compare_error("source", CompareError(KeyError("right first")))
make = ctx["make"]
source = ctx["source"]
and_ = And(cTrue, Eq("source", "xxx"))
(obj, err) = and_(ctx)
self.assertTrue(obj)
self.assertIsInstance(err, KeyError)
self.assertEqual(err.message, "right first")
ctx = Ctx(acura, False)
and_ = And(cTrue, Eq("source", "xxx"))
(obj, err) = and_(ctx)
self.assertEqual(obj, Const.ERROR)
self.assertIsInstance(err, KeyError)
self.assertEqual(err.message, "right first")
def test_fuzzy_match(self):
car_search_criteria = Criteria().Between(17, "maxprice", 21).Eq("make", "Chevrolet").And().Eq("type", "Compact").And().Done()
ctx = Ctx(chevrolet_compact_e)
(ans, err) = car_search_criteria(ctx)
self.assertTrue(ans)
self.assertIsNone(err)
ctx = Ctx(chevrolet_compact_c)
(ans, err) = car_search_criteria(ctx)
self.assertFalse(ans)
self.assertIsNone(err)
with chevrolet_compact_c as chevrolet_compact:
""" make maxprice missing for chevrolet_compact temporarily """
chevrolet_compact.set_access_error("maxprice", KeyError)
ctx = Ctx(chevrolet_compact)
(ans, err) = car_search_criteria(ctx)
self.assertEqual(ans, Const.ERROR)
self.assertIsInstance(err, KeyError)
ctx = Ctx(chevrolet_compact, True)
(ans, err) = car_search_criteria(ctx)
self.assertTrue(ans)
self.assertIsInstance(err, KeyError)
def test_error_build(self):
with self.assertRaises(SyntaxError):
Criteria().Done()
def test_not(self):
c = Criteria().Eq("type", "Midsize").Not().Done()
ctx = Ctx(acura)
(ans, err) = c(ctx)
self.assertFalse(ans)
self.assertIsNone(err)
def test_criteria_simple(self):
c = Criteria()
self.assertEqual(c.size(), 0)
c = Criteria().Eq("make", "Acura")
self.assertEqual(c.size(), 1)
c = Criteria().Eq("make", "Acura").Eq("type", "Midsize")
self.assertEqual(c.size(), 2)
c = Criteria().Eq("make", "Acura").Eq("type", "Midsize").And()
self.assertEqual(c.size(), 1)
c = Criteria().Eq("make", "Acura").Eq("type", "Midsize").And().Done()
self.assertIsInstance(c, And)
ctx = Ctx(acura)
(ans, err) = c(ctx)
self.assertTrue(ans)
self.assertIsNone(err)