Synnefo » snf-ganeti

#!/usr/bin/python

#

# Copyright (C) 2008, 2011, 2012, 2013 Google Inc.

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful, but

# WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

# General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

# 02110-1301, USA.

"""Script for unittesting the cmdlib module"""

import unittest

import operator

import itertools

import copy

from ganeti import constants

from ganeti import mcpu

from ganeti import cmdlib

from ganeti.cmdlib import cluster

from ganeti.cmdlib import instance

from ganeti.cmdlib import instance_storage

from ganeti.cmdlib import instance_utils

from ganeti.cmdlib import common

from ganeti.cmdlib import query

from ganeti import opcodes

from ganeti import errors

from ganeti import utils

from ganeti import luxi

from ganeti import ht

from ganeti import objects

from ganeti import compat

from ganeti import rpc

from ganeti import locking

from ganeti.masterd import iallocator

import testutils

import mocks

class TestOpcodeParams(testutils.GanetiTestCase):

  def testParamsStructures(self):

    for op in sorted(mcpu.Processor.DISPATCH_TABLE):

      lu = mcpu.Processor.DISPATCH_TABLE[op]

      lu_name = lu.__name__

      self.failIf(hasattr(lu, "_OP_REQP"),

                  msg=("LU '%s' has old-style _OP_REQP" % lu_name))

      self.failIf(hasattr(lu, "_OP_DEFS"),

                  msg=("LU '%s' has old-style _OP_DEFS" % lu_name))

      self.failIf(hasattr(lu, "_OP_PARAMS"),

                  msg=("LU '%s' has old-style _OP_PARAMS" % lu_name))

class TestIAllocatorChecks(testutils.GanetiTestCase):

  def testFunction(self):

    class TestLU(object):

      def __init__(self, opcode):

        self.cfg = mocks.FakeConfig()

        self.op = opcode

    class OpTest(opcodes.OpCode):

       OP_PARAMS = [

        ("iallocator", None, ht.TAny, None),

        ("node", None, ht.TAny, None),

        ]

    default_iallocator = mocks.FakeConfig().GetDefaultIAllocator()

    other_iallocator = default_iallocator + "_not"

    op = OpTest()

    lu = TestLU(op)

    c_i = lambda: common.CheckIAllocatorOrNode(lu, "iallocator", "node")

    # Neither node nor iallocator given

    for n in (None, []):

      op.iallocator = None

      op.node = n

      c_i()

      self.assertEqual(lu.op.iallocator, default_iallocator)

      self.assertEqual(lu.op.node, n)

    # Both, iallocator and node given

    for a in ("test", constants.DEFAULT_IALLOCATOR_SHORTCUT):

      op.iallocator = a

      op.node = "test"

      self.assertRaises(errors.OpPrereqError, c_i)

    # Only iallocator given

    for n in (None, []):

      op.iallocator = other_iallocator

      op.node = n

      c_i()

      self.assertEqual(lu.op.iallocator, other_iallocator)

      self.assertEqual(lu.op.node, n)

    # Only node given

    op.iallocator = None

    op.node = "node"

    c_i()

    self.assertEqual(lu.op.iallocator, None)

    self.assertEqual(lu.op.node, "node")

    # Asked for default iallocator, no node given

    op.iallocator = constants.DEFAULT_IALLOCATOR_SHORTCUT

    op.node = None

    c_i()

    self.assertEqual(lu.op.iallocator, default_iallocator)

    self.assertEqual(lu.op.node, None)

    # No node, iallocator or default iallocator

    op.iallocator = None

    op.node = None

    lu.cfg.GetDefaultIAllocator = lambda: None

    self.assertRaises(errors.OpPrereqError, c_i)

class TestLUTestJqueue(unittest.TestCase):

  def test(self):

    self.assert_(cmdlib.LUTestJqueue._CLIENT_CONNECT_TIMEOUT <

                 (luxi.WFJC_TIMEOUT * 0.75),

                 msg=("Client timeout too high, might not notice bugs"

                      " in WaitForJobChange"))

class TestLUQuery(unittest.TestCase):

  def test(self):

    self.assertEqual(sorted(query._QUERY_IMPL.keys()),

                     sorted(constants.QR_VIA_OP))

    assert constants.QR_NODE in constants.QR_VIA_OP

    assert constants.QR_INSTANCE in constants.QR_VIA_OP

    for i in constants.QR_VIA_OP:

      self.assert_(query._GetQueryImplementation(i))

    self.assertRaises(errors.OpPrereqError, query._GetQueryImplementation,

                      "")

    self.assertRaises(errors.OpPrereqError, query._GetQueryImplementation,

                      "xyz")

class _FakeLU:

  def __init__(self, cfg=NotImplemented, proc=NotImplemented,

               rpc=NotImplemented):

    self.warning_log = []

    self.info_log = []

    self.cfg = cfg

    self.proc = proc

    self.rpc = rpc

  def LogWarning(self, text, *args):

    self.warning_log.append((text, args))

  def LogInfo(self, text, *args):

    self.info_log.append((text, args))

class TestLoadNodeEvacResult(unittest.TestCase):

  def testSuccess(self):

    for moved in [[], [

      ("inst20153.example.com", "grp2", ["nodeA4509", "nodeB2912"]),

      ]]:

      for early_release in [False, True]:

        for use_nodes in [False, True]:

          jobs = [

            [opcodes.OpInstanceReplaceDisks().__getstate__()],

            [opcodes.OpInstanceMigrate().__getstate__()],

            ]

          alloc_result = (moved, [], jobs)

          assert iallocator._NEVAC_RESULT(alloc_result)

          lu = _FakeLU()

          result = common.LoadNodeEvacResult(lu, alloc_result,

                                             early_release, use_nodes)

          if moved:

            (_, (info_args, )) = lu.info_log.pop(0)

            for (instname, instgroup, instnodes) in moved:

              self.assertTrue(instname in info_args)

              if use_nodes:

                for i in instnodes:

                  self.assertTrue(i in info_args)

              else:

                self.assertTrue(instgroup in info_args)

          self.assertFalse(lu.info_log)

          self.assertFalse(lu.warning_log)

          for op in itertools.chain(*result):

            if hasattr(op.__class__, "early_release"):

              self.assertEqual(op.early_release, early_release)

            else:

              self.assertFalse(hasattr(op, "early_release"))

  def testFailed(self):

    alloc_result = ([], [

      ("inst5191.example.com", "errormsg21178"),

      ], [])

    assert iallocator._NEVAC_RESULT(alloc_result)

    lu = _FakeLU()

    self.assertRaises(errors.OpExecError, common.LoadNodeEvacResult,

                      lu, alloc_result, False, False)

    self.assertFalse(lu.info_log)

    (_, (args, )) = lu.warning_log.pop(0)

    self.assertTrue("inst5191.example.com" in args)

    self.assertTrue("errormsg21178" in args)

    self.assertFalse(lu.warning_log)

class TestUpdateAndVerifySubDict(unittest.TestCase):

  def setUp(self):

    self.type_check = {

        "a": constants.VTYPE_INT,

        "b": constants.VTYPE_STRING,

        "c": constants.VTYPE_BOOL,

        "d": constants.VTYPE_STRING,

        }

  def test(self):

    old_test = {

      "foo": {

        "d": "blubb",

        "a": 321,

        },

      "baz": {

        "a": 678,

        "b": "678",

        "c": True,

        },

      }

    test = {

      "foo": {

        "a": 123,

        "b": "123",

        "c": True,

        },

      "bar": {

        "a": 321,

        "b": "321",

        "c": False,

        },

      }

    mv = {

      "foo": {

        "a": 123,

        "b": "123",

        "c": True,

        "d": "blubb"

        },

      "bar": {

        "a": 321,

        "b": "321",

        "c": False,

        },

      "baz": {

        "a": 678,

        "b": "678",

        "c": True,

        },

      }

    verified = common._UpdateAndVerifySubDict(old_test, test, self.type_check)

    self.assertEqual(verified, mv)

  def testWrong(self):

    test = {

      "foo": {

        "a": "blubb",

        "b": "123",

        "c": True,

        },

      "bar": {

        "a": 321,

        "b": "321",

        "c": False,

        },

      }

    self.assertRaises(errors.TypeEnforcementError,

                      common._UpdateAndVerifySubDict, {}, test,

                      self.type_check)

class TestHvStateHelper(unittest.TestCase):

  def testWithoutOpData(self):

    self.assertEqual(common.MergeAndVerifyHvState(None, NotImplemented),

                     None)

  def testWithoutOldData(self):

    new = {

      constants.HT_XEN_PVM: {

        constants.HVST_MEMORY_TOTAL: 4096,

        },

      }

    self.assertEqual(common.MergeAndVerifyHvState(new, None), new)

  def testWithWrongHv(self):

    new = {

      "i-dont-exist": {

        constants.HVST_MEMORY_TOTAL: 4096,

        },

      }

    self.assertRaises(errors.OpPrereqError, common.MergeAndVerifyHvState,

                      new, None)

class TestDiskStateHelper(unittest.TestCase):

  def testWithoutOpData(self):

    self.assertEqual(common.MergeAndVerifyDiskState(None, NotImplemented),

                     None)

  def testWithoutOldData(self):

    new = {

      constants.DT_PLAIN: {

        "xenvg": {

          constants.DS_DISK_RESERVED: 1024,

          },

        },

      }

    self.assertEqual(common.MergeAndVerifyDiskState(new, None), new)

  def testWithWrongStorageType(self):

    new = {

      "i-dont-exist": {

        "xenvg": {

          constants.DS_DISK_RESERVED: 1024,

          },

        },

      }

    self.assertRaises(errors.OpPrereqError, common.MergeAndVerifyDiskState,

                      new, None)

class TestComputeMinMaxSpec(unittest.TestCase):

  def setUp(self):

    self.ispecs = {

      constants.ISPECS_MAX: {

        constants.ISPEC_MEM_SIZE: 512,

        constants.ISPEC_DISK_SIZE: 1024,

        },

      constants.ISPECS_MIN: {

        constants.ISPEC_MEM_SIZE: 128,

        constants.ISPEC_DISK_COUNT: 1,

        },

      }

  def testNoneValue(self):

    self.assertTrue(common._ComputeMinMaxSpec(constants.ISPEC_MEM_SIZE, None,

                                              self.ispecs, None) is None)

  def testAutoValue(self):

    self.assertTrue(common._ComputeMinMaxSpec(constants.ISPEC_MEM_SIZE, None,

                                              self.ispecs,

                                              constants.VALUE_AUTO) is None)

  def testNotDefined(self):

    self.assertTrue(common._ComputeMinMaxSpec(constants.ISPEC_NIC_COUNT, None,

                                              self.ispecs, 3) is None)

  def testNoMinDefined(self):

    self.assertTrue(common._ComputeMinMaxSpec(constants.ISPEC_DISK_SIZE, None,

                                              self.ispecs, 128) is None)

  def testNoMaxDefined(self):

    self.assertTrue(common._ComputeMinMaxSpec(constants.ISPEC_DISK_COUNT,

                                              None, self.ispecs, 16) is None)

  def testOutOfRange(self):

    for (name, val) in ((constants.ISPEC_MEM_SIZE, 64),

                        (constants.ISPEC_MEM_SIZE, 768),

                        (constants.ISPEC_DISK_SIZE, 4096),

                        (constants.ISPEC_DISK_COUNT, 0)):

      min_v = self.ispecs[constants.ISPECS_MIN].get(name, val)

      max_v = self.ispecs[constants.ISPECS_MAX].get(name, val)

      self.assertEqual(common._ComputeMinMaxSpec(name, None,

                                                 self.ispecs, val),

                       "%s value %s is not in range [%s, %s]" %

                       (name, val,min_v, max_v))

      self.assertEqual(common._ComputeMinMaxSpec(name, "1",

                                                 self.ispecs, val),

                       "%s/1 value %s is not in range [%s, %s]" %

                       (name, val,min_v, max_v))

  def test(self):

    for (name, val) in ((constants.ISPEC_MEM_SIZE, 256),

                        (constants.ISPEC_MEM_SIZE, 128),

                        (constants.ISPEC_MEM_SIZE, 512),

                        (constants.ISPEC_DISK_SIZE, 1024),

                        (constants.ISPEC_DISK_SIZE, 0),

                        (constants.ISPEC_DISK_COUNT, 1),

                        (constants.ISPEC_DISK_COUNT, 5)):

      self.assertTrue(common._ComputeMinMaxSpec(name, None, self.ispecs, val)

                      is None)

def _ValidateComputeMinMaxSpec(name, *_):

  assert name in constants.ISPECS_PARAMETERS

  return None

def _NoDiskComputeMinMaxSpec(name, *_):

  if name == constants.ISPEC_DISK_COUNT:

    return name

  else:

    return None

class _SpecWrapper:

  def __init__(self, spec):

    self.spec = spec

  def ComputeMinMaxSpec(self, *args):

    return self.spec.pop(0)

class TestComputeIPolicySpecViolation(unittest.TestCase):

  # Minimal policy accepted by _ComputeIPolicySpecViolation()

  _MICRO_IPOL = {

    constants.IPOLICY_DTS: [constants.DT_PLAIN, constants.DT_DISKLESS],

    constants.ISPECS_MINMAX: [NotImplemented],

    }

  def test(self):

    compute_fn = _ValidateComputeMinMaxSpec

    ret = common.ComputeIPolicySpecViolation(self._MICRO_IPOL, 1024, 1, 1, 1,

                                             [1024], 1, constants.DT_PLAIN,

                                             _compute_fn=compute_fn)

    self.assertEqual(ret, [])

  def testDiskFull(self):

    compute_fn = _NoDiskComputeMinMaxSpec

    ret = common.ComputeIPolicySpecViolation(self._MICRO_IPOL, 1024, 1, 1, 1,

                                             [1024], 1, constants.DT_PLAIN,

                                             _compute_fn=compute_fn)

    self.assertEqual(ret, [constants.ISPEC_DISK_COUNT])

  def testDiskLess(self):

    compute_fn = _NoDiskComputeMinMaxSpec

    ret = common.ComputeIPolicySpecViolation(self._MICRO_IPOL, 1024, 1, 1, 1,

                                             [1024], 1, constants.DT_DISKLESS,

                                             _compute_fn=compute_fn)

    self.assertEqual(ret, [])

  def testWrongTemplates(self):

    compute_fn = _ValidateComputeMinMaxSpec

    ret = common.ComputeIPolicySpecViolation(self._MICRO_IPOL, 1024, 1, 1, 1,

                                             [1024], 1, constants.DT_DRBD8,

                                             _compute_fn=compute_fn)

    self.assertEqual(len(ret), 1)

    self.assertTrue("Disk template" in ret[0])

  def testInvalidArguments(self):

    self.assertRaises(AssertionError, common.ComputeIPolicySpecViolation,

                      self._MICRO_IPOL, 1024, 1, 1, 1, [], 1,

                      constants.DT_PLAIN,)

  def testInvalidSpec(self):

    spec = _SpecWrapper([None, False, "foo", None, "bar", None])

    compute_fn = spec.ComputeMinMaxSpec

    ret = common.ComputeIPolicySpecViolation(self._MICRO_IPOL, 1024, 1, 1, 1,

                                             [1024], 1, constants.DT_PLAIN,

                                             _compute_fn=compute_fn)

    self.assertEqual(ret, ["foo", "bar"])

    self.assertFalse(spec.spec)

  def testWithIPolicy(self):

    mem_size = 2048

    cpu_count = 2

    disk_count = 1

    disk_sizes = [512]

    nic_count = 1

    spindle_use = 4

    disk_template = "mytemplate"

    ispec = {

      constants.ISPEC_MEM_SIZE: mem_size,

      constants.ISPEC_CPU_COUNT: cpu_count,

      constants.ISPEC_DISK_COUNT: disk_count,

      constants.ISPEC_DISK_SIZE: disk_sizes[0],

      constants.ISPEC_NIC_COUNT: nic_count,

      constants.ISPEC_SPINDLE_USE: spindle_use,

      }

    ipolicy1 = {

      constants.ISPECS_MINMAX: [{

        constants.ISPECS_MIN: ispec,

        constants.ISPECS_MAX: ispec,

        }],

      constants.IPOLICY_DTS: [disk_template],

      }

    ispec_copy = copy.deepcopy(ispec)

    ipolicy2 = {

      constants.ISPECS_MINMAX: [

        {

          constants.ISPECS_MIN: ispec_copy,

          constants.ISPECS_MAX: ispec_copy,

          },

        {

          constants.ISPECS_MIN: ispec,

          constants.ISPECS_MAX: ispec,

          },

        ],

      constants.IPOLICY_DTS: [disk_template],

      }

    ipolicy3 = {

      constants.ISPECS_MINMAX: [

        {

          constants.ISPECS_MIN: ispec,

          constants.ISPECS_MAX: ispec,

          },

        {

          constants.ISPECS_MIN: ispec_copy,

          constants.ISPECS_MAX: ispec_copy,

          },

        ],

      constants.IPOLICY_DTS: [disk_template],

      }

    def AssertComputeViolation(ipolicy, violations):

      ret = common.ComputeIPolicySpecViolation(ipolicy, mem_size, cpu_count,

                                               disk_count, nic_count,

                                               disk_sizes, spindle_use,

                                               disk_template)

      self.assertEqual(len(ret), violations)

    AssertComputeViolation(ipolicy1, 0)

    AssertComputeViolation(ipolicy2, 0)

    AssertComputeViolation(ipolicy3, 0)

    for par in constants.ISPECS_PARAMETERS:

      ispec[par] += 1

      AssertComputeViolation(ipolicy1, 1)

      AssertComputeViolation(ipolicy2, 0)

      AssertComputeViolation(ipolicy3, 0)

      ispec[par] -= 2

      AssertComputeViolation(ipolicy1, 1)

      AssertComputeViolation(ipolicy2, 0)

      AssertComputeViolation(ipolicy3, 0)

      ispec[par] += 1 # Restore

    ipolicy1[constants.IPOLICY_DTS] = ["another_template"]

    AssertComputeViolation(ipolicy1, 1)

class _StubComputeIPolicySpecViolation:

  def __init__(self, mem_size, cpu_count, disk_count, nic_count, disk_sizes,

               spindle_use, disk_template):

    self.mem_size = mem_size

    self.cpu_count = cpu_count

    self.disk_count = disk_count

    self.nic_count = nic_count

    self.disk_sizes = disk_sizes

    self.spindle_use = spindle_use

    self.disk_template = disk_template

  def __call__(self, _, mem_size, cpu_count, disk_count, nic_count, disk_sizes,

               spindle_use, disk_template):

    assert self.mem_size == mem_size

    assert self.cpu_count == cpu_count

    assert self.disk_count == disk_count

    assert self.nic_count == nic_count

    assert self.disk_sizes == disk_sizes

    assert self.spindle_use == spindle_use

    assert self.disk_template == disk_template

    return []

class _FakeConfigForComputeIPolicyInstanceViolation:

  def __init__(self, be, excl_stor):

    self.cluster = objects.Cluster(beparams={"default": be})

    self.excl_stor = excl_stor

  def GetClusterInfo(self):

    return self.cluster

  def GetNodeInfo(self, _):

    return {}

  def GetNdParams(self, _):

    return {

      constants.ND_EXCLUSIVE_STORAGE: self.excl_stor,

      }

class TestComputeIPolicyInstanceViolation(unittest.TestCase):

  def test(self):

    beparams = {

      constants.BE_MAXMEM: 2048,

      constants.BE_VCPUS: 2,

      constants.BE_SPINDLE_USE: 4,

      }

    disks = [objects.Disk(size=512, spindles=13)]

    cfg = _FakeConfigForComputeIPolicyInstanceViolation(beparams, False)

    instance = objects.Instance(beparams=beparams, disks=disks, nics=[],

                                disk_template=constants.DT_PLAIN)

    stub = _StubComputeIPolicySpecViolation(2048, 2, 1, 0, [512], 4,

                                            constants.DT_PLAIN)

    ret = common.ComputeIPolicyInstanceViolation(NotImplemented, instance,

                                                 cfg, _compute_fn=stub)

    self.assertEqual(ret, [])

    instance2 = objects.Instance(beparams={}, disks=disks, nics=[],

                                 disk_template=constants.DT_PLAIN)

    ret = common.ComputeIPolicyInstanceViolation(NotImplemented, instance2,

                                                 cfg, _compute_fn=stub)

    self.assertEqual(ret, [])

    cfg_es = _FakeConfigForComputeIPolicyInstanceViolation(beparams, True)

    stub_es = _StubComputeIPolicySpecViolation(2048, 2, 1, 0, [512], 13,

                                               constants.DT_PLAIN)

    ret = common.ComputeIPolicyInstanceViolation(NotImplemented, instance,

                                                 cfg_es, _compute_fn=stub_es)

    self.assertEqual(ret, [])

    ret = common.ComputeIPolicyInstanceViolation(NotImplemented, instance2,

                                                 cfg_es, _compute_fn=stub_es)

    self.assertEqual(ret, [])

class _CallRecorder:

  def __init__(self, return_value=None):

    self.called = False

    self.return_value = return_value

  def __call__(self, *args):

    self.called = True

    return self.return_value

class TestComputeIPolicyNodeViolation(unittest.TestCase):

  def setUp(self):

    self.recorder = _CallRecorder(return_value=[])

  def testSameGroup(self):

    ret = instance_utils._ComputeIPolicyNodeViolation(

      NotImplemented,

      NotImplemented,

      "foo", "foo", NotImplemented,

      _compute_fn=self.recorder)

    self.assertFalse(self.recorder.called)

    self.assertEqual(ret, [])

  def testDifferentGroup(self):

    ret = instance_utils._ComputeIPolicyNodeViolation(

      NotImplemented,

      NotImplemented,

      "foo", "bar", NotImplemented,

      _compute_fn=self.recorder)

    self.assertTrue(self.recorder.called)

    self.assertEqual(ret, [])

class TestDiskSizeInBytesToMebibytes(unittest.TestCase):

  def testLessThanOneMebibyte(self):

    for i in [1, 2, 7, 512, 1000, 1023]:

      lu = _FakeLU()

      result = instance_storage._DiskSizeInBytesToMebibytes(lu, i)

      self.assertEqual(result, 1)

      self.assertEqual(len(lu.warning_log), 1)

      self.assertEqual(len(lu.warning_log[0]), 2)

      (_, (warnsize, )) = lu.warning_log[0]

      self.assertEqual(warnsize, (1024 * 1024) - i)

  def testEven(self):

    for i in [1, 2, 7, 512, 1000, 1023]:

      lu = _FakeLU()

      result = instance_storage._DiskSizeInBytesToMebibytes(lu,

                                                            i * 1024 * 1024)

      self.assertEqual(result, i)

      self.assertFalse(lu.warning_log)

  def testLargeNumber(self):

    for i in [1, 2, 7, 512, 1000, 1023, 2724, 12420]:

      for j in [1, 2, 486, 326, 986, 1023]:

        lu = _FakeLU()

        size = (1024 * 1024 * i) + j

        result = instance_storage._DiskSizeInBytesToMebibytes(lu, size)

        self.assertEqual(result, i + 1, msg="Amount was not rounded up")

        self.assertEqual(len(lu.warning_log), 1)

        self.assertEqual(len(lu.warning_log[0]), 2)

        (_, (warnsize, )) = lu.warning_log[0]

        self.assertEqual(warnsize, (1024 * 1024) - j)

class _OpTestVerifyErrors(opcodes.OpCode):

  OP_PARAMS = [

    ("debug_simulate_errors", False, ht.TBool, ""),

    ("error_codes", False, ht.TBool, ""),

    ("ignore_errors",

     [],

     ht.TListOf(ht.TElemOf(constants.CV_ALL_ECODES_STRINGS)),

     "")

    ]

class _LuTestVerifyErrors(cluster._VerifyErrors):

  def __init__(self, **kwargs):

    cluster._VerifyErrors.__init__(self)

    self.op = _OpTestVerifyErrors(**kwargs)

    self.op.Validate(True)

    self.msglist = []

    self._feedback_fn = self.msglist.append

    self.bad = False

  def DispatchCallError(self, which, *args, **kwargs):

    if which:

      self._Error(*args, **kwargs)

    else:

      self._ErrorIf(True, *args, **kwargs)

  def CallErrorIf(self, c, *args, **kwargs):

    self._ErrorIf(c, *args, **kwargs)

class TestVerifyErrors(unittest.TestCase):

  # Fake cluster-verify error code structures; we use two arbitary real error

  # codes to pass validation of ignore_errors

  (_, _ERR1ID, _) = constants.CV_ECLUSTERCFG

  _NODESTR = "node"

  _NODENAME = "mynode"

  _ERR1CODE = (_NODESTR, _ERR1ID, "Error one")

  (_, _ERR2ID, _) = constants.CV_ECLUSTERCERT

  _INSTSTR = "instance"

  _INSTNAME = "myinstance"

  _ERR2CODE = (_INSTSTR, _ERR2ID, "Error two")

  # Arguments used to call _Error() or _ErrorIf()

  _ERR1ARGS = (_ERR1CODE, _NODENAME, "Error1 is %s", "an error")

  _ERR2ARGS = (_ERR2CODE, _INSTNAME, "Error2 has no argument")

  # Expected error messages

  _ERR1MSG = _ERR1ARGS[2] % _ERR1ARGS[3]

  _ERR2MSG = _ERR2ARGS[2]

  def testNoError(self):

    lu = _LuTestVerifyErrors()

    lu.CallErrorIf(False, self._ERR1CODE, *self._ERR1ARGS)

    self.assertFalse(lu.bad)

    self.assertFalse(lu.msglist)

  def _InitTest(self, **kwargs):

    self.lu1 = _LuTestVerifyErrors(**kwargs)

    self.lu2 = _LuTestVerifyErrors(**kwargs)

  def _CallError(self, *args, **kwargs):

    # Check that _Error() and _ErrorIf() produce the same results

    self.lu1.DispatchCallError(True, *args, **kwargs)

    self.lu2.DispatchCallError(False, *args, **kwargs)

    self.assertEqual(self.lu1.bad, self.lu2.bad)

    self.assertEqual(self.lu1.msglist, self.lu2.msglist)

    # Test-specific checks are made on one LU

    return self.lu1

  def _checkMsgCommon(self, logstr, errmsg, itype, item, warning):

    self.assertTrue(errmsg in logstr)

    if warning:

      self.assertTrue("WARNING" in logstr)

    else:

      self.assertTrue("ERROR" in logstr)

    self.assertTrue(itype in logstr)

    self.assertTrue(item in logstr)

  def _checkMsg1(self, logstr, warning=False):

    self._checkMsgCommon(logstr, self._ERR1MSG, self._NODESTR,

                         self._NODENAME, warning)

  def _checkMsg2(self, logstr, warning=False):

    self._checkMsgCommon(logstr, self._ERR2MSG, self._INSTSTR,

                         self._INSTNAME, warning)

  def testPlain(self):

    self._InitTest()

    lu = self._CallError(*self._ERR1ARGS)

    self.assertTrue(lu.bad)

    self.assertEqual(len(lu.msglist), 1)

    self._checkMsg1(lu.msglist[0])

  def testMultiple(self):

    self._InitTest()

    self._CallError(*self._ERR1ARGS)

    lu = self._CallError(*self._ERR2ARGS)

    self.assertTrue(lu.bad)

    self.assertEqual(len(lu.msglist), 2)

    self._checkMsg1(lu.msglist[0])

    self._checkMsg2(lu.msglist[1])