def test__assert_greater1(self):
'''test'''
with patch.dict(
saltcheck.__salt__, {
'config.get': MagicMock(return_value=True),
'cp.cache_master': MagicMock(return_value=[True])
}):
sc_instance = saltcheck.SaltCheck()
aaa = 110
bbb = 100
mybool = sc_instance._SaltCheck__assert_greater(aaa, bbb)
self.assertTrue(mybool, True)
def test__assert_less_equal2(self):
'''test'''
with patch.dict(
saltcheck.__salt__, {
'config.get': MagicMock(return_value=True),
'cp.cache_master': MagicMock(return_value=[True])
}):
sc_instance = saltcheck.SaltCheck()
aaa = 110
bbb = 99
mybool = sc_instance._SaltCheck__assert_less_equal(aaa, bbb)
self.assertNotEqual(mybool, True)
def test__assert_not_in2(self):
'''test'''
with patch.dict(
saltcheck.__salt__, {
'config.get': MagicMock(return_value=True),
'cp.cache_master': MagicMock(return_value=[True])
}):
sc_instance = saltcheck.SaltCheck()
aaa = "bob"
mylist = ['alice', 'bob', 'charles', 'dana']
mybool = sc_instance._SaltCheck__assert_not_in(aaa, mylist)
self.assertNotEqual(mybool, True)
def test__assert_not_equal1(self):
'''test'''
with patch.dict(
saltcheck.__salt__, {
'config.get': MagicMock(return_value=True),
'cp.cache_master': MagicMock(return_value=[True])
}):
sc_instance = saltcheck.SaltCheck()
aaa = {'a': 1, 'b': 2}
bbb = {'a': 1, 'b': 2, 'c': 3}
mybool = sc_instance._SaltCheck__assert_not_equal(aaa, bbb)
self.assertTrue(mybool)
def test__assert_equal2(self):
"""test"""
with patch.dict(
saltcheck.__salt__,
{
"config.get": MagicMock(return_value=True),
"cp.cache_master": MagicMock(return_value=[True]),
},
):
sc_instance = saltcheck.SaltCheck()
mybool = sc_instance._SaltCheck__assert_equal(False, True)
self.assertNotEqual(mybool, True)
def test__assert__not_empty(self):
"""test"""
with patch.dict(
saltcheck.__salt__,
{
"config.get": MagicMock(return_value=True),
"cp.cache_master": MagicMock(return_value=[True]),
},
):
sc_instance = saltcheck.SaltCheck()
mybool = sc_instance._SaltCheck__assert_not_empty("data")
self.assertEqual(mybool, "Pass")
def test_call_salt_command2(self):
'''test simple test.echo module again'''
with patch.dict(
saltcheck.__salt__, {
'config.get': MagicMock(return_value=True),
'sys.list_modules': MagicMock(return_value=['module1']),
'cp.cache_master': MagicMock(return_value=[True])
}):
sc_instance = saltcheck.SaltCheck()
returned = sc_instance.call_salt_command(fun="test.echo",
args=['hello'],
kwargs=None)
self.assertNotEqual(returned, 'not-hello')
def test__assert_not_equal1(self):
"""test"""
with patch.dict(
saltcheck.__salt__,
{
"config.get": MagicMock(return_value=True),
"cp.cache_master": MagicMock(return_value=[True]),
},
):
sc_instance = saltcheck.SaltCheck()
aaa = {"a": 1, "b": 2}
bbb = {"a": 1, "b": 2, "c": 3}
mybool = sc_instance._SaltCheck__assert_not_equal(aaa, bbb)
self.assertTrue(mybool)
def test__assert_less_equal3(self):
"""test"""
with patch.dict(
saltcheck.__salt__,
{
"config.get": MagicMock(return_value=True),
"cp.cache_master": MagicMock(return_value=[True]),
},
):
sc_instance = saltcheck.SaltCheck()
aaa = 100
bbb = 100
mybool = sc_instance._SaltCheck__assert_less_equal(aaa, bbb)
self.assertEqual(mybool, "Pass")
def test__assert_not_in2(self):
"""test"""
with patch.dict(
saltcheck.__salt__,
{
"config.get": MagicMock(return_value=True),
"cp.cache_master": MagicMock(return_value=[True]),
},
):
sc_instance = saltcheck.SaltCheck()
aaa = "bob"
mylist = ["alice", "bob", "charles", "dana"]
mybool = sc_instance._SaltCheck__assert_not_in(aaa, mylist)
self.assertNotEqual(mybool, True)
def test_call_salt_command2(self):
"""test simple test.echo module again"""
with patch.dict(
saltcheck.__salt__,
{
"config.get": MagicMock(return_value=True),
"sys.list_modules": MagicMock(return_value=["module1"]),
"cp.cache_master": MagicMock(return_value=[True]),
},
):
sc_instance = saltcheck.SaltCheck()
returned = sc_instance._call_salt_command(
fun="test.echo", args=["hello"], kwargs=None
)
self.assertNotEqual(returned, "not-hello")
def test_validation(self):
"""test validation of tests"""
sc_instance = saltcheck.SaltCheck()
# Fail on empty test
test_dict = {}
expected_return = False
val_ret = sc_instance._SaltCheck__is_valid_test(test_dict)
self.assertEqual(val_ret, expected_return)
# Succeed on standard test
test_dict = {
"module_and_function": "test.echo",
"args": ["hello"],
"kwargs": {},
"assertion": "assertEqual",
"expected_return": "hello",
}
expected_return = True
with patch.dict(
saltcheck.__salt__,
{
"sys.list_modules": MagicMock(return_value=["test"]),
"sys.list_functions": MagicMock(return_value=["test.echo"]),
},
):
val_ret = sc_instance._SaltCheck__is_valid_test(test_dict)
self.assertEqual(val_ret, expected_return)
# Succeed on standard test with older expected-return syntax
test_dict = {
"module_and_function": "test.echo",
"args": ["hello"],
"kwargs": {},
"assertion": "assertEqual",
"expected-return": "hello",
}
expected_return = True
with patch.dict(
saltcheck.__salt__,
{
"sys.list_modules": MagicMock(return_value=["test"]),
"sys.list_functions": MagicMock(return_value=["test.echo"]),
},
):
val_ret = sc_instance._SaltCheck__is_valid_test(test_dict)
self.assertEqual(val_ret, expected_return)
# Do not require expected_return for some assertions
assertions = ["assertEmpty", "assertNotEmpty", "assertTrue", "assertFalse"]
for assertion in assertions:
test_dict = {"module_and_function": "test.echo", "args": ["hello"]}
test_dict["assertion"] = assertion
expected_return = True
with patch.dict(
saltcheck.__salt__,
{
"sys.list_modules": MagicMock(return_value=["test"]),
"sys.list_functions": MagicMock(return_value=["test.echo"]),
},
):
val_ret = sc_instance._SaltCheck__is_valid_test(test_dict)
self.assertEqual(val_ret, expected_return)
# Fail on invalid module
test_dict = {
"module_and_function": "broken.echo",
"args": ["hello"],
"kwargs": {},
"assertion": "assertEqual",
"expected_return": "hello",
}
expected_return = False
with patch.dict(
saltcheck.__salt__,
{
"sys.list_modules": MagicMock(return_value=["test"]),
"sys.list_functions": MagicMock(return_value=["test.echo"]),
},
):
val_ret = sc_instance._SaltCheck__is_valid_test(test_dict)
self.assertEqual(val_ret, expected_return)
# Fail on invalid function
test_dict = {
"module_and_function": "test.broken",
"args": ["hello"],
"kwargs": {},
"assertion": "assertEqual",
"expected_return": "hello",
}
expected_return = False
with patch.dict(
saltcheck.__salt__,
{
"sys.list_modules": MagicMock(return_value=["test"]),
"sys.list_functions": MagicMock(return_value=["test.echo"]),
},
):
val_ret = sc_instance._SaltCheck__is_valid_test(test_dict)
self.assertEqual(val_ret, expected_return)
# Fail on missing expected_return
test_dict = {
"module_and_function": "test.echo",
"args": ["hello"],
"kwargs": {},
"assertion": "assertEqual",
}
expected_return = False
with patch.dict(
saltcheck.__salt__,
{
"sys.list_modules": MagicMock(return_value=["test"]),
"sys.list_functions": MagicMock(return_value=["test.echo"]),
},
):
val_ret = sc_instance._SaltCheck__is_valid_test(test_dict)
self.assertEqual(val_ret, expected_return)
# Fail on empty expected_return
test_dict = {
"module_and_function": "test.echo",
"args": ["hello"],
"kwargs": {},
"assertion": "assertEqual",
"expected_return": None,
}
expected_return = False
with patch.dict(
saltcheck.__salt__,
{
"sys.list_modules": MagicMock(return_value=["test"]),
"sys.list_functions": MagicMock(return_value=["test.echo"]),
},
):
val_ret = sc_instance._SaltCheck__is_valid_test(test_dict)
self.assertEqual(val_ret, expected_return)
# Succeed on m_and_f saltcheck.state_apply with only args
test_dict = {"module_and_function": "saltcheck.state_apply", "args": ["common"]}
expected_return = True
with patch.dict(
saltcheck.__salt__,
{
"sys.list_modules": MagicMock(return_value=["saltcheck"]),
"sys.list_functions": MagicMock(return_value=["saltcheck.state_apply"]),
},
):
val_ret = sc_instance._SaltCheck__is_valid_test(test_dict)
self.assertEqual(val_ret, expected_return)
def test_validation(self):
'''test validation of tests'''
sc_instance = saltcheck.SaltCheck()
# Fail on empty test
test_dict = {}
expected_return = False
val_ret = sc_instance._SaltCheck__is_valid_test(test_dict)
self.assertEqual(val_ret, expected_return)
# Succeed on standard test
test_dict = {
'module_and_function': 'test.echo',
'args': ["hello"],
'kwargs': {},
'assertion': 'assertEqual',
'expected_return': 'hello'
}
expected_return = True
with patch.dict(saltcheck.__salt__, {'sys.list_modules': MagicMock(return_value=['test']),
'sys.list_functions': MagicMock(return_value=['test.echo'])
}):
val_ret = sc_instance._SaltCheck__is_valid_test(test_dict)
self.assertEqual(val_ret, expected_return)
# Succeed on standard test with older expected-return syntax
test_dict = {
'module_and_function': 'test.echo',
'args': ["hello"],
'kwargs': {},
'assertion': 'assertEqual',
'expected-return': 'hello'
}
expected_return = True
with patch.dict(saltcheck.__salt__, {'sys.list_modules': MagicMock(return_value=['test']),
'sys.list_functions': MagicMock(return_value=['test.echo'])
}):
val_ret = sc_instance._SaltCheck__is_valid_test(test_dict)
self.assertEqual(val_ret, expected_return)
# Do not require expected_return for some assertions
assertions = ["assertEmpty",
"assertNotEmpty",
"assertTrue",
"assertFalse"]
for assertion in assertions:
test_dict = {
'module_and_function': 'test.echo',
'args': ["hello"]
}
test_dict['assertion'] = assertion
expected_return = True
with patch.dict(saltcheck.__salt__, {'sys.list_modules': MagicMock(return_value=['test']),
'sys.list_functions': MagicMock(return_value=['test.echo'])
}):
val_ret = sc_instance._SaltCheck__is_valid_test(test_dict)
self.assertEqual(val_ret, expected_return)
# Fail on invalid module
test_dict = {
'module_and_function': 'broken.echo',
'args': ["hello"],
'kwargs': {},
'assertion': 'assertEqual',
'expected_return': 'hello'
}
expected_return = False
with patch.dict(saltcheck.__salt__, {'sys.list_modules': MagicMock(return_value=['test']),
'sys.list_functions': MagicMock(return_value=['test.echo'])
}):
val_ret = sc_instance._SaltCheck__is_valid_test(test_dict)
self.assertEqual(val_ret, expected_return)
# Fail on invalid function
test_dict = {
'module_and_function': 'test.broken',
'args': ["hello"],
'kwargs': {},
'assertion': 'assertEqual',
'expected_return': 'hello'
}
expected_return = False
with patch.dict(saltcheck.__salt__, {'sys.list_modules': MagicMock(return_value=['test']),
'sys.list_functions': MagicMock(return_value=['test.echo'])
}):
val_ret = sc_instance._SaltCheck__is_valid_test(test_dict)
self.assertEqual(val_ret, expected_return)
# Fail on missing expected_return
test_dict = {
'module_and_function': 'test.echo',
'args': ["hello"],
'kwargs': {},
'assertion': 'assertEqual'
}
expected_return = False
with patch.dict(saltcheck.__salt__, {'sys.list_modules': MagicMock(return_value=['test']),
'sys.list_functions': MagicMock(return_value=['test.echo'])
}):
val_ret = sc_instance._SaltCheck__is_valid_test(test_dict)
self.assertEqual(val_ret, expected_return)
# Fail on empty expected_return
test_dict = {
'module_and_function': 'test.echo',
'args': ["hello"],
'kwargs': {},
'assertion': 'assertEqual',
'expected_return': None
}
expected_return = False
with patch.dict(saltcheck.__salt__, {'sys.list_modules': MagicMock(return_value=['test']),
'sys.list_functions': MagicMock(return_value=['test.echo'])
}):
val_ret = sc_instance._SaltCheck__is_valid_test(test_dict)
self.assertEqual(val_ret, expected_return)
# Succeed on m_and_f saltcheck.state_apply with only args
test_dict = {
'module_and_function': 'saltcheck.state_apply',
'args': ["common"]
}
expected_return = True
with patch.dict(saltcheck.__salt__, {'sys.list_modules': MagicMock(return_value=['saltcheck']),
'sys.list_functions': MagicMock(return_value=['saltcheck.state_apply'])
}):
val_ret = sc_instance._SaltCheck__is_valid_test(test_dict)
self.assertEqual(val_ret, expected_return)
