def test_append_nested_ok(self): # Append to an existing list grainsmod.__grains__ = {'a': {'a_list': ['a', 'b', 'c'], 'b': 'bval'}} res = grainsmod.append('a:a_list', 'd') # check the result self.assertEqual(res, {'a': {'a_list': ['a', 'b', 'c', 'd'], 'b': 'bval'}}) # check the whole grains self.assertEqual(grainsmod.__grains__, {'a': {'a_list': ['a', 'b', 'c', 'd'], 'b': 'bval'}}) # Append to an non existing list grainsmod.__grains__ = {'a': {'b': 'bval'}} res = grainsmod.append('a:a_list', 'd') # check the result self.assertEqual(res, {'a': {'a_list': ['d'], 'b': 'bval'}}) # check the whole grains self.assertEqual(grainsmod.__grains__, {'a': {'a_list': ['d'], 'b': 'bval'}}) # Append to an existing string, with convert grainsmod.__grains__ = {'a': {'b': 'bval'}} res = grainsmod.append('a:b', 'd', convert=True) # check the result self.assertEqual(res, {'a': {'b': ['bval', 'd']}}) # check the whole grains self.assertEqual(grainsmod.__grains__, {'a': {'b': ['bval', 'd']}}) # Append to an existing dict, with convert grainsmod.__grains__ = {'a': {'b': {'b1': 'bval1'}}} res = grainsmod.append('a:b', 'd', convert=True) # check the result self.assertEqual(res, {'a': {'b': [{'b1': 'bval1'}, 'd']}}) # check the whole grains self.assertEqual(grainsmod.__grains__, {'a': {'b': [{'b1': 'bval1'}, 'd']}})
def test_append_nested_not_a_list(self): # Failing append to an existing string, without convert grainsmod.__grains__ = {'a': {'b': 'bval'}} res = grainsmod.append('a:b', 'd') self.assertEqual(res, 'The key a:b is not a valid list') self.assertEqual(grainsmod.__grains__, {'a': {'b': 'bval'}}) # Failing append to an existing dict grainsmod.__grains__ = {'a': {'b': {'b1': 'bval1'}}} res = grainsmod.append('a:b', 'd') self.assertEqual(res, 'The key a:b is not a valid list') self.assertEqual(grainsmod.__grains__, {'a': {'b': {'b1': 'bval1'}}})
def test_append_not_a_list(self): # Failing append to an existing string, without convert grainsmod.__grains__ = {'b': 'bval'} res = grainsmod.append('b', 'd') # check the result self.assertEqual(res, 'The key b is not a valid list') # check the whole grains self.assertEqual(grainsmod.__grains__, {'b': 'bval'}) # Failing append to an existing dict grainsmod.__grains__ = {'b': {'b1': 'bval1'}} res = grainsmod.append('b', 'd') # check the result self.assertEqual(res, 'The key b is not a valid list') # check the whole grains self.assertEqual(grainsmod.__grains__, {'b': {'b1': 'bval1'}})
def test_append_to_an_element_of_a_list(self): # Append to an element in a list # It currently fails silently grainsmod.__grains__ = {'a': ['b', 'c']} res = grainsmod.append('a:b', 'd') self.assertEqual(res, {'a': ['b', 'c']}) self.assertEqual(grainsmod.__grains__, {'a': ['b', 'c']})
def test_append_to_an_element_of_a_list(self): # Append to an element in a list # It currently fails silently with patch.dict(grainsmod.__grains__, {"a": ["b", "c"]}): res = grainsmod.append("a:b", "d") self.assertEqual(res, {"a": ["b", "c"]}) self.assertEqual(grainsmod.__grains__, {"a": ["b", "c"]})
def test_append_nested_not_a_list(self): # Failing append to an existing string, without convert grainsmod.__grains__ = {'a': {'b': 'bval'}} res = grainsmod.append('a:b', 'd') # check the result self.assertEqual(res, 'The key a:b is not a valid list') # check the whole grains self.assertEqual(grainsmod.__grains__, {'a': {'b': 'bval'}}) # Failing append to an existing dict grainsmod.__grains__ = {'a': {'b': {'b1': 'bval1'}}} res = grainsmod.append('a:b', 'd') # check the result self.assertEqual(res, 'The key a:b is not a valid list') # check the whole grains self.assertEqual(grainsmod.__grains__, {'a': {'b': {'b1': 'bval1'}}})
def test_append_nested_already_in_list(): with patch.dict( grainsmod.__grains__, {"a": {"a_list": ["a", "b", "c"], "b": "bval"}} ): res = grainsmod.append("a:a_list", "b") assert res == "The val b was already in the list a:a_list" assert grainsmod.__grains__ == {"a": {"a_list": ["a", "b", "c"], "b": "bval"}}
def test_append_nested_ok(self): # Append to an existing list with patch.dict(grainsmod.__grains__, {"a": { "a_list": ["a", "b", "c"], "b": "bval" }}): res = grainsmod.append("a:a_list", "d") self.assertEqual( res, {"a": { "a_list": ["a", "b", "c", "d"], "b": "bval" }}) self.assertEqual( grainsmod.__grains__, {"a": { "a_list": ["a", "b", "c", "d"], "b": "bval" }}, ) # Append to an non existing list with patch.dict(grainsmod.__grains__, {"a": {"b": "bval"}}): res = grainsmod.append("a:a_list", "d") self.assertEqual(res, {"a": {"a_list": ["d"], "b": "bval"}}) self.assertEqual(grainsmod.__grains__, {"a": { "a_list": ["d"], "b": "bval" }}) # Append to an existing string, with convert with patch.dict(grainsmod.__grains__, {"a": {"b": "bval"}}): res = grainsmod.append("a:b", "d", convert=True) self.assertEqual(res, {"a": {"b": ["bval", "d"]}}) self.assertEqual(grainsmod.__grains__, {"a": {"b": ["bval", "d"]}}) # Append to an existing dict, with convert with patch.dict(grainsmod.__grains__, {"a": {"b": {"b1": "bval1"}}}): res = grainsmod.append("a:b", "d", convert=True) self.assertEqual(res, {"a": {"b": [{"b1": "bval1"}, "d"]}}) self.assertEqual(grainsmod.__grains__, {"a": { "b": [{ "b1": "bval1" }, "d"] }})
def test_append_already_in_list(self): # Append an existing value with patch.dict(grainsmod.__grains__, {"a_list": ["a", "b", "c"], "b": "bval"}): res = grainsmod.append("a_list", "b") self.assertEqual(res, "The val b was already in the list a_list") self.assertEqual( grainsmod.__grains__, {"a_list": ["a", "b", "c"], "b": "bval"} )
def test_append_nested_already_in_list(self): # Append an existing value grainsmod.__grains__ = {'a': {'a_list': ['a', 'b', 'c'], 'b': 'bval'}} res = grainsmod.append('a:a_list', 'b') # check the result self.assertEqual(res, 'The val b was already in the list a:a_list') # check the whole grains self.assertEqual(grainsmod.__grains__, {'a': {'a_list': ['a', 'b', 'c'], 'b': 'bval'}})
def test_append_nested_not_a_list(self): # Failing append to an existing string, without convert with patch.dict(grainsmod.__grains__, {"a": {"b": "bval"}}): res = grainsmod.append("a:b", "d") self.assertEqual(res, "The key a:b is not a valid list") self.assertEqual(grainsmod.__grains__, {"a": {"b": "bval"}}) # Failing append to an existing dict with patch.dict(grainsmod.__grains__, {"a": {"b": {"b1": "bval1"}}}): res = grainsmod.append("a:b", "d") self.assertEqual(res, "The key a:b is not a valid list") self.assertEqual(grainsmod.__grains__, {"a": { "b": { "b1": "bval1" } }})
def test_append_nested_ok(self): # Append to an existing list with patch.dict(grainsmod.__grains__, {'a': { 'a_list': ['a', 'b', 'c'], 'b': 'bval' }}): res = grainsmod.append('a:a_list', 'd') self.assertEqual( res, {'a': { 'a_list': ['a', 'b', 'c', 'd'], 'b': 'bval' }}) self.assertEqual( grainsmod.__grains__, {'a': { 'a_list': ['a', 'b', 'c', 'd'], 'b': 'bval' }}) # Append to an non existing list with patch.dict(grainsmod.__grains__, {'a': {'b': 'bval'}}): res = grainsmod.append('a:a_list', 'd') self.assertEqual(res, {'a': {'a_list': ['d'], 'b': 'bval'}}) self.assertEqual(grainsmod.__grains__, {'a': { 'a_list': ['d'], 'b': 'bval' }}) # Append to an existing string, with convert with patch.dict(grainsmod.__grains__, {'a': {'b': 'bval'}}): res = grainsmod.append('a:b', 'd', convert=True) self.assertEqual(res, {'a': {'b': ['bval', 'd']}}) self.assertEqual(grainsmod.__grains__, {'a': {'b': ['bval', 'd']}}) # Append to an existing dict, with convert with patch.dict(grainsmod.__grains__, {'a': {'b': {'b1': 'bval1'}}}): res = grainsmod.append('a:b', 'd', convert=True) self.assertEqual(res, {'a': {'b': [{'b1': 'bval1'}, 'd']}}) self.assertEqual(grainsmod.__grains__, {'a': { 'b': [{ 'b1': 'bval1' }, 'd'] }})
def test_append_nested_not_a_list(self): # Failing append to an existing string, without convert with patch.dict(grainsmod.__grains__, {'a': {'b': 'bval'}}): res = grainsmod.append('a:b', 'd') self.assertEqual(res, 'The key a:b is not a valid list') self.assertEqual(grainsmod.__grains__, {'a': {'b': 'bval'}}) # Failing append to an existing dict with patch.dict(grainsmod.__grains__, {'a': {'b': {'b1': 'bval1'}}}): res = grainsmod.append('a:b', 'd') self.assertEqual(res, 'The key a:b is not a valid list') self.assertEqual(grainsmod.__grains__, {'a': { 'b': { 'b1': 'bval1' } }})
def test_append_already_in_list(self): # Append an existing value grainsmod.__grains__ = {'a_list': ['a', 'b', 'c'], 'b': 'bval'} res = grainsmod.append('a_list', 'b') self.assertEqual(res, 'The val b was already in the list a_list') self.assertEqual(grainsmod.__grains__, { 'a_list': ['a', 'b', 'c'], 'b': 'bval' })
def test_append_ok(): with patch.dict(grainsmod.__grains__, {"a_list": ["a", "b", "c"], "b": "bval"}): res = grainsmod.append("a_list", "d") assert res == {"a_list": ["a", "b", "c", "d"]} assert grainsmod.__grains__ == {"a_list": ["a", "b", "c", "d"], "b": "bval"} with patch.dict(grainsmod.__grains__, {"b": "bval"}): res = grainsmod.append("a_list", "d") assert res == {"a_list": ["d"]} assert grainsmod.__grains__ == {"a_list": ["d"], "b": "bval"} with patch.dict(grainsmod.__grains__, {"b": "bval"}): res = grainsmod.append("b", "d", convert=True) assert res == {"b": ["bval", "d"]} assert grainsmod.__grains__ == {"b": ["bval", "d"]} with patch.dict(grainsmod.__grains__, {"b": {"b1": "bval1"}}): res = grainsmod.append("b", "d", convert=True) assert res == {"b": [{"b1": "bval1"}, "d"]} assert grainsmod.__grains__ == {"b": [{"b1": "bval1"}, "d"]}
def test_append_nested_already_in_list(self): # Append an existing value grainsmod.__grains__ = {'a': {'a_list': ['a', 'b', 'c'], 'b': 'bval'}} res = grainsmod.append('a:a_list', 'b') # check the result self.assertEqual(res, 'The val b was already in the list a:a_list') # check the whole grains self.assertEqual(grainsmod.__grains__, {'a': { 'a_list': ['a', 'b', 'c'], 'b': 'bval' }})
def test_append_nested_already_in_list(self): # Append an existing value with patch.dict(grainsmod.__grains__, {'a': { 'a_list': ['a', 'b', 'c'], 'b': 'bval' }}): res = grainsmod.append('a:a_list', 'b') self.assertEqual(res, 'The val b was already in the list a:a_list') self.assertEqual(grainsmod.__grains__, {'a': { 'a_list': ['a', 'b', 'c'], 'b': 'bval' }})
def test_append_ok(self): # Append to an existing list grainsmod.__grains__ = {'a_list': ['a', 'b', 'c'], 'b': 'bval'} res = grainsmod.append('a_list', 'd') self.assertEqual(res, {'a_list': ['a', 'b', 'c', 'd']}) self.assertEqual(grainsmod.__grains__, {'a_list': ['a', 'b', 'c', 'd'], 'b': 'bval'}) # Append to an non existing list grainsmod.__grains__ = {'b': 'bval'} res = grainsmod.append('a_list', 'd') self.assertEqual(res, {'a_list': ['d']}) self.assertEqual(grainsmod.__grains__, {'a_list': ['d'], 'b': 'bval'}) # Append to an existing string, with convert grainsmod.__grains__ = {'b': 'bval'} res = grainsmod.append('b', 'd', convert=True) self.assertEqual(res, {'b': ['bval', 'd']}) self.assertEqual(grainsmod.__grains__, {'b': ['bval', 'd']}) # Append to an existing dict, with convert grainsmod.__grains__ = {'b': {'b1': 'bval1'}} res = grainsmod.append('b', 'd', convert=True) self.assertEqual(res, {'b': [{'b1': 'bval1'}, 'd']}) self.assertEqual(grainsmod.__grains__, {'b': [{'b1': 'bval1'}, 'd']})
def test_append_already_in_list(self): # Append an existing value grainsmod.__grains__ = {'a_list': ['a', 'b', 'c'], 'b': 'bval'} res = grainsmod.append('a_list', 'b') self.assertEqual(res, 'The val b was already in the list a_list') self.assertEqual(grainsmod.__grains__, {'a_list': ['a', 'b', 'c'], 'b': 'bval'})
def test_append_to_an_element_of_a_list(): with patch.dict(grainsmod.__grains__, {"a": ["b", "c"]}): res = grainsmod.append("a:b", "d") assert res == {"a": ["b", "c"]} assert grainsmod.__grains__ == {"a": ["b", "c"]}