Revision 0f511c8a test/py/ganeti.cmdlib_unittest.py
| b/test/py/ganeti.cmdlib_unittest.py | ||
|---|---|---|
| 1733 | 1733 |
"""Tests for cmdlib._GetUpdatedIPolicy()""" |
| 1734 | 1734 |
_OLD_CLUSTER_POLICY = {
|
| 1735 | 1735 |
constants.IPOLICY_VCPU_RATIO: 1.5, |
| 1736 |
constants.ISPECS_MINMAX: {
|
|
| 1737 |
constants.ISPECS_MIN: {
|
|
| 1738 |
constants.ISPEC_MEM_SIZE: 20, |
|
| 1739 |
constants.ISPEC_CPU_COUNT: 2, |
|
| 1740 |
}, |
|
| 1741 |
constants.ISPECS_MAX: {},
|
|
| 1742 |
}, |
|
| 1743 |
constants.ISPECS_STD: {},
|
|
| 1736 |
constants.ISPECS_MINMAX: constants.ISPECS_MINMAX_DEFAULTS, |
|
| 1737 |
constants.ISPECS_STD: constants.IPOLICY_DEFAULTS[constants.ISPECS_STD], |
|
| 1744 | 1738 |
} |
| 1745 | 1739 |
_OLD_GROUP_POLICY = {
|
| 1746 | 1740 |
constants.IPOLICY_SPINDLE_RATIO: 2.5, |
| 1747 | 1741 |
constants.ISPECS_MINMAX: {
|
| 1748 | 1742 |
constants.ISPECS_MIN: {
|
| 1749 |
constants.ISPEC_DISK_SIZE: 20, |
|
| 1750 |
constants.ISPEC_NIC_COUNT: 2, |
|
| 1743 |
constants.ISPEC_MEM_SIZE: 128, |
|
| 1744 |
constants.ISPEC_CPU_COUNT: 1, |
|
| 1745 |
constants.ISPEC_DISK_COUNT: 1, |
|
| 1746 |
constants.ISPEC_DISK_SIZE: 1024, |
|
| 1747 |
constants.ISPEC_NIC_COUNT: 1, |
|
| 1748 |
constants.ISPEC_SPINDLE_USE: 1, |
|
| 1749 |
}, |
|
| 1750 |
constants.ISPECS_MAX: {
|
|
| 1751 |
constants.ISPEC_MEM_SIZE: 32768, |
|
| 1752 |
constants.ISPEC_CPU_COUNT: 8, |
|
| 1753 |
constants.ISPEC_DISK_COUNT: 5, |
|
| 1754 |
constants.ISPEC_DISK_SIZE: 1024 * 1024, |
|
| 1755 |
constants.ISPEC_NIC_COUNT: 3, |
|
| 1756 |
constants.ISPEC_SPINDLE_USE: 12, |
|
| 1751 | 1757 |
}, |
| 1752 |
constants.ISPECS_MAX: {},
|
|
| 1753 | 1758 |
}, |
| 1754 | 1759 |
} |
| 1755 | 1760 |
|
| 1756 | 1761 |
def _TestSetSpecs(self, old_policy, isgroup): |
| 1757 |
ispec_key = constants.ISPECS_MIN |
|
| 1758 |
diff_ispec = {
|
|
| 1759 |
constants.ISPEC_MEM_SIZE: 50, |
|
| 1760 |
constants.ISPEC_DISK_SIZE: 30, |
|
| 1762 |
diff_minmax = {
|
|
| 1763 |
constants.ISPECS_MIN: {
|
|
| 1764 |
constants.ISPEC_MEM_SIZE: 64, |
|
| 1765 |
constants.ISPEC_CPU_COUNT: 1, |
|
| 1766 |
constants.ISPEC_DISK_COUNT: 2, |
|
| 1767 |
constants.ISPEC_DISK_SIZE: 64, |
|
| 1768 |
constants.ISPEC_NIC_COUNT: 1, |
|
| 1769 |
constants.ISPEC_SPINDLE_USE: 1, |
|
| 1770 |
}, |
|
| 1771 |
constants.ISPECS_MAX: {
|
|
| 1772 |
constants.ISPEC_MEM_SIZE: 16384, |
|
| 1773 |
constants.ISPEC_CPU_COUNT: 10, |
|
| 1774 |
constants.ISPEC_DISK_COUNT: 12, |
|
| 1775 |
constants.ISPEC_DISK_SIZE: 1024, |
|
| 1776 |
constants.ISPEC_NIC_COUNT: 9, |
|
| 1777 |
constants.ISPEC_SPINDLE_USE: 18, |
|
| 1778 |
}, |
|
| 1761 | 1779 |
} |
| 1780 |
diff_std = {
|
|
| 1781 |
constants.ISPEC_DISK_COUNT: 10, |
|
| 1782 |
constants.ISPEC_DISK_SIZE: 512, |
|
| 1783 |
} |
|
| 1762 | 1784 |
diff_policy = {
|
| 1763 |
constants.ISPECS_MINMAX: {
|
|
| 1764 |
ispec_key: diff_ispec, |
|
| 1765 |
}, |
|
| 1785 |
constants.ISPECS_MINMAX: diff_minmax |
|
| 1766 | 1786 |
} |
| 1767 | 1787 |
if not isgroup: |
| 1768 |
diff_std = {
|
|
| 1769 |
constants.ISPEC_CPU_COUNT: 3, |
|
| 1770 |
constants.ISPEC_DISK_COUNT: 3, |
|
| 1771 |
} |
|
| 1772 | 1788 |
diff_policy[constants.ISPECS_STD] = diff_std |
| 1773 | 1789 |
new_policy = cmdlib._GetUpdatedIPolicy(old_policy, diff_policy, |
| 1774 | 1790 |
group_policy=isgroup) |
| 1775 | 1791 |
|
| 1776 | 1792 |
self.assertTrue(constants.ISPECS_MINMAX in new_policy) |
| 1777 |
new_ispec = new_policy[constants.ISPECS_MINMAX][ispec_key] |
|
| 1778 |
for key in diff_ispec: |
|
| 1779 |
self.assertTrue(key in new_ispec) |
|
| 1780 |
self.assertEqual(new_ispec[key], diff_ispec[key]) |
|
| 1793 |
self.assertEqual(new_policy[constants.ISPECS_MINMAX], diff_minmax) |
|
| 1781 | 1794 |
for key in old_policy: |
| 1782 | 1795 |
if not key in diff_policy: |
| 1783 | 1796 |
self.assertTrue(key in new_policy) |
| 1784 | 1797 |
self.assertEqual(new_policy[key], old_policy[key]) |
| 1785 | 1798 |
|
| 1786 |
if constants.ISPECS_MINMAX in old_policy: |
|
| 1787 |
old_minmax = old_policy[constants.ISPECS_MINMAX] |
|
| 1788 |
for key in old_minmax: |
|
| 1789 |
if key != ispec_key: |
|
| 1790 |
self.assertTrue(key in new_policy[constants.ISPECS_MINMAX]) |
|
| 1791 |
self.assertEqual(new_policy[constants.ISPECS_MINMAX][key], |
|
| 1792 |
old_minmax[key]) |
|
| 1793 |
old_ispec = old_policy[constants.ISPECS_MINMAX][ispec_key] |
|
| 1794 |
for key in old_ispec: |
|
| 1795 |
if not key in diff_ispec: |
|
| 1796 |
self.assertTrue(key in new_ispec) |
|
| 1797 |
self.assertEqual(new_ispec[key], old_ispec[key]) |
|
| 1798 |
|
|
| 1799 | 1799 |
if not isgroup: |
| 1800 | 1800 |
new_std = new_policy[constants.ISPECS_STD] |
| 1801 | 1801 |
for key in diff_std: |
| 1802 | 1802 |
self.assertTrue(key in new_std) |
| 1803 | 1803 |
self.assertEqual(new_std[key], diff_std[key]) |
| 1804 |
old_std = old_policy.get(constants.ISPECS_STD, {})
|
|
| 1805 |
for key in old_std: |
|
| 1806 |
self.assertTrue(key in new_std) |
|
| 1807 |
if key not in diff_std: |
|
| 1808 |
self.assertEqual(new_std[key], old_std[key]) |
|
| 1804 | 1809 |
|
| 1805 |
|
|
| 1806 |
def _TestSet(self, old_policy, isgroup): |
|
| 1807 |
diff_policy = {
|
|
| 1808 |
constants.IPOLICY_VCPU_RATIO: 3, |
|
| 1809 |
constants.IPOLICY_SPINDLE_RATIO: 1.9, |
|
| 1810 |
} |
|
| 1810 |
def _TestSet(self, old_policy, diff_policy, isgroup): |
|
| 1811 | 1811 |
new_policy = cmdlib._GetUpdatedIPolicy(old_policy, diff_policy, |
| 1812 | 1812 |
group_policy=isgroup) |
| 1813 | 1813 |
for key in diff_policy: |
| ... | ... | |
| 1819 | 1819 |
self.assertEqual(new_policy[key], old_policy[key]) |
| 1820 | 1820 |
|
| 1821 | 1821 |
def testSet(self): |
| 1822 |
self._TestSet(self._OLD_GROUP_POLICY, True) |
|
| 1822 |
diff_policy = {
|
|
| 1823 |
constants.IPOLICY_VCPU_RATIO: 3, |
|
| 1824 |
constants.IPOLICY_DTS: [constants.DT_FILE], |
|
| 1825 |
} |
|
| 1826 |
self._TestSet(self._OLD_GROUP_POLICY, diff_policy, True) |
|
| 1823 | 1827 |
self._TestSetSpecs(self._OLD_GROUP_POLICY, True) |
| 1824 |
self._TestSet(self._OLD_CLUSTER_POLICY, False) |
|
| 1828 |
self._TestSet({}, diff_policy, True)
|
|
| 1829 |
self._TestSetSpecs({}, True)
|
|
| 1830 |
self._TestSet(self._OLD_CLUSTER_POLICY, diff_policy, False) |
|
| 1825 | 1831 |
self._TestSetSpecs(self._OLD_CLUSTER_POLICY, False) |
| 1826 | 1832 |
|
| 1827 | 1833 |
def testUnset(self): |
| ... | ... | |
| 1838 | 1844 |
self.assertTrue(key in new_policy) |
| 1839 | 1845 |
self.assertEqual(new_policy[key], old_policy[key]) |
| 1840 | 1846 |
|
| 1847 |
self.assertRaises(errors.OpPrereqError, cmdlib._GetUpdatedIPolicy, |
|
| 1848 |
old_policy, diff_policy, group_policy=False) |
|
| 1849 |
|
|
| 1841 | 1850 |
def _TestInvalidKeys(self, old_policy, isgroup): |
| 1851 |
INVALID_KEY = "this_key_shouldnt_be_allowed" |
|
| 1842 | 1852 |
INVALID_DICT = {
|
| 1843 |
"this_key_shouldnt_be_allowed": 3,
|
|
| 1853 |
INVALID_KEY: 3,
|
|
| 1844 | 1854 |
} |
| 1845 | 1855 |
invalid_policy = INVALID_DICT |
| 1846 | 1856 |
self.assertRaises(errors.OpPrereqError, cmdlib._GetUpdatedIPolicy, |
| ... | ... | |
| 1848 | 1858 |
invalid_ispecs = {
|
| 1849 | 1859 |
constants.ISPECS_MINMAX: INVALID_DICT, |
| 1850 | 1860 |
} |
| 1851 |
self.assertRaises(errors.OpPrereqError, cmdlib._GetUpdatedIPolicy,
|
|
| 1861 |
self.assertRaises(errors.TypeEnforcementError, cmdlib._GetUpdatedIPolicy,
|
|
| 1852 | 1862 |
old_policy, invalid_ispecs, group_policy=isgroup) |
| 1853 |
for key in constants.ISPECS_MINMAX_KEYS: |
|
| 1854 |
invalid_ispec = {
|
|
| 1855 |
constants.ISPECS_MINMAX: {
|
|
| 1856 |
key: INVALID_DICT, |
|
| 1857 |
}, |
|
| 1863 |
if isgroup: |
|
| 1864 |
invalid_for_group = {
|
|
| 1865 |
constants.ISPECS_STD: constants.IPOLICY_DEFAULTS[constants.ISPECS_STD], |
|
| 1858 | 1866 |
} |
| 1867 |
self.assertRaises(errors.OpPrereqError, cmdlib._GetUpdatedIPolicy, |
|
| 1868 |
old_policy, invalid_for_group, group_policy=isgroup) |
|
| 1869 |
good_ispecs = self._OLD_CLUSTER_POLICY[constants.ISPECS_MINMAX] |
|
| 1870 |
invalid_ispecs = copy.deepcopy(good_ispecs) |
|
| 1871 |
invalid_policy = {
|
|
| 1872 |
constants.ISPECS_MINMAX: invalid_ispecs, |
|
| 1873 |
} |
|
| 1874 |
for key in constants.ISPECS_MINMAX_KEYS: |
|
| 1875 |
ispec = invalid_ispecs[key] |
|
| 1876 |
ispec[INVALID_KEY] = None |
|
| 1859 | 1877 |
self.assertRaises(errors.TypeEnforcementError, cmdlib._GetUpdatedIPolicy, |
| 1860 |
old_policy, invalid_ispec, group_policy=isgroup) |
|
| 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" |
|
| 1883 |
self.assertRaises(errors.TypeEnforcementError, |
|
| 1884 |
cmdlib._GetUpdatedIPolicy, |
|
| 1885 |
old_policy, invalid_policy, group_policy=isgroup) |
|
| 1886 |
ispec[par] = oldv |
|
| 1887 |
# This is to make sure that no two errors were present during the tests |
|
| 1888 |
cmdlib._GetUpdatedIPolicy(old_policy, invalid_policy, group_policy=isgroup) |
|
| 1861 | 1889 |
|
| 1862 | 1890 |
def testInvalidKeys(self): |
| 1863 | 1891 |
self._TestInvalidKeys(self._OLD_GROUP_POLICY, True) |
| 1864 | 1892 |
self._TestInvalidKeys(self._OLD_CLUSTER_POLICY, False) |
| 1865 | 1893 |
|
| 1894 |
def testInvalidValues(self): |
|
| 1895 |
for par in (constants.IPOLICY_PARAMETERS | |
|
| 1896 |
frozenset([constants.IPOLICY_DTS])): |
|
| 1897 |
bad_policy = {
|
|
| 1898 |
par: "invalid_value", |
|
| 1899 |
} |
|
| 1900 |
self.assertRaises(errors.OpPrereqError, cmdlib._GetUpdatedIPolicy, {},
|
|
| 1901 |
bad_policy, group_policy=True) |
|
| 1866 | 1902 |
|
| 1867 | 1903 |
if __name__ == "__main__": |
| 1868 | 1904 |
testutils.GanetiTestProgram() |
Also available in: Unified diff