def testMergeDefaults(self):
# from a non-trivial dictionary
p = Policy(self.getTestDictionary("defaults_policy_partial.paf"))
p.set("required", "foo")
d = Dictionary(self.getTestDictionary("defaults_dictionary_good.paf"))
d.loadPolicyFiles(self.getTestDictionary(), True)
self.assert_(p.nameCount() == 2)
p.mergeDefaults(d)
self.assert_(p.valueCount("int_range_count") == 3)
self.assert_(p.nameCount() == 7)
# from a policy that's really a dictionary
p = Policy()
pd = Policy(self.getTestDictionary("defaults_dictionary_indirect.paf"))
p.mergeDefaults(pd)
self.assert_(p.getString("string_type") == "foo")
self.assert_(p.getDictionary().isDictionary())
# from a policy that's really a non-trivial dictionary
p = Policy(self.getTestDictionary("defaults_policy_partial.paf"))
p.set("required", "foo")
pd = Policy(self.getTestDictionary("defaults_dictionary_policy.paf"))
pd.loadPolicyFiles(self.getTestDictionary(), True)
self.assert_(p.nameCount() == 2)
p.mergeDefaults(pd)
self.assert_(p.valueCount("int_range_count") == 3)
self.assert_(p.nameCount() == 5)
# ensure post-load validation
p.set("int_range_count", -5)
self.assertValidationError(ValidationError.UNKNOWN_NAME,
p.add, "unknown", 0)
# test throwing validation
p = Policy(self.getTestDictionary("defaults_policy_partial.paf"))
try:
p.mergeDefaults(pd)
except ValidationError, e:
self.assert_(e.args[0].getErrors("required")
== ValidationError.MISSING_REQUIRED)
def testMergeDefaults(self):
# from a non-trivial dictionary
p = Policy(self.getTestDictionary("defaults_policy_partial.paf"))
p.set("required", "foo")
d = Dictionary(self.getTestDictionary("defaults_dictionary_good.paf"))
d.loadPolicyFiles(self.getTestDictionary(), True)
self.assertEqual(p.nameCount(), 2)
p.mergeDefaults(d)
self.assertEqual(p.valueCount("int_range_count"), 3)
self.assertEqual(p.nameCount(), 7)
# from a policy that's really a dictionary
p = Policy()
pd = Policy(self.getTestDictionary("defaults_dictionary_indirect.paf"))
p.mergeDefaults(pd)
self.assertEqual(p.getString("string_type"), "foo")
self.assertTrue(p.getDictionary().isDictionary())
# from a policy that's really a non-trivial dictionary
p = Policy(self.getTestDictionary("defaults_policy_partial.paf"))
p.set("required", "foo")
pd = Policy(self.getTestDictionary("defaults_dictionary_policy.paf"))
pd.loadPolicyFiles(self.getTestDictionary(), True)
self.assertEqual(p.nameCount(), 2)
p.mergeDefaults(pd)
self.assertEqual(p.valueCount("int_range_count"), 3)
self.assertEqual(p.nameCount(), 5)
# ensure post-load validation
p.set("int_range_count", -5)
self.assertValidationError(ValidationError.UNKNOWN_NAME,
p.add, "unknown", 0)
# test throwing validation
p = Policy(self.getTestDictionary("defaults_policy_partial.paf"))
try:
p.mergeDefaults(pd)
except ValidationError as ve:
self.assertEqual(ve.getErrors("required"),
ValidationError.MISSING_REQUIRED)
# non-throwing validation
p = Policy(self.getTestDictionary("defaults_policy_partial.paf"))
ve = ValidationError("Dictionary_1.py", 1, "testMergeDefaults")
p.mergeDefaults(pd, False, ve.cpp)
self.assertEqual(ve.getErrors("required"), ValidationError.MISSING_REQUIRED)
self.assertEqual(ve.getParamCount(), 1)
# non-retention
p = Policy(self.getTestDictionary("defaults_policy_partial.paf"))
p.set("required", "foo")
p.mergeDefaults(pd, False)
# make sure validate() fails gracefully when no dictionary present
self.assertRaiseLCE(DictionaryError, "No dictionary",
p.validate, "No dictionary assigned")
p.add("unknown", 0) # would be rejected if dictionary was kept
# deep merge from a Policy that's not a Dictionary
p = Policy(self.getTestDictionary("defaults_policy_partial.paf"))
p.mergeDefaults(Policy(self.getTestDictionary("defaults_policy_most.paf")))
self.assertEqual(p.nameCount(), 3)
self.assertIs(p.getBool("bool_set_count"), True)
self.assertEqual(p.getString("indirect.string_type"), "bar")
# propagation of a Dictionary from one Policy to another via mergeDefaults
d = Dictionary(self.getTestDictionary("defaults_dictionary_complete.paf"))
d.loadPolicyFiles(self.getTestDictionary())
pEmpty = Policy()
pEmpty.mergeDefaults(d)
self.assertTrue(pEmpty.canValidate())
pPartial = Policy(self.getTestDictionary("defaults_policy_partial.paf"))
pPartial.mergeDefaults(pEmpty)
self.assertTrue(pPartial.canValidate(), "Dictionary handed off via mergeDefaults.")
def testNested(self):
self.assertRaiseLCE(DictionaryError,
"policy_bad_subdef.dictionary is a string",
Dictionary, "Malformed subdictionary",
self.getTestDictionary("nested_dictionary_bad_1.paf"))
p = Policy(self.getTestDictionary("nested_policy_good.paf"))
self.assertRaiseLCE(DictionaryError, "Unknown Dictionary property",
Dictionary, "Malformed subdictionary",
self.getTestDictionary("nested_dictionary_bad_2.paf"))
d = Dictionary(self.getTestDictionary("nested_dictionary_good.paf"))
d.check()
self.assertRaiseLCE(lsst.pex.exceptions.LogicError, "dictionaryFile needs to be loaded",
d.validate, "dictionaryFile not loaded", p)
self.assertFalse(d.hasSubDictionary("policy_1"))
self.assertTrue(d.hasSubDictionary("policy_2"))
self.assertFalse(d.hasSubDictionary("policy_load"))
n = d.loadPolicyFiles(self.getTestDictionary(), True)
self.assertTrue(d.hasSubDictionary("policy_load"))
self.assertEqual(n, 1) # number of files loaded
d.validate(p)
ve = ValidationError("Dictionary_1.py", 1, "testNested")
p = Policy(self.getTestDictionary("nested_policy_bad.paf"))
d.validate(p, ve.cpp)
self.assertEqual(ve.getErrors("policy_1"), ValidationError.WRONG_TYPE)
self.assertEqual(ve.getErrors("policy_2.foo"),
ValidationError.VALUE_DISALLOWED)
self.assertEqual(ve.getErrors("policy_2.bar"),
ValidationError.MISSING_REQUIRED)
self.assertEqual(ve.getErrors("policy_3.baz.qux"),
ValidationError.WRONG_TYPE)
self.assertEqual(ve.getErrors("policy_3.baz.paisley"),
ValidationError.MISSING_REQUIRED)
self.assertEqual(ve.getErrors("policy_3.baz.paisley"),
ValidationError.MISSING_REQUIRED)
self.assertEqual(ve.getErrors("policy_load.height"),
ValidationError.MISSING_REQUIRED)
self.assertEqual(ve.getParamCount(), 6)
# multiple nesting
p = Policy(self.getTestDictionary("nested_policy_1.paf"))
n = p.loadPolicyFiles(self.getTestDictionary())
self.assertEqual(n, 3)
self.assertEqual(p.getString("1.2b.foo"), "bar")
d = Dictionary(self.getTestDictionary("nested_dictionary_1.paf"))
n = d.loadPolicyFiles(self.getTestDictionary())
self.assertEqual(n, 3)
p = Policy(True, d) # load from defaults
self.assertEqual(p.getString("1.2a.foo"), "bar")
self.assertEqual(p.getString("1.2b.foo"), "bar")
# error in child
d = Dictionary(self.getTestDictionary("nested_dictionary_bad_child.paf"))
d.loadPolicyFiles(self.getTestDictionary())
# this should really be caught during loadPolicyFiles(), above
self.assertRaiseLCE(DictionaryError, "Unknown type: \"NotAType\"",
d.makeDef("sub.something").getType,
"Loaded sub-dictionary specified a bogus type")
def testMergeDefaults(self):
# from a non-trivial dictionary
p = Policy(self.getTestDictionary("defaults_policy_partial.paf"))
p.set("required", "foo")
d = Dictionary(self.getTestDictionary("defaults_dictionary_good.paf"))
d.loadPolicyFiles(self.getTestDictionary(), True)
self.assert_(p.nameCount() == 2)
p.mergeDefaults(d)
self.assert_(p.valueCount("int_range_count") == 3)
self.assert_(p.nameCount() == 7)
# from a policy that's really a dictionary
p = Policy()
pd = Policy(self.getTestDictionary("defaults_dictionary_indirect.paf"))
p.mergeDefaults(pd)
self.assert_(p.getString("string_type") == "foo")
self.assert_(p.getDictionary().isDictionary())
# from a policy that's really a non-trivial dictionary
p = Policy(self.getTestDictionary("defaults_policy_partial.paf"))
p.set("required", "foo")
pd = Policy(self.getTestDictionary("defaults_dictionary_policy.paf"))
pd.loadPolicyFiles(self.getTestDictionary(), True)
self.assert_(p.nameCount() == 2)
p.mergeDefaults(pd)
self.assert_(p.valueCount("int_range_count") == 3)
self.assert_(p.nameCount() == 5)
# ensure post-load validation
p.set("int_range_count", -5)
self.assertValidationError(ValidationError.UNKNOWN_NAME,
p.add, "unknown", 0)
# test throwing validation
p = Policy(self.getTestDictionary("defaults_policy_partial.paf"))
try:
p.mergeDefaults(pd)
except ValidationError as ve:
self.assert_(ve.getErrors("required")
== ValidationError.MISSING_REQUIRED)
# non-throwing validation
p = Policy(self.getTestDictionary("defaults_policy_partial.paf"))
ve = ValidationError("Dictionary_1.py", 1, "testMergeDefaults")
p.mergeDefaults(pd, False, ve.cpp)
self.assert_(ve.getErrors("required") == ValidationError.MISSING_REQUIRED)
self.assert_(ve.getParamCount() == 1)
# non-retention
p = Policy(self.getTestDictionary("defaults_policy_partial.paf"))
p.set("required", "foo")
p.mergeDefaults(pd, False)
# make sure validate() fails gracefully when no dictionary present
self.assertRaiseLCE(DictionaryError, "No dictionary",
p.validate, "No dictionary assigned")
p.add("unknown", 0) # would be rejected if dictionary was kept
# deep merge from a Policy that's not a Dictionary
p = Policy(self.getTestDictionary("defaults_policy_partial.paf"))
p.mergeDefaults(Policy(self.getTestDictionary("defaults_policy_most.paf")))
self.assert_(p.nameCount() == 3)
self.assert_(p.getBool("bool_set_count") == True)
self.assert_(p.getString("indirect.string_type") == "bar")
# propagation of a Dictionary from one Policy to another via mergeDefaults
d = Dictionary(self.getTestDictionary("defaults_dictionary_complete.paf"))
d.loadPolicyFiles(self.getTestDictionary())
pEmpty = Policy()
pEmpty.mergeDefaults(d)
self.assert_(pEmpty.canValidate())
pPartial = Policy(self.getTestDictionary("defaults_policy_partial.paf"))
pPartial.mergeDefaults(pEmpty)
self.assert_(pPartial.canValidate(), "Dictionary handed off via mergeDefaults.")
def testNested(self):
self.assertRaiseLCE(DictionaryError,
"policy_bad_subdef.dictionary is a string",
Dictionary, "Malformed subdictionary",
self.getTestDictionary("nested_dictionary_bad_1.paf"))
p = Policy(self.getTestDictionary("nested_policy_good.paf"))
self.assertRaiseLCE(DictionaryError, "Unknown Dictionary property",
Dictionary, "Malformed subdictionary",
self.getTestDictionary("nested_dictionary_bad_2.paf"))
d = Dictionary(self.getTestDictionary("nested_dictionary_good.paf"))
d.check()
self.assertRaiseLCE(lsst.pex.exceptions.LogicError, "dictionaryFile needs to be loaded",
d.validate, "dictionaryFile not loaded", p)
self.assert_(not d.hasSubDictionary("policy_1"))
self.assert_(d.hasSubDictionary("policy_2"))
self.assert_(not d.hasSubDictionary("policy_load"))
n = d.loadPolicyFiles(self.getTestDictionary(), True)
self.assert_(d.hasSubDictionary("policy_load"))
self.assert_(n == 1) # number of files loaded
d.validate(p)
ve = ValidationError("Dictionary_1.py", 1, "testNested")
p = Policy(self.getTestDictionary("nested_policy_bad.paf"))
d.validate(p, ve.cpp)
self.assert_(ve.getErrors("policy_1") == ValidationError.WRONG_TYPE)
self.assert_(ve.getErrors("policy_2.foo")
== ValidationError.VALUE_DISALLOWED)
self.assert_(ve.getErrors("policy_2.bar")
== ValidationError.MISSING_REQUIRED)
self.assert_(ve.getErrors("policy_3.baz.qux")
== ValidationError.WRONG_TYPE)
self.assert_(ve.getErrors("policy_3.baz.paisley")
== ValidationError.MISSING_REQUIRED)
self.assert_(ve.getErrors("policy_3.baz.paisley")
== ValidationError.MISSING_REQUIRED)
self.assert_(ve.getErrors("policy_load.height")
== ValidationError.MISSING_REQUIRED)
self.assert_(ve.getParamCount() == 6)
# multiple nesting
p = Policy(self.getTestDictionary("nested_policy_1.paf"))
n = p.loadPolicyFiles(self.getTestDictionary())
self.assert_(n == 3)
self.assert_(p.getString("1.2b.foo") == "bar")
d = Dictionary(self.getTestDictionary("nested_dictionary_1.paf"))
n = d.loadPolicyFiles(self.getTestDictionary())
self.assert_(n == 3)
p = Policy(True, d) # load from defaults
self.assert_(p.getString("1.2a.foo") == "bar")
self.assert_(p.getString("1.2b.foo") == "bar")
# error in child
d = Dictionary(self.getTestDictionary("nested_dictionary_bad_child.paf"))
d.loadPolicyFiles(self.getTestDictionary())
# this should really be caught during loadPolicyFiles(), above
self.assertRaiseLCE(DictionaryError, "Unknown type: \"NotAType\"",
d.makeDef("sub.something").getType,
"Loaded sub-dictionary specified a bogus type")
p.mergeDefaults(pd, False)
# make sure validate() fails gracefully when no dictionary present
self.assertRaisesEx(DictionaryError, "No dictionary",
p.validate, "No dictionary assigned")
p.add("unknown", 0) # would be rejected if dictionary was kept
# deep merge from a Policy that's not a Dictionary
p = Policy(self.getTestDictionary("defaults_policy_partial.paf"))
p.mergeDefaults(Policy(self.getTestDictionary("defaults_policy_most.paf")))
self.assert_(p.nameCount() == 3)
self.assert_(p.getBool("bool_set_count") == True)
self.assert_(p.getString("indirect.string_type") == "bar")
# propagation of a Dictionary from one Policy to another via mergeDefaults
d = Dictionary(self.getTestDictionary("defaults_dictionary_complete.paf"))
d.loadPolicyFiles(self.getTestDictionary())
pEmpty = Policy()
pEmpty.mergeDefaults(d)
self.assert_(pEmpty.canValidate())
pPartial = Policy(self.getTestDictionary("defaults_policy_partial.paf"))
pPartial.mergeDefaults(pEmpty)
self.assert_(pPartial.canValidate(), "Dictionary handed off via mergeDefaults.")
# test the sample code at http://dev.lsstcorp.org/trac/wiki/PolicyHowto
def testSampleCode(self):
policyFile = DefaultPolicyFile("pex_policy", "defaults_dictionary_complete.paf",
"tests/dictionary")
defaults = Policy.createPolicy(policyFile, policyFile.getRepositoryPath(), True)
policy = Policy()
policy.mergeDefaults(defaults)
self.assert_(policy.canValidate())
