Revision 41044e04 test/py/ganeti.cmdlib_unittest.py
| b/test/py/ganeti.cmdlib_unittest.py | ||
|---|---|---|
| 673 | 673 |
# Minimal policy accepted by _ComputeIPolicySpecViolation() |
| 674 | 674 |
_MICRO_IPOL = {
|
| 675 | 675 |
constants.IPOLICY_DTS: [constants.DT_PLAIN, constants.DT_DISKLESS], |
| 676 |
constants.ISPECS_MINMAX: NotImplemented,
|
|
| 676 |
constants.ISPECS_MINMAX: [NotImplemented],
|
|
| 677 | 677 |
} |
| 678 | 678 |
|
| 679 | 679 |
def test(self): |
| ... | ... | |
| 719 | 719 |
self.assertEqual(ret, ["foo", "bar"]) |
| 720 | 720 |
self.assertFalse(spec.spec) |
| 721 | 721 |
|
| 722 |
def testWithIPolicy(self): |
|
| 723 |
mem_size = 2048 |
|
| 724 |
cpu_count = 2 |
|
| 725 |
disk_count = 1 |
|
| 726 |
disk_sizes = [512] |
|
| 727 |
nic_count = 1 |
|
| 728 |
spindle_use = 4 |
|
| 729 |
disk_template = "mytemplate" |
|
| 730 |
ispec = {
|
|
| 731 |
constants.ISPEC_MEM_SIZE: mem_size, |
|
| 732 |
constants.ISPEC_CPU_COUNT: cpu_count, |
|
| 733 |
constants.ISPEC_DISK_COUNT: disk_count, |
|
| 734 |
constants.ISPEC_DISK_SIZE: disk_sizes[0], |
|
| 735 |
constants.ISPEC_NIC_COUNT: nic_count, |
|
| 736 |
constants.ISPEC_SPINDLE_USE: spindle_use, |
|
| 737 |
} |
|
| 738 |
ipolicy1 = {
|
|
| 739 |
constants.ISPECS_MINMAX: [{
|
|
| 740 |
constants.ISPECS_MIN: ispec, |
|
| 741 |
constants.ISPECS_MAX: ispec, |
|
| 742 |
}], |
|
| 743 |
constants.IPOLICY_DTS: [disk_template], |
|
| 744 |
} |
|
| 745 |
ispec_copy = copy.deepcopy(ispec) |
|
| 746 |
ipolicy2 = {
|
|
| 747 |
constants.ISPECS_MINMAX: [ |
|
| 748 |
{
|
|
| 749 |
constants.ISPECS_MIN: ispec_copy, |
|
| 750 |
constants.ISPECS_MAX: ispec_copy, |
|
| 751 |
}, |
|
| 752 |
{
|
|
| 753 |
constants.ISPECS_MIN: ispec, |
|
| 754 |
constants.ISPECS_MAX: ispec, |
|
| 755 |
}, |
|
| 756 |
], |
|
| 757 |
constants.IPOLICY_DTS: [disk_template], |
|
| 758 |
} |
|
| 759 |
ipolicy3 = {
|
|
| 760 |
constants.ISPECS_MINMAX: [ |
|
| 761 |
{
|
|
| 762 |
constants.ISPECS_MIN: ispec, |
|
| 763 |
constants.ISPECS_MAX: ispec, |
|
| 764 |
}, |
|
| 765 |
{
|
|
| 766 |
constants.ISPECS_MIN: ispec_copy, |
|
| 767 |
constants.ISPECS_MAX: ispec_copy, |
|
| 768 |
}, |
|
| 769 |
], |
|
| 770 |
constants.IPOLICY_DTS: [disk_template], |
|
| 771 |
} |
|
| 772 |
def AssertComputeViolation(ipolicy, violations): |
|
| 773 |
ret = cmdlib._ComputeIPolicySpecViolation(ipolicy, mem_size, cpu_count, |
|
| 774 |
disk_count, nic_count, |
|
| 775 |
disk_sizes, spindle_use, |
|
| 776 |
disk_template) |
|
| 777 |
self.assertEqual(len(ret), violations) |
|
| 778 |
|
|
| 779 |
AssertComputeViolation(ipolicy1, 0) |
|
| 780 |
AssertComputeViolation(ipolicy2, 0) |
|
| 781 |
AssertComputeViolation(ipolicy3, 0) |
|
| 782 |
for par in constants.ISPECS_PARAMETERS: |
|
| 783 |
ispec[par] += 1 |
|
| 784 |
AssertComputeViolation(ipolicy1, 1) |
|
| 785 |
AssertComputeViolation(ipolicy2, 0) |
|
| 786 |
AssertComputeViolation(ipolicy3, 0) |
|
| 787 |
ispec[par] -= 2 |
|
| 788 |
AssertComputeViolation(ipolicy1, 1) |
|
| 789 |
AssertComputeViolation(ipolicy2, 0) |
|
| 790 |
AssertComputeViolation(ipolicy3, 0) |
|
| 791 |
ispec[par] += 1 # Restore |
|
| 792 |
ipolicy1[constants.IPOLICY_DTS] = ["another_template"] |
|
| 793 |
AssertComputeViolation(ipolicy1, 1) |
|
| 794 |
|
|
| 722 | 795 |
|
| 723 | 796 |
class _StubComputeIPolicySpecViolation: |
| 724 | 797 |
def __init__(self, mem_size, cpu_count, disk_count, nic_count, disk_sizes, |
| ... | ... | |
| 1733 | 1806 |
"""Tests for cmdlib._GetUpdatedIPolicy()""" |
| 1734 | 1807 |
_OLD_CLUSTER_POLICY = {
|
| 1735 | 1808 |
constants.IPOLICY_VCPU_RATIO: 1.5, |
| 1736 |
constants.ISPECS_MINMAX: constants.ISPECS_MINMAX_DEFAULTS, |
|
| 1809 |
constants.ISPECS_MINMAX: [ |
|
| 1810 |
{
|
|
| 1811 |
constants.ISPECS_MIN: {
|
|
| 1812 |
constants.ISPEC_MEM_SIZE: 32768, |
|
| 1813 |
constants.ISPEC_CPU_COUNT: 8, |
|
| 1814 |
constants.ISPEC_DISK_COUNT: 1, |
|
| 1815 |
constants.ISPEC_DISK_SIZE: 1024, |
|
| 1816 |
constants.ISPEC_NIC_COUNT: 1, |
|
| 1817 |
constants.ISPEC_SPINDLE_USE: 1, |
|
| 1818 |
}, |
|
| 1819 |
constants.ISPECS_MAX: {
|
|
| 1820 |
constants.ISPEC_MEM_SIZE: 65536, |
|
| 1821 |
constants.ISPEC_CPU_COUNT: 10, |
|
| 1822 |
constants.ISPEC_DISK_COUNT: 5, |
|
| 1823 |
constants.ISPEC_DISK_SIZE: 1024 * 1024, |
|
| 1824 |
constants.ISPEC_NIC_COUNT: 3, |
|
| 1825 |
constants.ISPEC_SPINDLE_USE: 12, |
|
| 1826 |
}, |
|
| 1827 |
}, |
|
| 1828 |
constants.ISPECS_MINMAX_DEFAULTS, |
|
| 1829 |
], |
|
| 1737 | 1830 |
constants.ISPECS_STD: constants.IPOLICY_DEFAULTS[constants.ISPECS_STD], |
| 1738 | 1831 |
} |
| 1739 | 1832 |
_OLD_GROUP_POLICY = {
|
| 1740 | 1833 |
constants.IPOLICY_SPINDLE_RATIO: 2.5, |
| 1741 |
constants.ISPECS_MINMAX: {
|
|
| 1834 |
constants.ISPECS_MINMAX: [{
|
|
| 1742 | 1835 |
constants.ISPECS_MIN: {
|
| 1743 | 1836 |
constants.ISPEC_MEM_SIZE: 128, |
| 1744 | 1837 |
constants.ISPEC_CPU_COUNT: 1, |
| ... | ... | |
| 1755 | 1848 |
constants.ISPEC_NIC_COUNT: 3, |
| 1756 | 1849 |
constants.ISPEC_SPINDLE_USE: 12, |
| 1757 | 1850 |
}, |
| 1758 |
}, |
|
| 1851 |
}],
|
|
| 1759 | 1852 |
} |
| 1760 | 1853 |
|
| 1761 | 1854 |
def _TestSetSpecs(self, old_policy, isgroup): |
| 1762 |
diff_minmax = {
|
|
| 1855 |
diff_minmax = [{
|
|
| 1763 | 1856 |
constants.ISPECS_MIN: {
|
| 1764 | 1857 |
constants.ISPEC_MEM_SIZE: 64, |
| 1765 | 1858 |
constants.ISPEC_CPU_COUNT: 1, |
| ... | ... | |
| 1776 | 1869 |
constants.ISPEC_NIC_COUNT: 9, |
| 1777 | 1870 |
constants.ISPEC_SPINDLE_USE: 18, |
| 1778 | 1871 |
}, |
| 1779 |
} |
|
| 1872 |
}]
|
|
| 1780 | 1873 |
diff_std = {
|
| 1781 | 1874 |
constants.ISPEC_DISK_COUNT: 10, |
| 1782 | 1875 |
constants.ISPEC_DISK_SIZE: 512, |
| ... | ... | |
| 1847 | 1940 |
self.assertRaises(errors.OpPrereqError, cmdlib._GetUpdatedIPolicy, |
| 1848 | 1941 |
old_policy, diff_policy, group_policy=False) |
| 1849 | 1942 |
|
| 1943 |
def testUnsetEmpty(self): |
|
| 1944 |
old_policy = {}
|
|
| 1945 |
for key in constants.IPOLICY_ALL_KEYS: |
|
| 1946 |
diff_policy = {
|
|
| 1947 |
key: constants.VALUE_DEFAULT, |
|
| 1948 |
} |
|
| 1949 |
new_policy = cmdlib._GetUpdatedIPolicy(old_policy, diff_policy, |
|
| 1950 |
group_policy=True) |
|
| 1951 |
self.assertEqual(new_policy, old_policy) |
|
| 1952 |
|
|
| 1850 | 1953 |
def _TestInvalidKeys(self, old_policy, isgroup): |
| 1851 | 1954 |
INVALID_KEY = "this_key_shouldnt_be_allowed" |
| 1852 | 1955 |
INVALID_DICT = {
|
| ... | ... | |
| 1856 | 1959 |
self.assertRaises(errors.OpPrereqError, cmdlib._GetUpdatedIPolicy, |
| 1857 | 1960 |
old_policy, invalid_policy, group_policy=isgroup) |
| 1858 | 1961 |
invalid_ispecs = {
|
| 1859 |
constants.ISPECS_MINMAX: INVALID_DICT,
|
|
| 1962 |
constants.ISPECS_MINMAX: [INVALID_DICT],
|
|
| 1860 | 1963 |
} |
| 1861 | 1964 |
self.assertRaises(errors.TypeEnforcementError, cmdlib._GetUpdatedIPolicy, |
| 1862 | 1965 |
old_policy, invalid_ispecs, group_policy=isgroup) |
| ... | ... | |
| 1871 | 1974 |
invalid_policy = {
|
| 1872 | 1975 |
constants.ISPECS_MINMAX: invalid_ispecs, |
| 1873 | 1976 |
} |
| 1874 |
for key in constants.ISPECS_MINMAX_KEYS: |
|
| 1875 |
ispec = invalid_ispecs[key] |
|
| 1876 |
ispec[INVALID_KEY] = None |
|
| 1877 |
self.assertRaises(errors.TypeEnforcementError, cmdlib._GetUpdatedIPolicy, |
|
| 1878 |
old_policy, invalid_policy, group_policy=isgroup) |
|
| 1879 |
del ispec[INVALID_KEY] |
|
| 1880 |
for par in constants.ISPECS_PARAMETERS: |
|
| 1881 |
oldv = ispec[par] |
|
| 1882 |
ispec[par] = "this_is_not_good" |
|
| 1977 |
for minmax in invalid_ispecs: |
|
| 1978 |
for key in constants.ISPECS_MINMAX_KEYS: |
|
| 1979 |
ispec = minmax[key] |
|
| 1980 |
ispec[INVALID_KEY] = None |
|
| 1883 | 1981 |
self.assertRaises(errors.TypeEnforcementError, |
| 1884 |
cmdlib._GetUpdatedIPolicy, |
|
| 1885 |
old_policy, invalid_policy, group_policy=isgroup) |
|
| 1886 |
ispec[par] = oldv |
|
| 1982 |
cmdlib._GetUpdatedIPolicy, old_policy, |
|
| 1983 |
invalid_policy, group_policy=isgroup) |
|
| 1984 |
del ispec[INVALID_KEY] |
|
| 1985 |
for par in constants.ISPECS_PARAMETERS: |
|
| 1986 |
oldv = ispec[par] |
|
| 1987 |
ispec[par] = "this_is_not_good" |
|
| 1988 |
self.assertRaises(errors.TypeEnforcementError, |
|
| 1989 |
cmdlib._GetUpdatedIPolicy, |
|
| 1990 |
old_policy, invalid_policy, group_policy=isgroup) |
|
| 1991 |
ispec[par] = oldv |
|
| 1887 | 1992 |
# This is to make sure that no two errors were present during the tests |
| 1888 | 1993 |
cmdlib._GetUpdatedIPolicy(old_policy, invalid_policy, group_policy=isgroup) |
| 1889 | 1994 |
|
Also available in: Unified diff