Synnefo » snf-ganeti » ganeti-local

#!/usr/bin/python

#

# Copyright (C) 2010, 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 RAPI rlib2 module

"""

import unittest

import itertools

import random

from ganeti import constants

from ganeti import opcodes

from ganeti import compat

from ganeti import http

from ganeti import query

from ganeti import luxi

from ganeti import errors

from ganeti import rapi

from ganeti.rapi import rlib2

from ganeti.rapi import baserlib

from ganeti.rapi import connector

import testutils

class _FakeRequestPrivateData:

  def __init__(self, body_data):

    self.body_data = body_data

class _FakeRequest:

  def __init__(self, body_data):

    self.private = _FakeRequestPrivateData(body_data)

def _CreateHandler(cls, items, queryargs, body_data, client_cls):

  return cls(items, queryargs, _FakeRequest(body_data),

             _client_cls=client_cls)

class _FakeClient:

  def __init__(self, address=None):

    self._jobs = []

  def GetNextSubmittedJob(self):

    return self._jobs.pop(0)

  def SubmitJob(self, ops):

    job_id = str(1 + int(random.random() * 1000000))

    self._jobs.append((job_id, ops))

    return job_id

class _FakeClientFactory:

  def __init__(self, cls):

    self._client_cls = cls

    self._clients = []

  def GetNextClient(self):

    return self._clients.pop(0)

  def __call__(self, address=None):

    cl = self._client_cls(address=address)

    self._clients.append(cl)

    return cl

class TestConstants(unittest.TestCase):

  def testConsole(self):

    # Exporting the console field without authentication might expose

    # information

    assert "console" in query.INSTANCE_FIELDS

    self.assertTrue("console" not in rlib2.I_FIELDS)

  def testFields(self):

    checks = {

      constants.QR_INSTANCE: rlib2.I_FIELDS,

      constants.QR_NODE: rlib2.N_FIELDS,

      constants.QR_GROUP: rlib2.G_FIELDS,

      }

    for (qr, fields) in checks.items():

      self.assertFalse(set(fields) - set(query.ALL_FIELDS[qr].keys()))

class TestClientConnectError(unittest.TestCase):

  @staticmethod

  def _FailingClient(address=None):

    raise luxi.NoMasterError("test")

  def test(self):

    resources = [

      rlib2.R_2_groups,

      rlib2.R_2_instances,

      rlib2.R_2_nodes,

      ]

    for cls in resources:

      handler = _CreateHandler(cls, ["name"], {}, None, self._FailingClient)

      self.assertRaises(http.HttpBadGateway, handler.GET)

class TestJobSubmitError(unittest.TestCase):

  class _SubmitErrorClient:

    def __init__(self, address=None):

      pass

    @staticmethod

    def SubmitJob(ops):

      raise errors.JobQueueFull("test")

  def test(self):

    handler = _CreateHandler(rlib2.R_2_redist_config, [], {}, None,

                             self._SubmitErrorClient)

    self.assertRaises(http.HttpServiceUnavailable, handler.PUT)

class TestClusterModify(unittest.TestCase):

  def test(self):

    clfactory = _FakeClientFactory(_FakeClient)

    handler = _CreateHandler(rlib2.R_2_cluster_modify, [], {}, {

      "vg_name": "testvg",

      "candidate_pool_size": 100,

      }, clfactory)

    job_id = handler.PUT()

    cl = clfactory.GetNextClient()

    self.assertRaises(IndexError, clfactory.GetNextClient)

    (exp_job_id, (op, )) = cl.GetNextSubmittedJob()

    self.assertEqual(job_id, exp_job_id)

    self.assertTrue(isinstance(op, opcodes.OpClusterSetParams))

    self.assertEqual(op.vg_name, "testvg")

    self.assertEqual(op.candidate_pool_size, 100)

    self.assertRaises(IndexError, cl.GetNextSubmittedJob)

  def testInvalidValue(self):

    for attr in ["vg_name", "candidate_pool_size", "beparams", "_-Unknown#"]:

      clfactory = _FakeClientFactory(_FakeClient)

      handler = _CreateHandler(rlib2.R_2_cluster_modify, [], {}, {

        attr: True,

        }, clfactory)

      self.assertRaises(http.HttpBadRequest, handler.PUT)

      self.assertRaises(IndexError, clfactory.GetNextClient)

class TestRedistConfig(unittest.TestCase):

  def test(self):

    clfactory = _FakeClientFactory(_FakeClient)

    handler = _CreateHandler(rlib2.R_2_redist_config, [], {}, None, clfactory)

    job_id = handler.PUT()

    cl = clfactory.GetNextClient()

    self.assertRaises(IndexError, clfactory.GetNextClient)

    (exp_job_id, (op, )) = cl.GetNextSubmittedJob()

    self.assertEqual(job_id, exp_job_id)

    self.assertTrue(isinstance(op, opcodes.OpClusterRedistConf))

    self.assertRaises(IndexError, cl.GetNextSubmittedJob)

class TestNodeMigrate(unittest.TestCase):

  def test(self):

    clfactory = _FakeClientFactory(_FakeClient)

    handler = _CreateHandler(rlib2.R_2_nodes_name_migrate, ["node1"], {}, {

      "iallocator": "fooalloc",

      }, clfactory)

    job_id = handler.POST()

    cl = clfactory.GetNextClient()

    self.assertRaises(IndexError, clfactory.GetNextClient)

    (exp_job_id, (op, )) = cl.GetNextSubmittedJob()

    self.assertEqual(job_id, exp_job_id)

    self.assertTrue(isinstance(op, opcodes.OpNodeMigrate))

    self.assertEqual(op.node_name, "node1")

    self.assertEqual(op.iallocator, "fooalloc")

    self.assertRaises(IndexError, cl.GetNextSubmittedJob)

  def testQueryArgsConflict(self):

    clfactory = _FakeClientFactory(_FakeClient)

    handler = _CreateHandler(rlib2.R_2_nodes_name_migrate, ["node2"], {

      "live": True,

      "mode": constants.HT_MIGRATION_NONLIVE,

      }, None, clfactory)

    self.assertRaises(http.HttpBadRequest, handler.POST)

    self.assertRaises(IndexError, clfactory.GetNextClient)

  def testQueryArgsMode(self):

    clfactory = _FakeClientFactory(_FakeClient)

    queryargs = {

      "mode": [constants.HT_MIGRATION_LIVE],

      }

    handler = _CreateHandler(rlib2.R_2_nodes_name_migrate, ["node17292"],

                             queryargs, None, clfactory)

    job_id = handler.POST()

    cl = clfactory.GetNextClient()

    self.assertRaises(IndexError, clfactory.GetNextClient)

    (exp_job_id, (op, )) = cl.GetNextSubmittedJob()

    self.assertEqual(job_id, exp_job_id)

    self.assertTrue(isinstance(op, opcodes.OpNodeMigrate))

    self.assertEqual(op.node_name, "node17292")

    self.assertEqual(op.mode, constants.HT_MIGRATION_LIVE)

    self.assertRaises(IndexError, cl.GetNextSubmittedJob)

  def testQueryArgsLive(self):

    clfactory = _FakeClientFactory(_FakeClient)

    for live in [False, True]:

      queryargs = {

        "live": [str(int(live))],

        }

      handler = _CreateHandler(rlib2.R_2_nodes_name_migrate, ["node6940"],

                               queryargs, None, clfactory)

      job_id = handler.POST()

      cl = clfactory.GetNextClient()

      self.assertRaises(IndexError, clfactory.GetNextClient)

      (exp_job_id, (op, )) = cl.GetNextSubmittedJob()

      self.assertEqual(job_id, exp_job_id)

      self.assertTrue(isinstance(op, opcodes.OpNodeMigrate))

      self.assertEqual(op.node_name, "node6940")

      if live:

        self.assertEqual(op.mode, constants.HT_MIGRATION_LIVE)

      else:

        self.assertEqual(op.mode, constants.HT_MIGRATION_NONLIVE)

      self.assertRaises(IndexError, cl.GetNextSubmittedJob)

class TestNodeEvacuate(unittest.TestCase):

  def test(self):

    clfactory = _FakeClientFactory(_FakeClient)

    handler = _CreateHandler(rlib2.R_2_nodes_name_evacuate, ["node92"], {

      "dry-run": ["1"],

      }, {

      "mode": constants.IALLOCATOR_NEVAC_SEC,

      }, clfactory)

    job_id = handler.POST()

    cl = clfactory.GetNextClient()

    self.assertRaises(IndexError, clfactory.GetNextClient)

    (exp_job_id, (op, )) = cl.GetNextSubmittedJob()

    self.assertEqual(job_id, exp_job_id)

    self.assertTrue(isinstance(op, opcodes.OpNodeEvacuate))

    self.assertEqual(op.node_name, "node92")

    self.assertEqual(op.mode, constants.IALLOCATOR_NEVAC_SEC)

    self.assertTrue(op.dry_run)

    self.assertRaises(IndexError, cl.GetNextSubmittedJob)

class TestNodePowercycle(unittest.TestCase):

  def test(self):

    clfactory = _FakeClientFactory(_FakeClient)

    handler = _CreateHandler(rlib2.R_2_nodes_name_powercycle, ["node20744"], {

      "force": ["1"],

      }, None, clfactory)

    job_id = handler.POST()

    cl = clfactory.GetNextClient()

    self.assertRaises(IndexError, clfactory.GetNextClient)

    (exp_job_id, (op, )) = cl.GetNextSubmittedJob()

    self.assertEqual(job_id, exp_job_id)

    self.assertTrue(isinstance(op, opcodes.OpNodePowercycle))

    self.assertEqual(op.node_name, "node20744")

    self.assertTrue(op.force)

    self.assertRaises(IndexError, cl.GetNextSubmittedJob)

class TestGroupAssignNodes(unittest.TestCase):

  def test(self):

    clfactory = _FakeClientFactory(_FakeClient)

    handler = _CreateHandler(rlib2.R_2_groups_name_assign_nodes, ["grp-a"], {

      "dry-run": ["1"],

      "force": ["1"],

      }, {

      "nodes": ["n2", "n3"],

      }, clfactory)

    job_id = handler.PUT()

    cl = clfactory.GetNextClient()

    self.assertRaises(IndexError, clfactory.GetNextClient)

    (exp_job_id, (op, )) = cl.GetNextSubmittedJob()

    self.assertEqual(job_id, exp_job_id)

    self.assertTrue(isinstance(op, opcodes.OpGroupAssignNodes))

    self.assertEqual(op.group_name, "grp-a")

    self.assertEqual(op.nodes, ["n2", "n3"])

    self.assertTrue(op.dry_run)

    self.assertTrue(op.force)

    self.assertRaises(IndexError, cl.GetNextSubmittedJob)

class TestInstanceDelete(unittest.TestCase):

  def test(self):

    clfactory = _FakeClientFactory(_FakeClient)

    handler = _CreateHandler(rlib2.R_2_instances_name, ["inst30965"], {

      "dry-run": ["1"],

      }, {}, clfactory)

    job_id = handler.DELETE()

    cl = clfactory.GetNextClient()

    self.assertRaises(IndexError, clfactory.GetNextClient)

    (exp_job_id, (op, )) = cl.GetNextSubmittedJob()

    self.assertEqual(job_id, exp_job_id)

    self.assertTrue(isinstance(op, opcodes.OpInstanceRemove))

    self.assertEqual(op.instance_name, "inst30965")

    self.assertTrue(op.dry_run)

    self.assertFalse(op.ignore_failures)

    self.assertRaises(IndexError, cl.GetNextSubmittedJob)

class TestInstanceInfo(unittest.TestCase):

  def test(self):

    clfactory = _FakeClientFactory(_FakeClient)

    handler = _CreateHandler(rlib2.R_2_instances_name_info, ["inst31217"], {

      "static": ["1"],

      }, {}, clfactory)

    job_id = handler.GET()

    cl = clfactory.GetNextClient()

    self.assertRaises(IndexError, clfactory.GetNextClient)

    (exp_job_id, (op, )) = cl.GetNextSubmittedJob()

    self.assertEqual(job_id, exp_job_id)

    self.assertTrue(isinstance(op, opcodes.OpInstanceQueryData))

    self.assertEqual(op.instances, ["inst31217"])

    self.assertTrue(op.static)

    self.assertRaises(IndexError, cl.GetNextSubmittedJob)

class TestInstanceReboot(unittest.TestCase):

  def test(self):

    clfactory = _FakeClientFactory(_FakeClient)

    handler = _CreateHandler(rlib2.R_2_instances_name_reboot, ["inst847"], {

      "dry-run": ["1"],

      "ignore_secondaries": ["1"],

      "reason": ["System update"],

      }, {}, clfactory)

    job_id = handler.POST()

    cl = clfactory.GetNextClient()

    self.assertRaises(IndexError, clfactory.GetNextClient)

    (exp_job_id, (op, )) = cl.GetNextSubmittedJob()

    self.assertEqual(job_id, exp_job_id)

    self.assertTrue(isinstance(op, opcodes.OpInstanceReboot))

    self.assertEqual(op.instance_name, "inst847")

    self.assertEqual(op.reboot_type, constants.INSTANCE_REBOOT_HARD)

    self.assertTrue(op.ignore_secondaries)

    self.assertTrue(op.dry_run)

    self.assertEqual(op.reason[0][0], constants.OPCODE_REASON_SRC_USER)

    self.assertEqual(op.reason[0][1], "System update")

    self.assertEqual(op.reason[1][0],

                     "%s:%s" % (constants.OPCODE_REASON_SRC_RLIB2,

                                "instances_name_reboot"))

    self.assertEqual(op.reason[1][1], "")

    self.assertRaises(IndexError, cl.GetNextSubmittedJob)

class TestInstanceStartup(unittest.TestCase):

  def test(self):

    clfactory = _FakeClientFactory(_FakeClient)

    handler = _CreateHandler(rlib2.R_2_instances_name_startup, ["inst31083"], {

      "force": ["1"],

      "no_remember": ["1"],

      "reason": ["Newly created instance"],

      }, {}, clfactory)

    job_id = handler.PUT()

    cl = clfactory.GetNextClient()

    self.assertRaises(IndexError, clfactory.GetNextClient)

    (exp_job_id, (op, )) = cl.GetNextSubmittedJob()

    self.assertEqual(job_id, exp_job_id)

    self.assertTrue(isinstance(op, opcodes.OpInstanceStartup))

    self.assertEqual(op.instance_name, "inst31083")

    self.assertTrue(op.no_remember)

    self.assertTrue(op.force)

    self.assertFalse(op.dry_run)

    self.assertEqual(op.reason[0][0], constants.OPCODE_REASON_SRC_USER)

    self.assertEqual(op.reason[0][1], "Newly created instance")

    self.assertEqual(op.reason[1][0],

                     "%s:%s" % (constants.OPCODE_REASON_SRC_RLIB2,

                                "instances_name_startup"))

    self.assertEqual(op.reason[1][1], "")

    self.assertRaises(IndexError, cl.GetNextSubmittedJob)

class TestInstanceShutdown(unittest.TestCase):

  def test(self):

    clfactory = _FakeClientFactory(_FakeClient)

    handler = _CreateHandler(rlib2.R_2_instances_name_shutdown, ["inst26791"], {

      "no_remember": ["0"],

      "reason": ["Not used anymore"],

      }, {}, clfactory)

    job_id = handler.PUT()

    cl = clfactory.GetNextClient()

    self.assertRaises(IndexError, clfactory.GetNextClient)

    (exp_job_id, (op, )) = cl.GetNextSubmittedJob()

    self.assertEqual(job_id, exp_job_id)

    self.assertTrue(isinstance(op, opcodes.OpInstanceShutdown))

    self.assertEqual(op.instance_name, "inst26791")

    self.assertFalse(op.no_remember)

    self.assertFalse(op.dry_run)

    self.assertEqual(op.reason[0][0], constants.OPCODE_REASON_SRC_USER)

    self.assertEqual(op.reason[0][1], "Not used anymore")

    self.assertEqual(op.reason[1][0],

                     "%s:%s" % (constants.OPCODE_REASON_SRC_RLIB2,

                                "instances_name_shutdown"))

    self.assertEqual(op.reason[1][1], "")

    self.assertRaises(IndexError, cl.GetNextSubmittedJob)

class TestInstanceActivateDisks(unittest.TestCase):

  def test(self):

    clfactory = _FakeClientFactory(_FakeClient)

    handler = _CreateHandler(rlib2.R_2_instances_name_activate_disks, ["xyz"], {

      "ignore_size": ["1"],

      }, {}, clfactory)

    job_id = handler.PUT()

    cl = clfactory.GetNextClient()

    self.assertRaises(IndexError, clfactory.GetNextClient)

    (exp_job_id, (op, )) = cl.GetNextSubmittedJob()

    self.assertEqual(job_id, exp_job_id)

    self.assertTrue(isinstance(op, opcodes.OpInstanceActivateDisks))

    self.assertEqual(op.instance_name, "xyz")

    self.assertTrue(op.ignore_size)

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

    self.assertRaises(IndexError, cl.GetNextSubmittedJob)

class TestInstanceDeactivateDisks(unittest.TestCase):

  def test(self):

    clfactory = _FakeClientFactory(_FakeClient)

    handler = _CreateHandler(rlib2.R_2_instances_name_deactivate_disks,

                             ["inst22357"], {}, {}, clfactory)

    job_id = handler.PUT()

    cl = clfactory.GetNextClient()

    self.assertRaises(IndexError, clfactory.GetNextClient)

    (exp_job_id, (op, )) = cl.GetNextSubmittedJob()

    self.assertEqual(job_id, exp_job_id)

    self.assertTrue(isinstance(op, opcodes.OpInstanceDeactivateDisks))

    self.assertEqual(op.instance_name, "inst22357")

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

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

    self.assertRaises(IndexError, cl.GetNextSubmittedJob)

class TestInstanceRecreateDisks(unittest.TestCase):

  def test(self):

    clfactory = _FakeClientFactory(_FakeClient)

    handler = _CreateHandler(rlib2.R_2_instances_name_recreate_disks,

                             ["inst22357"], {}, {}, clfactory)

    job_id = handler.POST()

    cl = clfactory.GetNextClient()

    self.assertRaises(IndexError, clfactory.GetNextClient)

    (exp_job_id, (op, )) = cl.GetNextSubmittedJob()

    self.assertEqual(job_id, exp_job_id)

    self.assertTrue(isinstance(op, opcodes.OpInstanceRecreateDisks))

    self.assertEqual(op.instance_name, "inst22357")

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

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

    self.assertRaises(IndexError, cl.GetNextSubmittedJob)

class TestInstanceFailover(unittest.TestCase):

  def test(self):

    clfactory = _FakeClientFactory(_FakeClient)

    handler = _CreateHandler(rlib2.R_2_instances_name_failover,

                             ["inst12794"], {}, {}, clfactory)

    job_id = handler.PUT()

    cl = clfactory.GetNextClient()

    self.assertRaises(IndexError, clfactory.GetNextClient)

    (exp_job_id, (op, )) = cl.GetNextSubmittedJob()

    self.assertEqual(job_id, exp_job_id)

    self.assertTrue(isinstance(op, opcodes.OpInstanceFailover))

    self.assertEqual(op.instance_name, "inst12794")

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

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

    self.assertRaises(IndexError, cl.GetNextSubmittedJob)

class TestInstanceDiskGrow(unittest.TestCase):

  def test(self):

    clfactory = _FakeClientFactory(_FakeClient)

    data = {

      "amount": 1024,

      }

    handler = _CreateHandler(rlib2.R_2_instances_name_disk_grow,

                             ["inst10742", "3"], {}, data, clfactory)

    job_id = handler.POST()

    cl = clfactory.GetNextClient()

    self.assertRaises(IndexError, clfactory.GetNextClient)

    (exp_job_id, (op, )) = cl.GetNextSubmittedJob()

    self.assertEqual(job_id, exp_job_id)

    self.assertTrue(isinstance(op, opcodes.OpInstanceGrowDisk))

    self.assertEqual(op.instance_name, "inst10742")

    self.assertEqual(op.disk, 3)

    self.assertEqual(op.amount, 1024)

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

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

    self.assertRaises(IndexError, cl.GetNextSubmittedJob)

class TestBackupPrepare(unittest.TestCase):

  def test(self):

    clfactory = _FakeClientFactory(_FakeClient)

    queryargs = {

      "mode": constants.EXPORT_MODE_REMOTE,

      }

    handler = _CreateHandler(rlib2.R_2_instances_name_prepare_export,

                             ["inst17925"], queryargs, {}, clfactory)

    job_id = handler.PUT()

    cl = clfactory.GetNextClient()

    self.assertRaises(IndexError, clfactory.GetNextClient)

    (exp_job_id, (op, )) = cl.GetNextSubmittedJob()

    self.assertEqual(job_id, exp_job_id)

    self.assertTrue(isinstance(op, opcodes.OpBackupPrepare))

    self.assertEqual(op.instance_name, "inst17925")

    self.assertEqual(op.mode, constants.EXPORT_MODE_REMOTE)

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

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

    self.assertRaises(IndexError, cl.GetNextSubmittedJob)

class TestGroupRemove(unittest.TestCase):

  def test(self):

    clfactory = _FakeClientFactory(_FakeClient)

    handler = _CreateHandler(rlib2.R_2_groups_name,

                             ["grp28575"], {}, {}, clfactory)

    job_id = handler.DELETE()

    cl = clfactory.GetNextClient()

    self.assertRaises(IndexError, clfactory.GetNextClient)

    (exp_job_id, (op, )) = cl.GetNextSubmittedJob()

    self.assertEqual(job_id, exp_job_id)

    self.assertTrue(isinstance(op, opcodes.OpGroupRemove))

    self.assertEqual(op.group_name, "grp28575")

    self.assertFalse(op.dry_run)

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

    self.assertRaises(IndexError, cl.GetNextSubmittedJob)

class TestStorageQuery(unittest.TestCase):

  def test(self):

    clfactory = _FakeClientFactory(_FakeClient)

    queryargs = {

      "storage_type": constants.ST_LVM_PV,

      "output_fields": "name,other",

      }

    handler = _CreateHandler(rlib2.R_2_nodes_name_storage,

                             ["node21075"], queryargs, {}, clfactory)

    job_id = handler.GET()

    cl = clfactory.GetNextClient()

    self.assertRaises(IndexError, clfactory.GetNextClient)

    (exp_job_id, (op, )) = cl.GetNextSubmittedJob()

    self.assertEqual(job_id, exp_job_id)

    self.assertTrue(isinstance(op, opcodes.OpNodeQueryStorage))

    self.assertEqual(op.nodes, ["node21075"])

    self.assertEqual(op.storage_type, constants.ST_LVM_PV)

    self.assertEqual(op.output_fields, ["name", "other"])

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

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

    self.assertRaises(IndexError, cl.GetNextSubmittedJob)

  def testErrors(self):

    clfactory = _FakeClientFactory(_FakeClient)

    queryargs = {

      "output_fields": "name,other",

      }

    handler = _CreateHandler(rlib2.R_2_nodes_name_storage,

                             ["node10538"], queryargs, {}, clfactory)

    self.assertRaises(http.HttpBadRequest, handler.GET)

    queryargs = {

      "storage_type": constants.ST_LVM_VG,

      }

    handler = _CreateHandler(rlib2.R_2_nodes_name_storage,

                             ["node21273"], queryargs, {}, clfactory)

    self.assertRaises(http.HttpBadRequest, handler.GET)

    queryargs = {

      "storage_type": "##unknown_storage##",

      "output_fields": "name,other",

      }

    handler = _CreateHandler(rlib2.R_2_nodes_name_storage,

                             ["node10315"], queryargs, {}, clfactory)

    self.assertRaises(http.HttpBadRequest, handler.GET)

class TestStorageModify(unittest.TestCase):

  def test(self):

    clfactory = _FakeClientFactory(_FakeClient)

    for allocatable in [None, "1", "0"]:

      queryargs = {

        "storage_type": constants.ST_LVM_VG,

        "name": "pv-a",

        }

      if allocatable is not None:

        queryargs["allocatable"] = allocatable

      handler = _CreateHandler(rlib2.R_2_nodes_name_storage_modify,

                               ["node9292"], queryargs, {}, clfactory)

      job_id = handler.PUT()

      cl = clfactory.GetNextClient()

      self.assertRaises(IndexError, clfactory.GetNextClient)

      (exp_job_id, (op, )) = cl.GetNextSubmittedJob()

      self.assertEqual(job_id, exp_job_id)

      self.assertTrue(isinstance(op, opcodes.OpNodeModifyStorage))

      self.assertEqual(op.node_name, "node9292")

      self.assertEqual(op.storage_type, constants.ST_LVM_VG)

      self.assertEqual(op.name, "pv-a")

      if allocatable is None:

        self.assertFalse(op.changes)

      else:

        assert allocatable in ("0", "1")

        self.assertEqual(op.changes, {

          constants.SF_ALLOCATABLE: (allocatable == "1"),

          })

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

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

      self.assertRaises(IndexError, cl.GetNextSubmittedJob)

  def testErrors(self):

    clfactory = _FakeClientFactory(_FakeClient)

    # No storage type

    queryargs = {

      "name": "xyz",

      }

    handler = _CreateHandler(rlib2.R_2_nodes_name_storage_modify,

                             ["node26016"], queryargs, {}, clfactory)

    self.assertRaises(http.HttpBadRequest, handler.PUT)

    # No name

    queryargs = {

      "storage_type": constants.ST_LVM_VG,

      }

    handler = _CreateHandler(rlib2.R_2_nodes_name_storage_modify,

                             ["node21218"], queryargs, {}, clfactory)

    self.assertRaises(http.HttpBadRequest, handler.PUT)

    # Invalid value

    queryargs = {

      "storage_type": constants.ST_LVM_VG,

      "name": "pv-b",

      "allocatable": "noint",

      }

    handler = _CreateHandler(rlib2.R_2_nodes_name_storage_modify,

                             ["node30685"], queryargs, {}, clfactory)

    self.assertRaises(http.HttpBadRequest, handler.PUT)

class TestStorageRepair(unittest.TestCase):

  def test(self):

    clfactory = _FakeClientFactory(_FakeClient)

    queryargs = {

      "storage_type": constants.ST_LVM_PV,

      "name": "pv16611",

      }

    handler = _CreateHandler(rlib2.R_2_nodes_name_storage_repair,

                             ["node19265"], queryargs, {}, clfactory)

    job_id = handler.PUT()

    cl = clfactory.GetNextClient()

    self.assertRaises(IndexError, clfactory.GetNextClient)

    (exp_job_id, (op, )) = cl.GetNextSubmittedJob()

    self.assertEqual(job_id, exp_job_id)

    self.assertTrue(isinstance(op, opcodes.OpRepairNodeStorage))

    self.assertEqual(op.node_name, "node19265")

    self.assertEqual(op.storage_type, constants.ST_LVM_PV)

    self.assertEqual(op.name, "pv16611")

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

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

    self.assertRaises(IndexError, cl.GetNextSubmittedJob)

  def testErrors(self):

    clfactory = _FakeClientFactory(_FakeClient)

    # No storage type

    queryargs = {

      "name": "xyz",

      }

    handler = _CreateHandler(rlib2.R_2_nodes_name_storage_repair,

                             ["node11275"], queryargs, {}, clfactory)

    self.assertRaises(http.HttpBadRequest, handler.PUT)

    # No name

    queryargs = {

      "storage_type": constants.ST_LVM_VG,

      }

    handler = _CreateHandler(rlib2.R_2_nodes_name_storage_repair,

                             ["node21218"], queryargs, {}, clfactory)

    self.assertRaises(http.HttpBadRequest, handler.PUT)

class TestTags(unittest.TestCase):

  TAG_HANDLERS = [

    rlib2.R_2_instances_name_tags,

    rlib2.R_2_nodes_name_tags,

    rlib2.R_2_groups_name_tags,

    rlib2.R_2_tags,

    ]

  def testSetAndDelete(self):

    clfactory = _FakeClientFactory(_FakeClient)

    for method, opcls in [("PUT", opcodes.OpTagsSet),

                          ("DELETE", opcodes.OpTagsDel)]:

      for idx, handler in enumerate(self.TAG_HANDLERS):

        dry_run = bool(idx % 2)

        name = "test%s" % idx

        queryargs = {

          "tag": ["foo", "bar", "baz"],

          "dry-run": str(int(dry_run)),

          }

        handler = _CreateHandler(handler, [name], queryargs, {}, clfactory)

        job_id = getattr(handler, method)()

        cl = clfactory.GetNextClient()

        self.assertRaises(IndexError, clfactory.GetNextClient)