class ValidationTestCase(unittest.TestCase):
""" Test validation of -o options on create """
@unittest.skipIf(not vsan_info.get_vsan_datastore(),
"VSAN is not found - skipping vsan_info tests")
def setUp(self):
""" Create a bunch of policies """
self.policy_names = ['name1', 'name2', 'name3']
self.policy_content = ('(("proportionalCapacity" i50) '
'("hostFailuresToTolerate" i0))')
self.path = vsan_info.get_vsan_datastore().info.url
for n in self.policy_names:
result = vsan_policy.create(n, self.policy_content)
self.assertEquals(None, result,
"failed creating policy %s (%s)" % (n, result))
def tearDown(self):
for n in self.policy_names:
try:
vsan_policy.delete(n)
except:
pass
def test_success(self):
sizes = ['2gb', '200tb', '200mb', '5kb']
sizes.extend([s.upper() for s in sizes])
for s in sizes:
for p in self.policy_names:
for d in volume_kv.VALID_ALLOCATION_FORMATS:
# An exception should not be raised
vmdk_ops.validate_opts(
{
volume_kv.SIZE: s,
volume_kv.VSAN_POLICY_NAME: p,
volume_kv.DISK_ALLOCATION_FORMAT: d
}, self.path)
vmdk_ops.validate_opts({volume_kv.SIZE: s}, self.path)
vmdk_ops.validate_opts({volume_kv.VSAN_POLICY_NAME: p},
self.path)
vmdk_ops.validate_opts(
{volume_kv.DISK_ALLOCATION_FORMAT: d}, self.path)
def test_failure(self):
bad = [{
volume_kv.SIZE: '2'
}, {
volume_kv.VSAN_POLICY_NAME: 'bad-policy'
}, {
volume_kv.DISK_ALLOCATION_FORMAT: 'thiN'
}, {
volume_kv.SIZE: 'mb'
}, {
'bad-option': '4'
}, {
'bad-option': 'what',
volume_kv.SIZE: '4mb'
}]
for opts in bad:
with self.assertRaises(vmdk_ops.ValidationError):
vmdk_ops.validate_opts(opts, self.path)
def test_ds(self):
self.assertNotEqual(vsan_info.get_vsan_datastore(), None,
"Failed to find VSAN datastore")
self.assertTrue(vsan_info.is_on_vsan(self.VMDK_PATH),
"is_on_vsan can't find file %s" % self.VMDK_PATH)
self.assertFalse(
vsan_info.is_on_vsan(self.NON_VSAN_VMDK),
"is_on_vsan is mistaken about the file %s" % self.NON_VSAN_VMDK)
def test_ds(self):
self.assertNotEqual(vsan_info.get_vsan_datastore(), None,
"Failed to find VSAN datastore")
self.assertTrue(
vsan_info.is_on_vsan(self.VMDK_PATH),
"is_on_vsan can't find file %s" % self.VMDK_PATH)
self.assertFalse(
vsan_info.is_on_vsan(self.NON_VSAN_VMDK),
"is_on_vsan is mistaken about the file %s" % self.NON_VSAN_VMDK)
def setUp(self):
""" Create a bunch of policies """
self.policy_names = ['name1', 'name2', 'name3']
self.policy_content = ('(("proportionalCapacity" i50) '
'("hostFailuresToTolerate" i0))')
self.path = vsan_info.get_vsan_datastore().info.url
for n in self.policy_names:
result = vsan_policy.create(n, self.policy_content)
self.assertEquals(None, result,
"failed creating policy %s (%s)" % (n, result))
def get_vsan_dockvols_path():
"""
Return the VSAN datastore dockvols path for a given cluster. Default to the
first datastore for now, so we can test without VSAN.
"""
datastore = vsan_info.get_vsan_datastore()
if datastore:
return os.path.join(datastore.info.url, 'dockvols')
else:
return None
def setUp(self):
""" Create a bunch of policies """
self.policy_names = ['name1', 'name2', 'name3']
self.policy_content = ('(("proportionalCapacity" i50) '
'("hostFailuresToTolerate" i0))')
self.path = vsan_info.get_vsan_datastore().info.url
for n in self.policy_names:
result = vsan_policy.create(n, self.policy_content)
self.assertEquals(None, result,
"failed creating policy %s (%s)" % (n, result))
def get_vsan_dockvols_path():
"""
Return the VSAN datastore dockvols path for a given cluster. Default to the
first datastore for now, so we can test without VSAN.
"""
datastore = vsan_info.get_vsan_datastore()
if datastore:
return os.path.join(datastore.info.url, 'dockvols')
else:
return None
class TestVsanPolicy(unittest.TestCase):
""" Test VSAN Policy code """
@unittest.skipIf(not vsan_info.get_vsan_datastore(),
"VSAN is not found - skipping vsan_info tests")
def setUp(self):
self.policy_path = os.path.join(vsan_info.get_vsan_dockvols_path(),
'policies/test_policy')
self.name = 'test_policy'
self.content = ('(("proportionalCapacity" i50) '
'("hostFailuresToTolerate" i0))')
def tearDown(self):
try:
os.remove(self.policy_path)
except:
pass
def assertPoliciesEqual(self):
with open(self.policy_path) as f:
content = f.read()
# Remove the added newline
self.assertEqual(content[:-1], self.content)
def test_create(self):
self.assertEqual(None, vsan_policy.create(self.name, self.content))
self.assertPoliciesEqual()
def test_double_create_fails(self):
self.assertEqual(None, vsan_policy.create(self.name, self.content))
self.assertNotEqual(None, vsan_policy.create(self.name, self.content))
self.assertPoliciesEqual()
def test_create_delete(self):
self.assertEqual(None, vsan_policy.create(self.name, self.content))
self.assertPoliciesEqual()
self.assertEqual(None, vsan_policy.delete(self.name))
self.assertFalse(os.path.isfile(self.policy_path))
def test_delete_nonexistent_policy_fails(self):
log = log_config.get_logger('Delete_nonexistent_policy')
log.info(
"\nThis is a negative test to delete a non-existent vsan policy.\n"
"Test is expected to raise exception log - Failed to remove the policy file error. \n"
)
self.assertNotEqual(None, vsan_policy.delete(self.name))
def test_create_list(self):
self.assertEqual(None, vsan_policy.create(self.name, self.content))
policies = vsan_policy.get_policies()
self.assertTrue(self.content + '\n', policies[self.name])
# See the License for the specific language governing permissions and
# limitations under the License.#
#
# tests for vsan_info.py
import unittest
import log_config
import volume_kv as kv
import vmdk_ops
import os.path
import pyVim.connect
import vsan_info
@unittest.skipIf(not vsan_info.get_vsan_datastore(),
"VSAN is not found - skipping vsan_info tests")
class TestVsanInfo(unittest.TestCase):
""" Test VSAN Info API """
VM_NAME = "test-vm"
VSAN_DS = "/vmfs/volumes/"+vsan_info.get_vsan_datastore().info.name
TEST_DIR = os.path.join(VSAN_DS, "vsan_info_test")
TEST_VOL = "test_policy_vol"
VMDK_PATH = os.path.join(TEST_DIR, TEST_VOL + ".vmdk")
NON_VSAN_VMDK = "/vmfs/volumes/datastore/eek/other.vmdk"
# make sure dir is there, failure "already exits" is OK here
vmdk_ops.RunCommand("/usr/lib/vmware/osfs/bin/osfs-mkdir " + TEST_DIR)
def __init__(self, *args, **kwargs):
# See the License for the specific language governing permissions and
# limitations under the License.#
#
# tests for vsan_info.py
import unittest
import log_config
import volume_kv as kv
import vmdk_ops
import os.path
import pyVim.connect
import vsan_info
@unittest.skipIf(not vsan_info.get_vsan_datastore(),
"VSAN is not found - skipping vsan_info tests")
class TestVsanInfo(unittest.TestCase):
""" Test VSAN Info API """
VM_NAME = "test-vm"
VSAN_DS = "/vmfs/volumes/vsanDatastore"
TEST_DIR = os.path.join(VSAN_DS, "vsan_info_test")
TEST_VOL = "test_policy_vol"
VMDK_PATH = os.path.join(TEST_DIR, TEST_VOL + ".vmdk")
NON_VSAN_VMDK = "/vmfs/volumes/datastore/eek/other.vmdk"
# make sure dir is there, failure "already exits" is OK here
vmdk_ops.RunCommand("/usr/lib/vmware/osfs/bin/osfs-mkdir " + TEST_DIR)
def __init__(self, *args, **kwargs):
class VmdkCreateRemoveTestCase(unittest.TestCase):
"""Unit test for VMDK Create and Remove ops"""
volName = "vol_UnitTest_Create"
badOpts = {
u'policy': u'good',
volume_kv.SIZE: u'12unknown',
volume_kv.DISK_ALLOCATION_FORMAT: u'5disk'
}
invalid_access_choice = {volume_kv.ACCESS: u'only-read'}
invalid_access_opt = {u'acess': u'read-write'}
valid_access_opt = {volume_kv.ACCESS: 'read-only'}
name = ""
vm_name = 'test-vm'
def setUp(self):
self.name = vmdk_utils.get_vmdk_path(path, self.volName)
self.policy_names = ['good', 'impossible']
self.orig_policy_content = ('(("proportionalCapacity" i0) '
'("hostFailuresToTolerate" i0))')
self.new_policy_content = '(("hostFailuresToTolerate" i0))'
for n in self.policy_names:
vsan_policy.create(n, self.orig_policy_content)
def tearDown(self):
vmdk_ops.removeVMDK(self.name)
self.vmdk = None
for n in self.policy_names:
vsan_policy.delete(n)
def testCreateDelete(self):
err = vmdk_ops.createVMDK(vm_name=self.vm_name,
vmdk_path=self.name,
vol_name=self.volName)
self.assertEqual(err, None, err)
self.assertEqual(os.path.isfile(self.name), True,
"VMDK {0} is missing after create.".format(self.name))
err = vmdk_ops.removeVMDK(self.name)
self.assertEqual(err, None, err)
self.assertEqual(
os.path.isfile(self.name), False,
"VMDK {0} is still present after delete.".format(self.name))
def testBadOpts(self):
err = vmdk_ops.createVMDK(vm_name=self.vm_name,
vmdk_path=self.name,
vol_name=self.volName,
opts=self.badOpts)
logging.info(err)
self.assertNotEqual(err, None, err)
err = vmdk_ops.removeVMDK(self.name)
logging.info(err)
self.assertNotEqual(err, None, err)
def testAccessOpts(self):
err = vmdk_ops.createVMDK(vm_name=self.vm_name,
vmdk_path=self.name,
vol_name=self.volName,
opts=self.invalid_access_choice)
logging.info(err)
self.assertNotEqual(err, None, err)
err = vmdk_ops.createVMDK(vm_name=self.vm_name,
vmdk_path=self.name,
vol_name=self.volName,
opts=self.invalid_access_opt)
logging.info(err)
self.assertNotEqual(err, None, err)
err = vmdk_ops.createVMDK(vm_name=self.vm_name,
vmdk_path=self.name,
vol_name=self.volName,
opts=self.valid_access_opt)
logging.info(err)
self.assertEqual(err, None, err)
err = vmdk_ops.removeVMDK(self.name)
logging.info(err)
self.assertEqual(err, None, err)
@unittest.skipIf(not vsan_info.get_vsan_datastore(),
"VSAN is not found - skipping vsan_info tests")
def testPolicyUpdate(self):
path = vsan_info.get_vsan_dockvols_path()
vmdk_path = vmdk_utils.get_vmdk_path(path, self.volName)
err = vmdk_ops.createVMDK(vm_name=self.vm_name,
vmdk_path=vmdk_path,
vol_name=self.volName,
opts={'vsan-policy-name': 'good'})
self.assertEqual(err, None, err)
self.assertEqual(None,
vsan_policy.update('good', self.new_policy_content))
# Setting an identical policy returns an error msg
self.assertNotEqual(
None, vsan_policy.update('good', self.new_policy_content))
backup_policy_file = vsan_policy.backup_policy_filename(self.name)
#Ensure there is no backup policy file
self.assertFalse(os.path.isfile(backup_policy_file))
# Fail to update because of a bad policy, and ensure there is no backup
self.assertNotEqual(None, vsan_policy.update('good', 'blah'))
self.assertFalse(os.path.isfile(backup_policy_file))
@unittest.skipIf(not vsan_info.get_vsan_datastore(),
"VSAN is not found - skipping vsan_info tests")
def testPolicy(self):
# info for testPolicy
testInfo = [
# size policy expected success?
["2000kb", "good", True, "zeroedthick"],
["14000pb", "good", False, "zeroedthick"],
["bad size", "good", False, "eagerzeroedthick"],
["100mb", "impossible", True, "eagerzeroedthick"],
["100mb", "good", True, "thin"],
]
path = vsan_info.get_vsan_dockvols_path()
i = 0
for unit in testInfo:
vol_name = '{0}{1}'.format(self.volName, i)
vmdk_path = vmdk_utils.get_vmdk_path(path, vol_name)
i = i + 1
# create a volume with requests size/policy and check vs expected result
err = vmdk_ops.createVMDK(vm_name=self.vm_name,
vmdk_path=vmdk_path,
vol_name=vol_name,
opts={
volume_kv.VSAN_POLICY_NAME: unit[1],
volume_kv.SIZE: unit[0],
volume_kv.DISK_ALLOCATION_FORMAT:
unit[3]
})
self.assertEqual(err == None, unit[2], err)
# clean up should fail if the created should have failed.
err = vmdk_ops.removeVMDK(vmdk_path)
self.assertEqual(err == None, unit[2], err)
class VmdkCreateRemoveTestCase(unittest.TestCase):
"""Unit test for VMDK Create and Remove ops"""
volName = "vol_UnitTest_Create"
badOpts = {u'policy': u'good', volume_kv.SIZE: u'12unknown'}
name = ""
vm_name = 'test-vm'
def setUp(self):
self.name = vmdk_ops.getVmdkName(path, self.volName)
self.policy_names = ['good', 'impossible']
policy_content = ('(("proportionalCapacity" i50) '
'("hostFailuresToTolerate" i0))')
for n in self.policy_names:
vsan_policy.create(n, policy_content)
def tearDown(self):
self.vmdk = None
for n in self.policy_names:
vsan_policy.delete(n)
def testCreateDelete(self):
err = vmdk_ops.createVMDK(vm_name=self.vm_name,
vmdk_path=self.name,
vol_name=self.volName)
self.assertEqual(err, None, err)
self.assertEqual(
os.path.isfile(self.name), True,
"VMDK {0} is missing after create.".format(self.name))
err = vmdk_ops.removeVMDK(self.name)
self.assertEqual(err, None, err)
self.assertEqual(
os.path.isfile(self.name), False,
"VMDK {0} is still present after delete.".format(self.name))
def testBadOpts(self):
err = vmdk_ops.createVMDK(vm_name=self.vm_name,
vmdk_path=self.name,
vol_name=self.volName,
opts=self.badOpts)
logging.info(err)
self.assertNotEqual(err, None, err)
err = vmdk_ops.removeVMDK(self.name)
logging.info(err)
self.assertNotEqual(err, None, err)
@unittest.skipIf(not vsan_info.get_vsan_datastore(),
"VSAN is not found - skipping vsan_info tests")
def testPolicy(self):
# info for testPolicy
testInfo = [
# size policy expected success?
["2000kb", "good", True],
["14000pb", "good", False],
["bad size", "good", False],
["100mb", "impossible", True],
["100mb", "good", True],
]
path = vmdk_utils.get_vsan_dockvols_path()
i = 0
for unit in testInfo:
vol_name = '{0}{1}'.format(self.volName, i)
vmdk_path = vmdk_ops.getVmdkName(path,vol_name)
i = i+1
# create a volume with requestes size/policy and check vs expected result
err = vmdk_ops.createVMDK(vm_name=self.vm_name,
vmdk_path=vmdk_path,
vol_name=vol_name,
opts={volume_kv.VSAN_POLICY_NAME: unit[1],
volume_kv.SIZE: unit[0]})
self.assertEqual(err == None, unit[2], err)
# clean up should fail if the created should have failed.
err = vmdk_ops.removeVMDK(vmdk_path)
self.assertEqual(err == None, unit[2], err)
class TestVsanInfo(unittest.TestCase):
""" Test VSAN Info API """
VM_NAME = "test-vm"
VSAN_DS = "/vmfs/volumes/" + vsan_info.get_vsan_datastore().info.name
TEST_DIR = os.path.join(VSAN_DS, "vsan_info_test")
TEST_VOL = "test_policy_vol"
VMDK_PATH = os.path.join(TEST_DIR, TEST_VOL + ".vmdk")
NON_VSAN_VMDK = "/vmfs/volumes/datastore/eek/other.vmdk"
# make sure dir is there, failure "already exits" is OK here
vmdk_ops.RunCommand("/usr/lib/vmware/osfs/bin/osfs-mkdir " + TEST_DIR)
def __init__(self, *args, **kwargs):
super(TestVsanInfo, self).__init__(*args, **kwargs)
self.si = None
def setUp(self):
"""create a vmdk before each test (method) in this class"""
si = vmdk_ops.get_si()
# create VMDK
err = vmdk_ops.createVMDK(vmdk_path=self.VMDK_PATH,
vm_name=self.VM_NAME,
vol_name="test_policy_vol")
self.assertEqual(err, None, err)
def tearDown(self):
"""clean up after each test (method) in this class"""
err = vmdk_ops.removeVMDK(self.VMDK_PATH)
self.assertEqual(err, None, err)
pyVim.connect.Disconnect(self.si)
def test_ds(self):
self.assertNotEqual(vsan_info.get_vsan_datastore(), None,
"Failed to find VSAN datastore")
self.assertTrue(vsan_info.is_on_vsan(self.VMDK_PATH),
"is_on_vsan can't find file %s" % self.VMDK_PATH)
self.assertFalse(
vsan_info.is_on_vsan(self.NON_VSAN_VMDK),
"is_on_vsan is mistaken about the file %s" % self.NON_VSAN_VMDK)
def test_policy(self):
# check it's on VSAN
self.assertTrue(vsan_info.is_on_vsan(self.VMDK_PATH),
"is_on_vsan can't find file %s" % self.VMDK_PATH)
# set policy
policy_string = \
'(("hostFailuresToTolerate" i0) ("forceProvisioning" i1))'
# same policy content with different space/tabs:
same_policy = \
' (( "hostFailuresToTolerate" \ti0) ("forceProvisioning" i1))'
# different content:
notsame_policy = \
'(("hostFailuresToTolerate" i0) ("forceProvisioning" i0))'
err = vsan_info.set_policy(self.VMDK_PATH, policy_string)
self.assertEqual(err, None, "failed to set")
# get policy and check it
p = vsan_info.get_policy(self.VMDK_PATH)
self.assertTrue(vsan_info.same_policy(self.VMDK_PATH, p),
"failed to compare with get_policy")
self.assertTrue(vsan_info.same_policy(self.VMDK_PATH, policy_string),
"failed to compare with original policy")
self.assertTrue(vsan_info.same_policy(self.VMDK_PATH, same_policy),
"failed to compare with same policy, different tabs")
self.assertFalse(vsan_info.same_policy(self.VMDK_PATH, notsame_policy),
"failed to compare with different policy")
