def test_xdict_builtin_dictionary_method(self):
xd = XDict({'key': 'value'}, {'attrkey': 'attrval'})
nd = {'another': 'value2'}
xd.update(nd) # test a built in dictionary method on an XDict
self.assertEqual(xd['another'], 'value2')
self.assertEqual(xd.attrkey,
'attrval') # confirm that attribute remains
def write_files(self):
the_file_xdict = XDict(self.file_dictionary)
for filepath, file_string in the_file_xdict.xitems():
fw = nfile.FileWriter(filepath)
try:
fw.write_utf8(file_string)
except TypeError as te: # catch unicode write errors
fw.write(file_string)
def write_files(self):
the_file_xdict = XDict(self.file_dictionary)
for filepath, file_string in the_file_xdict.xitems():
fw = nfile.FileWriter(filepath)
try:
fw.write_utf8(file_string)
except TypeError as te: # catch unicode write errors
fw.write(file_string)
def test_xdict_equals_newobj_diffattr_number(self):
xd = XDict({'key': 'value'}, {
'attrkey': 'attrval',
'another': 'test'
})
xn = XDict({'key': 'value'}, {'attrkey': 'attrval'})
self.assertFalse(xd.equals(xn))
self.assertFalse(xd == xn)
self.assertTrue(xd != xn)
def test_xdict_key_xlist(self):
xd = XDict({'a_one': 'value_one', 'b_two': 'value_two', 'c_three': 'value_three'}, {'attrkey': 'attrval'})
xl = xd.key_xlist()
self.assertEqual(type(xl), type(XList(['item']))) #actually makes XList
self.assertTrue(len(xl) == 3) # includes all items
self.assertTrue('a_one' in xl) # includes appropriate items in XList
self.assertTrue('b_two' in xl)
self.assertTrue('c_three' in xl)
self.assertEqual(xl.attrkey, 'attrval') # includes original attributes
def test_xdict_equals_newobj_addattr(self):
xd = XDict({'key': 'value'})
xn = XDict({'key': 'value'})
xd.test = 'testing'
xn.test = 'testing'
self.assertTrue(hasattr(xd, 'test'))
self.assertTrue(hasattr(xn, 'test'))
self.assertTrue(xd.equals(xn))
self.assertTrue(xd == xn)
self.assertFalse(xd != xn)
def test_xdict_plusequal_overload(self):
ld = XDict({'key': 'value'}, {'attrkey': 'attrval'})
nd = {'another': 'value2'}
ld += nd
self.assertEqual(type(ld),
type(XDict({'test': 'string'
}))) # is of type XDict after combine
self.assertEqual(ld.attrkey, 'attrval') #attribute is maintained
self.assertEqual(len(ld), 2) # includes two key:value pairs
self.assertEqual(ld['key'], 'value') # test value of key 1
self.assertEqual(ld['another'], 'value2') # test value of key 2
def test_xdict_map_to_vals(self):
def cap_val(xdict_val):
return xdict_val.upper()
xd = XDict({'a_one': 'value_one', 'b_two': 'value_two', 'a_three': 'value_three'}, {'attrkey': 'attrval'})
xd = xd.map_to_vals(cap_val)
self.assertEqual(type(xd), type(XDict({'test': 'dict'})))
self.assertTrue(len(xd.values()) == 3)
self.assertTrue('VALUE_ONE' in xd.values())
self.assertTrue('VALUE_TWO' in xd.values())
self.assertTrue('VALUE_THREE' in xd.values())
self.assertEqual(xd.attrkey, 'attrval')
def test_xdict_min_val_strings(self):
xd = XDict({
'one': '1',
'two': '2',
'three': '3'
}) # test numerals as strings, still works
value, key = xd.min_val()
self.assertEqual(xd.min_val(), ('1', 'one')) # returns a tuple
self.assertEqual(value, '1')
self.assertEqual(
key,
'one') # note for non-numeral strings, uses alphabetic sorting
def test_xdict_xitems(self):
xd = XDict(
{
'a_one': 'value_one',
'b_two': 'value_two',
'c_three': 'value_three'
}, {'attrkey': 'attrval'})
for keys, values in xd.xitems():
self.assertTrue('a_one' in keys or 'b_two' in keys
or 'c_three' in keys)
self.assertTrue('value_one' in values or 'value_two' in values
or 'value_three' in values)
def test_xdict_key_random_sample(self):
xd = XDict(
{
'a_one': 'value_one',
'b_two': 'value_two',
'c_three': 'value_three'
}, {'attrkey': 'attrval'})
rand = xd.random_sample(2)
self.assertEqual(len(rand), 2)
self.assertEqual(type({'test': 'val'}),
type(rand)) # returns Python dictionary type
self.assertTrue('a_one' in rand.keys() or 'b_two' in rand.keys()
or 'c_three' in rand.keys())
def test_xdict_key_random(self):
xd = XDict(
{
'a_one': 'value_one',
'b_two': 'value_two',
'c_three': 'value_three'
}, {'attrkey': 'attrval'})
rand = xd.random()
self.assertEqual(len(rand), 1)
self.assertEqual(type({'test': 'val'}),
type(rand)) # returns Python dictionary type
self.assertTrue(
'a_one' in rand.keys() or 'b_two' in rand.keys() or 'c_three'
in rand.keys()) # includes one of the key:val from XDict
def test_xdict_plus_overload_with_xdict(self):
xd = XDict({'key': 'value'}, {'attrkey': 'attrval'})
nd = XDict({'another': 'value2'}, {'attrkey2': 'attrval2'})
ld = xd + nd
self.assertEqual(type(ld),
type(XDict({'test': 'string'
}))) # is of type XDict after combine
self.assertEqual(ld.attrkey,
'attrval') #attribute from first XDict is maintained
self.assertEqual(
ld.attrkey2,
'attrval2') #attribute from second XDict is maintained
self.assertEqual(len(ld), 2) # includes two key:value pairs
self.assertEqual(ld['key'], 'value') # test value of key 1
self.assertEqual(ld['another'], 'value2') # test value of key 2
def test_xdict_key_xlist(self):
xd = XDict(
{
'a_one': 'value_one',
'b_two': 'value_two',
'c_three': 'value_three'
}, {'attrkey': 'attrval'})
xl = xd.key_xlist()
self.assertEqual(type(xl),
type(XList(['item']))) #actually makes XList
self.assertTrue(len(xl) == 3) # includes all items
self.assertTrue('a_one' in xl) # includes appropriate items in XList
self.assertTrue('b_two' in xl)
self.assertTrue('c_three' in xl)
self.assertEqual(xl.attrkey, 'attrval') # includes original attributes
def test_xdict_plus_overload_dict_leftside(self):
xd = XDict({'key': 'value'}, {'attrkey': 'attrval'})
nd = {'another': 'value2'}
with self.assertRaises(
TypeError
): # python dictionary does not support + operator (dict + dict OR dict + XDict)
ld = nd + xd
def test_xdict_plusequal_dict_leftside(self):
nd = XDict({'key': 'value'}, {'attrkey': 'attrval'})
ld = {'another': 'value2'}
with self.assertRaises(
TypeError
): # python does not support this operator for dicts
ld += nd
def test_xdict_equals_newobj_addattr(self):
xd = XDict({'key': 'value'})
xn = XDict({'key': 'value'})
xd.test = 'testing'
xn.test = 'testing'
self.assertTrue(hasattr(xd, 'test'))
self.assertTrue(hasattr(xn, 'test'))
self.assertTrue(xd.equals(xn))
self.assertTrue(xd == xn)
self.assertFalse(xd != xn)
def xd(dictionary_arg, attributes={}):
try:
return XDict(dictionary_arg, attributes)
except TypeError:
raise TypeError(
"Attempted to cast to a XDict with an incompatible type")
except Exception as e:
if DEBUG_FLAG:
print(
"Naked Framework Error: unable to cast object to a XDict with the xd() function (Naked.toolshed.casts.py)."
)
raise e
def test_xdict_conditional_map_to_vals(self):
def true_a(xdict_key):
return xdict_key.startswith('a')
def cap_val(xdict_val):
return xdict_val.upper()
xd = XDict({'a_one': 'value_one', 'b_two': 'value_two', 'a_three': 'value_three'}, {'attrkey': 'attrval'})
xd = xd.conditional_map_to_vals(true_a, cap_val)
self.assertTrue(len(xd.values()) == 3)
self.assertTrue('VALUE_ONE' in xd.values())
self.assertTrue('VALUE_THREE' in xd.values())
self.assertTrue('value_two' in xd.values())
self.assertFalse('VALUE_TWO' in xd.values()) # the b_two value was not converted as per the conditional function
def test_xdict_conditional_map_to_vals(self):
def true_a(xdict_key):
return xdict_key.startswith('a')
def cap_val(xdict_val):
return xdict_val.upper()
xd = XDict(
{
'a_one': 'value_one',
'b_two': 'value_two',
'a_three': 'value_three'
}, {'attrkey': 'attrval'})
xd = xd.conditional_map_to_vals(true_a, cap_val)
self.assertTrue(len(xd.values()) == 3)
self.assertTrue('VALUE_ONE' in xd.values())
self.assertTrue('VALUE_THREE' in xd.values())
self.assertTrue('value_two' in xd.values())
self.assertFalse('VALUE_TWO' in xd.values(
)) # the b_two value was not converted as per the conditional function
def test_xdict_map_to_vals(self):
def cap_val(xdict_val):
return xdict_val.upper()
xd = XDict(
{
'a_one': 'value_one',
'b_two': 'value_two',
'a_three': 'value_three'
}, {'attrkey': 'attrval'})
xd = xd.map_to_vals(cap_val)
self.assertEqual(type(xd), type(XDict({'test': 'dict'})))
self.assertTrue(len(xd.values()) == 3)
self.assertTrue('VALUE_ONE' in xd.values())
self.assertTrue('VALUE_TWO' in xd.values())
self.assertTrue('VALUE_THREE' in xd.values())
self.assertEqual(xd.attrkey, 'attrval')
def setUp(self):
self.teststring = "this is a test"
self.testdict = {'key1': 'val1', 'key2': 'val2'}
self.testlist = ['item1', 'item2', 'item3']
self.testset = {'item1', 'item2', 'item3'}
self.frozenset = frozenset(self.testset)
self.testtuple = ('item1', 'item2', 'item3')
self.stringtype = type(self.teststring)
self.dicttype = type(self.testdict)
self.listtype = type(self.testlist)
self.settype = type(self.testset)
self.fsettype = type(self.frozenset)
self.tupletype = type(self.testtuple)
self.nobj = NakedObject(self.testdict)
self.xstring = XString(self.teststring, self.testdict)
self.xdict = XDict(self.testdict, self.testdict)
self.xlist = XList(self.testlist, self.testdict)
self.xsets = XSet(self.testset, self.testdict)
self.xfsets = XFSet(self.testset, self.testdict)
self.xtuple = XTuple(self.testtuple, self.testdict)
self.nobjtype = type(self.nobj)
self.xstringtype = type(self.xstring)
self.xdicttype = type(self.xdict)
self.xlisttype = type(self.xlist)
self.xsettype = type(self.xsets)
self.xfsettype = type(self.xfsets)
self.xtupletype = type(self.xtuple)
self.test_nobj = nobj(self.testdict)
self.test_xstring = xstr(self.teststring, self.testdict)
self.test_xdict = xd(self.testdict, self.testdict)
self.test_xlist = xl(self.testlist, self.testdict)
self.test_xset = xset(self.testset, self.testdict)
self.test_xfset = xfset(self.frozenset, self.testdict)
self.test_xtuple = xt(self.testtuple, self.testdict)
def test_xdict_key_difference_when_none_present(self):
xd = XDict({'one': 1, 'two': 1, 'three': 3})
xn = XDict({'one': 1, 'two': 1, 'three': 3})
self.assertEqual(xd.difference(xn), set([])) # returns empty set
def test_xdict_min_val(self):
xd = XDict({'one': 1, 'two': 2, 'three': 3})
value, key = xd.min_val()
self.assertEqual(xd.min_val(), (1, 'one')) # returns a tuple
self.assertEqual(value, 1)
self.assertEqual(key, 'one')
def test_xdict_val_count_string(self):
xd = XDict({'one': '1', 'two': '1', 'three': '3'})
self.assertEqual(xd.val_count('1'), 2)
self.assertEqual(xd.val_count('3'), 1)
self.assertEqual(xd.val_count('10'), 0) # missing value count is 0
def test_xdict_val_count_ci(self):
xd = XDict({'one': 'TEST', 'two': 'Test', 'int': 1})
self.assertEqual(xd.val_count_ci('test'), 2)
def test_xdict_min_val(self):
xd = XDict({'one': 1, 'two': 2, 'three': 3})
value, key = xd.min_val()
self.assertEqual(xd.min_val(), (1, 'one')) # returns a tuple
self.assertEqual(value, 1)
self.assertEqual(key, 'one')
def test_xdict_sum_vals(self):
xd = XDict({'one': 1, 'two': 2, 'three': 3})
self.assertEqual(xd.sum_vals(), 6)
def test_xdict_key_intersection(self):
xd = XDict({'one': 1, 'two': 1, 'three': 3})
xn = XDict({'one': 1, 'twotwo': 1, 'three': 3})
self.assertEqual(len(xd.intersection(xn)), 2)
self.assertEqual(xd.intersection(xn), set(['one', 'three']))
def test_xdict_sum_vals_string_type(self):
xd = XDict({'one': '1', 'two': '2', 'three': '3'})
with self.assertRaises(TypeError): # raises TypeError when inappropriate types in the XDict vals
xd.sum_vals()
def test_xdict_max_val_strings(self):
xd = XDict({'one': '1', 'two': '2', 'three': '3'})
value, key = xd.max_val()
self.assertEqual(xd.max_val(), ('3', 'three')) # returns a tuple
self.assertEqual(value, '3')
self.assertEqual(key, 'three')
def test_xdict_equals_sameobj(self):
xd = XDict({'key': 'value'}, {'attrkey': 'attrval'})
xn = xd
self.assertTrue(xd.equals(xn))
self.assertTrue(xd == xn)
self.assertFalse(xd != xn)
def test_xdict_xitems(self):
xd = XDict({'a_one': 'value_one', 'b_two': 'value_two', 'c_three': 'value_three'}, {'attrkey': 'attrval'})
for keys, values in xd.xitems():
self.assertTrue('a_one' in keys or 'b_two' in keys or 'c_three' in keys)
self.assertTrue('value_one' in values or 'value_two' in values or 'value_three' in values)
def test_xdict_key_random_sample(self):
xd = XDict({'a_one': 'value_one', 'b_two': 'value_two', 'c_three': 'value_three'}, {'attrkey': 'attrval'})
rand = xd.random_sample(2)
self.assertEqual(len(rand), 2)
self.assertEqual(type({'test': 'val'}), type(rand)) # returns Python dictionary type
self.assertTrue('a_one' in rand.keys() or 'b_two' in rand.keys() or 'c_three' in rand.keys())
def test_xdict_key_random(self):
xd = XDict({'a_one': 'value_one', 'b_two': 'value_two', 'c_three': 'value_three'}, {'attrkey': 'attrval'})
rand = xd.random()
self.assertEqual(len(rand), 1)
self.assertEqual(type({'test': 'val'}), type(rand)) # returns Python dictionary type
self.assertTrue('a_one' in rand.keys() or 'b_two' in rand.keys() or 'c_three' in rand.keys()) # includes one of the key:val from XDict
def test_xdict_add_attribute(self):
xd = XDict({'key': 'value'}, {'attrkey': 'attrval'})
xd.newatt = 'the test'
self.assertEqual(xd.newatt, 'the test')
def test_xdict_key_difference_when_none_present(self):
xd = XDict({'one': 1, 'two': 1, 'three': 3})
xn = XDict({'one': 1, 'two': 1, 'three': 3})
self.assertEqual(xd.difference(xn), set([])) # returns empty set
def test_xdict_val_count_string(self):
xd = XDict({'one': '1', 'two': '1', 'three': '3'})
self.assertEqual(xd.val_count('1'), 2)
self.assertEqual(xd.val_count('3'), 1)
self.assertEqual(xd.val_count('10'), 0) # missing value count is 0
def test_xdict_key_difference(self):
xd = XDict({'one': 1, 'two': 1, 'three': 3})
xn = XDict({'one': 1, 'twotwo': 1, 'three': 3})
self.assertEqual(len(xd.difference(xn)), 1)
self.assertEqual(xd.difference(xn), set(['two']))
def test_xdict_max_val_strings(self):
xd = XDict({'one': '1', 'two': '2', 'three': '3'})
value, key = xd.max_val()
self.assertEqual(xd.max_val(), ('3', 'three')) # returns a tuple
self.assertEqual(value, '3')
self.assertEqual(key, 'three')
def test_xdict_key_intersection_when_none_present(self):
xd = XDict({'one': 1, 'two': 1, 'three': 3})
xn = XDict({'oneone': 1, 'twotwo': 1, 'threethree': 3})
self.assertEqual(len(xd.intersection(xn)), 0)
self.assertEqual(xd.intersection(xn), set([]))
def test_xdict_equals_newobj_diff_dicttypes(self):
xd = XDict({'key': '1'}, {'attrkey': 'attrval'})
xn = XDict({'key': 1}, {'attrkey': 'attrval'})
self.assertFalse(xd.equals(xn))
self.assertFalse(xd == xn)
self.assertTrue(xd != xn)
def test_xdict_equals_newobj_diffattrval(self):
xd = XDict({'key': 'value'}, {'attrkey': 'diff'})
xn = XDict({'key': 'value'}, {'attrkey': 'attrval'})
self.assertFalse(xd.equals(xn))
self.assertFalse(xd == xn)
self.assertTrue(xd != xn)
def test_xdict_sum_vals_string_type(self):
xd = XDict({'one': '1', 'two': '2', 'three': '3'})
with self.assertRaises(
TypeError
): # raises TypeError when inappropriate types in the XDict vals
xd.sum_vals()
def test_xdict_val_count_ci(self):
xd = XDict({'one': 'TEST', 'two': 'Test', 'int': 1})
self.assertEqual(xd.val_count_ci('test'), 2)
def test_xdict_val_count_integer(self):
xd = XDict({'one': 1, 'two': 1, 'three': 3})
self.assertEqual(xd.val_count(1), 2)
self.assertEqual(xd.val_count(3), 1)
self.assertEqual(xd.val_count(10), 0) # missing value count is 0
def test_xdict_sum_vals(self):
xd = XDict({'one': 1, 'two': 2, 'three': 3})
self.assertEqual(xd.sum_vals(), 6)
def test_xdict_key_difference(self):
xd = XDict({'one': 1, 'two': 1, 'three': 3})
xn = XDict({'one': 1, 'twotwo': 1, 'three': 3})
self.assertEqual(len(xd.difference(xn)), 1)
self.assertEqual(xd.difference(xn), set(['two']))
def test_xdict_val_count_integer(self):
xd = XDict({'one': 1, 'two': 1, 'three': 3})
self.assertEqual(xd.val_count(1), 2)
self.assertEqual(xd.val_count(3), 1)
self.assertEqual(xd.val_count(10), 0) # missing value count is 0
def test_xdict_key_intersection(self):
xd = XDict({'one': 1, 'two': 1, 'three': 3})
xn = XDict({'one': 1, 'twotwo': 1, 'three': 3})
self.assertEqual(len(xd.intersection(xn)), 2)
self.assertEqual(xd.intersection(xn), set(['one', 'three']))
def test_xdict_key_intersection_when_none_present(self):
xd = XDict({'one': 1, 'two': 1, 'three': 3})
xn = XDict({'oneone': 1, 'twotwo': 1, 'threethree': 3})
self.assertEqual(len(xd.intersection(xn)), 0)
self.assertEqual(xd.intersection(xn), set([]))
def test_xdict_equals_newobj_diffattr_number(self):
xd = XDict({'key': 'value'}, {'attrkey': 'attrval', 'another': 'test'})
xn = XDict({'key': 'value'}, {'attrkey': 'attrval'})
self.assertFalse(xd.equals(xn))
self.assertFalse(xd == xn)
self.assertTrue(xd != xn)
def test_xdict_has_attribute_true(self):
xd = XDict({'key': 'value'}, {'attrkey': 'attrval'})
self.assertTrue(hasattr(xd, 'attrkey'))
def test_xdict_equals_newobj_emptyattrs(self):
xd = XDict({'key': 'value'})
xn = XDict({'key': 'value'})
self.assertTrue(xd.equals(xn))
self.assertTrue(xd == xn)
self.assertFalse(xd != xn)
def test_xdict_has_attribute_false(self):
xd = XDict({'key': 'value'}, {'attrkey': 'attrval'})
self.assertFalse(hasattr(xd, 'bogus'))
def test_xdict_builtin_dictionary_method(self):
xd = XDict({'key': 'value'}, {'attrkey': 'attrval'})
nd = {'another': 'value2'}
xd.update(nd) # test a built in dictionary method on an XDict
self.assertEqual(xd['another'], 'value2')
self.assertEqual(xd.attrkey, 'attrval') # confirm that attribute remains
def test_xdict_min_val_strings(self):
xd = XDict({'one': '1', 'two': '2', 'three': '3'}) # test numerals as strings, still works
value, key = xd.min_val()
self.assertEqual(xd.min_val(), ('1', 'one')) # returns a tuple
self.assertEqual(value, '1')
self.assertEqual(key, 'one') # note for non-numeral strings, uses alphabetic sorting
