#!/usr/bin/python
#

# Copyright (C) 2010, 2012, 2013 Google Inc.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
# 1. Redistributions of source code must retain the above copyright notice,
# this list of conditions and the following disclaimer.
#
# 2. Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
# IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
# TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


"""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 ht
from ganeti import http
from ganeti import query
import ganeti.rpc.errors as rpcerr
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 RAPITestCase(testutils.GanetiTestCase):
  """Provides a few helper methods specific to RAPI testing.

  """
  def __init__(self, *args, **kwargs):
    """Creates a fake client factory the test may or may not use.

    """
    unittest.TestCase.__init__(self, *args, **kwargs)
    self._clfactory = _FakeClientFactory(_FakeClient)

  def assertNoNextClient(self, clfactory=None):
    """Insures that no further clients are present.

    """
    if clfactory is None:
      clfactory = self._clfactory

    self.assertRaises(IndexError, clfactory.GetNextClient)

  def getSubmittedOpcode(self, rapi_cls, items, query_args, body_data,
                         method_name, opcode_cls):
    """Submits a RAPI request and fetches the resulting opcode.

    """
    handler = _CreateHandler(rapi_cls, items, query_args, body_data,
                             self._clfactory)
    self.assertTrue(hasattr(handler, method_name),
                    "Handler lacks target method %s" % method_name)
    job_id = getattr(handler, method_name)()
    try:
      int(job_id)
    except ValueError:
      raise AssertionError("Returned value not job id; received %s" % job_id)

    cl = self._clfactory.GetNextClient()
    self.assertNoNextClient()

    (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
    self.assertEqual(job_id, exp_job_id,
                     "Job IDs do not match: %s != %s" % (job_id, exp_job_id))
    self.assertRaises(IndexError, cl.GetNextSubmittedJob)

    self.assertTrue(isinstance(op, opcode_cls),
                    "Wrong opcode class: expected %s, got %s" %
                    (opcode_cls.__name__, op.__class__.__name__))

    return op


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 rpcerr.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(RAPITestCase):
  def test(self):
    body_data = {
      "vg_name": "testvg",
      "candidate_pool_size": 100,
      }
    op = self.getSubmittedOpcode(rlib2.R_2_cluster_modify, [], {}, body_data,
                                 "PUT", opcodes.OpClusterSetParams)

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

  def testInvalidValue(self):
    for attr in ["vg_name", "candidate_pool_size", "beparams", "_-Unknown#"]:
      handler = _CreateHandler(rlib2.R_2_cluster_modify, [], {}, {
        attr: True,
        }, self._clfactory)
      self.assertRaises(http.HttpBadRequest, handler.PUT)
      self.assertNoNextClient()

  def testForbiddenParams(self):
    for attr, value in [
      ("compression_tools", ["lzop"]),
      ]:
      handler = _CreateHandler(rlib2.R_2_cluster_modify, [], {}, {
        attr: value,
        }, self._clfactory)
      self.assertRaises(http.HttpForbidden, handler.PUT)
      self.assertNoNextClient()


class TestRedistConfig(RAPITestCase):
  def test(self):
    self.getSubmittedOpcode(rlib2.R_2_redist_config, [], {}, None, "PUT",
                            opcodes.OpClusterRedistConf)


class TestNodeMigrate(RAPITestCase):
  def test(self):
    body_data = {
      "iallocator": "fooalloc",
      }
    op = self.getSubmittedOpcode(rlib2.R_2_nodes_name_migrate, ["node1"], {},
                                 body_data, "POST", opcodes.OpNodeMigrate)
    self.assertEqual(op.node_name, "node1")
    self.assertEqual(op.iallocator, "fooalloc")

  def testQueryArgsConflict(self):
    query_args = {
      "live": True,
      "mode": constants.HT_MIGRATION_NONLIVE,
      }
    handler = _CreateHandler(rlib2.R_2_nodes_name_migrate, ["node2"],
                             query_args, None, self._clfactory)
    self.assertRaises(http.HttpBadRequest, handler.POST)
    self.assertNoNextClient()

  def testQueryArgsMode(self):
    query_args = {
      "mode": [constants.HT_MIGRATION_LIVE],
      }
    op = self.getSubmittedOpcode(rlib2.R_2_nodes_name_migrate, ["node17292"],
                                 query_args, None, "POST",
                                 opcodes.OpNodeMigrate)
    self.assertEqual(op.node_name, "node17292")
    self.assertEqual(op.mode, constants.HT_MIGRATION_LIVE)

  def testQueryArgsLive(self):
    clfactory = _FakeClientFactory(_FakeClient)

    for live in [False, True]:
      query_args = {
        "live": [str(int(live))],
        }
      op = self.getSubmittedOpcode(rlib2.R_2_nodes_name_migrate, ["node6940"],
                                   query_args, None, "POST",
                                   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)


class TestNodeEvacuate(RAPITestCase):
  def test(self):
    query_args = {
      "dry-run": ["1"],
      }
    body_data = {
      "mode": constants.NODE_EVAC_SEC,
      }
    op = self.getSubmittedOpcode(rlib2.R_2_nodes_name_evacuate, ["node92"],
                                 query_args, body_data, "POST",
                                 opcodes.OpNodeEvacuate)
    self.assertEqual(op.node_name, "node92")
    self.assertEqual(op.mode, constants.NODE_EVAC_SEC)


class TestNodePowercycle(RAPITestCase):
  def test(self):
    query_args = {
      "force": ["1"],
      }
    op = self.getSubmittedOpcode(rlib2.R_2_nodes_name_powercycle, ["node20744"],
                                 query_args, None, "POST",
                                 opcodes.OpNodePowercycle)
    self.assertEqual(op.node_name, "node20744")
    self.assertTrue(op.force)


class TestGroupAssignNodes(RAPITestCase):
  def test(self):
    clfactory = _FakeClientFactory(_FakeClient)
    query_args = {
      "dry-run": ["1"],
      "force": ["1"],
      }
    body_data = {
      "nodes": ["n2", "n3"],
      }
    op = self.getSubmittedOpcode(rlib2.R_2_groups_name_assign_nodes, ["grp-a"],
                                 query_args, body_data, "PUT",
                                 opcodes.OpGroupAssignNodes)
    self.assertEqual(op.group_name, "grp-a")
    self.assertEqual(op.nodes, ["n2", "n3"])
    self.assertTrue(op.dry_run)
    self.assertTrue(op.force)


class TestInstanceDelete(RAPITestCase):
  def test(self):
    query_args = {
      "dry-run": ["1"],
      }
    op = self.getSubmittedOpcode(rlib2.R_2_instances_name, ["inst30965"],
                                 query_args, {}, "DELETE",
                                 opcodes.OpInstanceRemove)

    self.assertEqual(op.instance_name, "inst30965")
    self.assertTrue(op.dry_run)
    self.assertFalse(op.ignore_failures)


class TestInstanceInfo(RAPITestCase):
  def test(self):
    query_args = {
      "static": ["1"],
      }
    op = self.getSubmittedOpcode(rlib2.R_2_instances_name_info, ["inst31217"],
                                 query_args, {}, "GET",
                                 opcodes.OpInstanceQueryData)

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


class TestInstanceReboot(RAPITestCase):
  def test(self):
    query_args = {
      "dry-run": ["1"],
      "ignore_secondaries": ["1"],
      "reason": ["System update"],
      }
    op = self.getSubmittedOpcode(rlib2.R_2_instances_name_reboot, ["inst847"],
                                 query_args, {}, "POST",
                                 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], "")


class TestInstanceStartup(RAPITestCase):
  def test(self):
    query_args = {
      "force": ["1"],
      "no_remember": ["1"],
      "reason": ["Newly created instance"],
      }
    op = self.getSubmittedOpcode(rlib2.R_2_instances_name_startup,
                                 ["inst31083"], query_args, {}, "PUT",
                                 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], "")


class TestInstanceShutdown(RAPITestCase):
  def test(self):
    query_args = {
      "no_remember": ["0"],
      "reason": ["Not used anymore"],
      }
    op = self.getSubmittedOpcode(rlib2.R_2_instances_name_shutdown,
                                 ["inst26791"], query_args, {}, "PUT",
                                 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], "")


class TestInstanceActivateDisks(RAPITestCase):
  def test(self):
    query_args = {
      "ignore_size": ["1"],
      }
    op = self.getSubmittedOpcode(rlib2.R_2_instances_name_activate_disks,
                                 ["xyz"], query_args, {}, "PUT",
                                 opcodes.OpInstanceActivateDisks)

    self.assertEqual(op.instance_name, "xyz")
    self.assertTrue(op.ignore_size)
    self.assertFalse(op.dry_run)


class TestInstanceDeactivateDisks(RAPITestCase):
  def test(self):
    op = self.getSubmittedOpcode(rlib2.R_2_instances_name_deactivate_disks,
                                 ["inst22357"], {}, {}, "PUT",
                                 opcodes.OpInstanceDeactivateDisks)

    self.assertEqual(op.instance_name, "inst22357")
    self.assertFalse(op.dry_run)
    self.assertFalse(op.force)


class TestInstanceRecreateDisks(RAPITestCase):
  def test(self):
    op = self.getSubmittedOpcode(rlib2.R_2_instances_name_recreate_disks,
                                 ["inst22357"], {}, {}, "POST",
                                 opcodes.OpInstanceRecreateDisks)

    self.assertEqual(op.instance_name, "inst22357")
    self.assertFalse(op.dry_run)
    self.assertTrue(op.iallocator is None)
    self.assertFalse(hasattr(op, "force"))

  def testCustomParameters(self):
    data = {
      "iallocator": "hail",
      }
    op = self.getSubmittedOpcode(rlib2.R_2_instances_name_recreate_disks,
                                 ["inst22357"], {}, data, "POST",
                                 opcodes.OpInstanceRecreateDisks)
    self.assertEqual(op.instance_name, "inst22357")
    self.assertEqual(op.iallocator, "hail")
    self.assertFalse(op.dry_run)


class TestInstanceFailover(RAPITestCase):
  def test(self):
    op = self.getSubmittedOpcode(rlib2.R_2_instances_name_failover,
                                 ["inst12794"], {}, {}, "PUT",
                                 opcodes.OpInstanceFailover)

    self.assertEqual(op.instance_name, "inst12794")
    self.assertFalse(op.dry_run)
    self.assertFalse(hasattr(op, "force"))


class TestInstanceDiskGrow(RAPITestCase):
  def test(self):
    data = {
      "amount": 1024,
      }
    op = self.getSubmittedOpcode(rlib2.R_2_instances_name_disk_grow,
                                 ["inst10742", "3"], {}, data, "POST",
                                 opcodes.OpInstanceGrowDisk)

    self.assertEqual(op.instance_name, "inst10742")
    self.assertEqual(op.disk, 3)
    self.assertEqual(op.amount, 1024)
    self.assertFalse(op.dry_run)
    self.assertFalse(hasattr(op, "force"))


class TestInstanceModify(RAPITestCase):
  def testCustomParamRename(self):
    name = "instant_instance"
    data = {
      "custom_beparams": {},
      "custom_hvparams": {},
      }

    op = self.getSubmittedOpcode(rlib2.R_2_instances_name_modify, [name], {},
                                 data, "PUT", opcodes.OpInstanceSetParams)

    self.assertEqual(op.beparams, {})
    self.assertEqual(op.hvparams, {})

    # Define both
    data["beparams"] = {}
    assert "beparams" in data and "custom_beparams" in data
    handler = _CreateHandler(rlib2.R_2_instances_name_modify, [name], {}, data,
                             self._clfactory)
    self.assertRaises(http.HttpBadRequest, handler.PUT)


class TestBackupPrepare(RAPITestCase):
  def test(self):
    query_args = {
      "mode": constants.EXPORT_MODE_REMOTE,
      }
    op = self.getSubmittedOpcode(rlib2.R_2_instances_name_prepare_export,
                                 ["inst17925"], query_args, {}, "PUT",
                                 opcodes.OpBackupPrepare)

    self.assertEqual(op.instance_name, "inst17925")
    self.assertEqual(op.mode, constants.EXPORT_MODE_REMOTE)
    self.assertFalse(op.dry_run)
    self.assertFalse(hasattr(op, "force"))


class TestGroupRemove(RAPITestCase):
  def test(self):
    op = self.getSubmittedOpcode(rlib2.R_2_groups_name, ["grp28575"], {}, {},
                                 "DELETE", opcodes.OpGroupRemove)

    self.assertEqual(op.group_name, "grp28575")
    self.assertFalse(op.dry_run)
    self.assertFalse(hasattr(op, "force"))


class TestStorageQuery(RAPITestCase):
  def test(self):
    query_args = {
      "storage_type": constants.ST_LVM_PV,
      "output_fields": "name,other",
      }
    op = self.getSubmittedOpcode(rlib2.R_2_nodes_name_storage, ["node21075"],
                                 query_args, {}, "GET",
                                 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(op.dry_run)
    self.assertFalse(hasattr(op, "force"))

  def testErrors(self):
    # storage type which does not support space reporting
    queryargs = {
      "storage_type": constants.ST_DISKLESS,
      }
    handler = _CreateHandler(rlib2.R_2_nodes_name_storage,
                             ["node21273"], queryargs, {}, self._clfactory)
    self.assertRaises(http.HttpBadRequest, handler.GET)

    queryargs = {
      "storage_type": constants.ST_LVM_VG,
      }
    handler = _CreateHandler(rlib2.R_2_nodes_name_storage,
                             ["node21273"], queryargs, {}, self._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, {}, self._clfactory)
    self.assertRaises(http.HttpBadRequest, handler.GET)


class TestStorageModify(RAPITestCase):
  def test(self):
    clfactory = _FakeClientFactory(_FakeClient)

    for allocatable in [None, "1", "0"]:
      query_args = {
        "storage_type": constants.ST_LVM_VG,
        "name": "pv-a",
        }

      if allocatable is not None:
        query_args["allocatable"] = allocatable

      op = self.getSubmittedOpcode(rlib2.R_2_nodes_name_storage_modify,
                                   ["node9292"], query_args, {}, "PUT",
                                   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(op.dry_run)
      self.assertFalse(hasattr(op, "force"))

  def testErrors(self):
    # No storage type
    queryargs = {
      "name": "xyz",
      }
    handler = _CreateHandler(rlib2.R_2_nodes_name_storage_modify,
                             ["node26016"], queryargs, {}, self._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, {}, self._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, {}, self._clfactory)
    self.assertRaises(http.HttpBadRequest, handler.PUT)


class TestStorageRepair(RAPITestCase):
  def test(self):
    query_args = {
      "storage_type": constants.ST_LVM_PV,
      "name": "pv16611",
      }
    op = self.getSubmittedOpcode(rlib2.R_2_nodes_name_storage_repair,
                                 ["node19265"], query_args, {}, "PUT",
                                 opcodes.OpRepairNodeStorage)

    self.assertEqual(op.node_name, "node19265")
    self.assertEqual(op.storage_type, constants.ST_LVM_PV)
    self.assertEqual(op.name, "pv16611")
    self.assertFalse(op.dry_run)
    self.assertFalse(hasattr(op, "force"))

  def testErrors(self):
    # No storage type
    queryargs = {
      "name": "xyz",
      }
    handler = _CreateHandler(rlib2.R_2_nodes_name_storage_repair,
                             ["node11275"], queryargs, {}, self._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, {}, self._clfactory)
    self.assertRaises(http.HttpBadRequest, handler.PUT)


class TestTags(RAPITestCase):
  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):
    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)),
          }

        op = self.getSubmittedOpcode(handler, [name], queryargs, {}, method,
                                     opcls)

        self.assertEqual(op.kind, handler.TAG_LEVEL)
        if handler.TAG_LEVEL == constants.TAG_CLUSTER:
          self.assertTrue(op.name is None)
        else:
          self.assertEqual(op.name, name)
        self.assertEqual(op.tags, ["foo", "bar", "baz"])
        self.assertEqual(op.dry_run, dry_run)
        self.assertFalse(hasattr(op, "force"))


class TestInstanceCreation(RAPITestCase):
  def test(self):
    name = "inst863.example.com"

    disk_variants = [
      # No disks
      [],

      # Two disks
      [{"size": 5, }, {"size": 100, }],

      # Disk with mode
      [{"size": 123, "mode": constants.DISK_RDWR, }],
      ]

    nic_variants = [
      # No NIC
      [],

      # Three NICs
      [{}, {}, {}],

      # Two NICs
      [
        { "ip": "192.0.2.6", "mode": constants.NIC_MODE_ROUTED,
          "mac": "01:23:45:67:68:9A",
        },
        { "mode": constants.NIC_MODE_BRIDGED, "link": "br1" },
      ],
      ]

    beparam_variants = [
      None,
      {},
      { constants.BE_VCPUS: 2, },
      { constants.BE_MAXMEM: 200, },
      { constants.BE_MEMORY: 256, },
      { constants.BE_VCPUS: 2,
        constants.BE_MAXMEM: 1024,
        constants.BE_MINMEM: 1024,
        constants.BE_AUTO_BALANCE: True,
        constants.BE_ALWAYS_FAILOVER: True, }
      ]

    hvparam_variants = [
      None,
      { constants.HV_BOOT_ORDER: "anc", },
      { constants.HV_KERNEL_PATH: "/boot/fookernel",
        constants.HV_ROOT_PATH: "/dev/hda1", },
      ]

    for mode in [constants.INSTANCE_CREATE, constants.INSTANCE_IMPORT]:
      for nics in nic_variants:
        for disk_template in constants.DISK_TEMPLATES:
          for disks in disk_variants:
            for beparams in beparam_variants:
              for hvparams in hvparam_variants:
                for dry_run in [False, True]:
                  query_args = {
                    "dry-run": str(int(dry_run)),
                    }

                  data = {
                    rlib2._REQ_DATA_VERSION: 1,
                    "name": name,
                    "hypervisor": constants.HT_FAKE,
                    "disks": disks,
                    "nics": nics,
                    "mode": mode,
                    "disk_template": disk_template,
                    "os": "debootstrap",
                    }

                  if beparams is not None:
                    data["beparams"] = beparams

                  if hvparams is not None:
                    data["hvparams"] = hvparams

                  op = self.getSubmittedOpcode(
                    rlib2.R_2_instances, [], query_args, data, "POST",
                    opcodes.OpInstanceCreate
                  )

                  self.assertEqual(op.instance_name, name)
                  self.assertEqual(op.mode, mode)
                  self.assertEqual(op.disk_template, disk_template)
                  self.assertEqual(op.dry_run, dry_run)
                  self.assertEqual(len(op.disks), len(disks))
                  self.assertEqual(len(op.nics), len(nics))

                  for opdisk, disk in zip(op.disks, disks):
                    for key in constants.IDISK_PARAMS:
                      self.assertEqual(opdisk.get(key), disk.get(key))
                    self.assertFalse("unknown" in opdisk)

                  for opnic, nic in zip(op.nics, nics):
                    for key in constants.INIC_PARAMS:
                      self.assertEqual(opnic.get(key), nic.get(key))
                    self.assertFalse("unknown" in opnic)
                    self.assertFalse("foobar" in opnic)

                  if beparams is None:
                    self.assertTrue(op.beparams in [None, {}])
                  else:
                    self.assertEqualValues(op.beparams, beparams)

                  if hvparams is None:
                    self.assertTrue(op.hvparams in [None, {}])
                  else:
                    self.assertEqualValues(op.hvparams, hvparams)

  def testLegacyName(self):
    name = "inst29128.example.com"
    data = {
      rlib2._REQ_DATA_VERSION: 1,
      "name": name,
      "disks": [],
      "nics": [],
      "mode": constants.INSTANCE_CREATE,
      "disk_template": constants.DT_PLAIN,
      }

    op = self.getSubmittedOpcode(rlib2.R_2_instances, [], {}, data, "POST",
                                 opcodes.OpInstanceCreate)

    self.assertEqual(op.instance_name, name)
    self.assertFalse(hasattr(op, "name"))
    self.assertFalse(op.dry_run)

    # Define both
    data["instance_name"] = "other.example.com"
    assert "name" in data and "instance_name" in data
    handler = _CreateHandler(rlib2.R_2_instances, [], {}, data, self._clfactory)
    self.assertRaises(http.HttpBadRequest, handler.POST)
    self.assertNoNextClient()

  def testLegacyOs(self):
    name = "inst4673.example.com"
    os = "linux29206"
    data = {
      rlib2._REQ_DATA_VERSION: 1,
      "name": name,
      "os_type": os,
      "disks": [],
      "nics": [],
      "mode": constants.INSTANCE_CREATE,
      "disk_template": constants.DT_PLAIN,
      }

    op = self.getSubmittedOpcode(rlib2.R_2_instances, [], {}, data, "POST",
                                 opcodes.OpInstanceCreate)

    self.assertEqual(op.instance_name, name)
    self.assertEqual(op.os_type, os)
    self.assertFalse(hasattr(op, "os"))
    self.assertFalse(op.dry_run)

    # Define both
    data["os"] = "linux9584"
    assert "os" in data and "os_type" in data
    handler = _CreateHandler(rlib2.R_2_instances, [], {}, data, self._clfactory)
    self.assertRaises(http.HttpBadRequest, handler.POST)

  def testErrors(self):
    # Test all required fields
    reqfields = {
      rlib2._REQ_DATA_VERSION: 1,
      "name": "inst1.example.com",
      "disks": [],
      "nics": [],
      "mode": constants.INSTANCE_CREATE,
      }

    for name in reqfields.keys():
      data = dict(i for i in reqfields.iteritems() if i[0] != name)

      handler = _CreateHandler(rlib2.R_2_instances, [], {}, data,
                               self._clfactory)
      self.assertRaises(http.HttpBadRequest, handler.POST)
      self.assertNoNextClient()

    # Invalid disks and nics
    for field in ["disks", "nics"]:
      invalid_values = [None, 1, "", {}, [1, 2, 3], ["hda1", "hda2"],
                        [{"_unknown_": False, }]]

      for invvalue in invalid_values:
        data = reqfields.copy()
        data[field] = invvalue
        handler = _CreateHandler(rlib2.R_2_instances, [], {}, data,
                                 self._clfactory)
        self.assertRaises(http.HttpBadRequest, handler.POST)
        self.assertNoNextClient()

  def testVersion(self):
    # No version field
    data = {
      "name": "inst1.example.com",
      "disks": [],
      "nics": [],
      "mode": constants.INSTANCE_CREATE,
      "disk_template": constants.DT_PLAIN,
      }

    handler = _CreateHandler(rlib2.R_2_instances, [], {}, data, self._clfactory)
    self.assertRaises(http.HttpBadRequest, handler.POST)

    # Old and incorrect versions
    for version in [0, -1, 10483, "Hello World"]:
      data[rlib2._REQ_DATA_VERSION] = version

      handler = _CreateHandler(rlib2.R_2_instances, [], {}, data,
                               self._clfactory)
      self.assertRaises(http.HttpBadRequest, handler.POST)
      self.assertNoNextClient()

    # Correct version
    data[rlib2._REQ_DATA_VERSION] = 1
    self.getSubmittedOpcode(rlib2.R_2_instances, [], {}, data, "POST",
                            opcodes.OpInstanceCreate)


class TestBackupExport(RAPITestCase):
  def test(self):
    name = "instmoo"
    data = {
      "mode": constants.EXPORT_MODE_REMOTE,
      "destination": [(1, 2, 3), (99, 99, 99)],
      "shutdown": True,
      "remove_instance": True,
      "x509_key_name": ["name", "hash"],
      "destination_x509_ca": "---cert---"
      }

    op = self.getSubmittedOpcode(rlib2.R_2_instances_name_export, [name], {},
                                 data, "PUT", opcodes.OpBackupExport)

    self.assertEqual(op.instance_name, name)
    self.assertEqual(op.mode, constants.EXPORT_MODE_REMOTE)
    self.assertEqual(op.target_node, [(1, 2, 3), (99, 99, 99)])
    self.assertEqual(op.shutdown, True)
    self.assertEqual(op.remove_instance, True)
    self.assertEqual(op.x509_key_name, ["name", "hash"])
    self.assertEqual(op.destination_x509_ca, "---cert---")
    self.assertFalse(op.dry_run)
    self.assertFalse(hasattr(op, "force"))

  def testDefaults(self):
    name = "inst1"
    data = {
      "destination": "node2",
      "shutdown": False,
      }

    op = self.getSubmittedOpcode(rlib2.R_2_instances_name_export, [name], {},
                                 data, "PUT", opcodes.OpBackupExport)

    self.assertEqual(op.instance_name, name)
    self.assertEqual(op.target_node, "node2")
    self.assertEqual(op.mode, "local")
    self.assertFalse(op.remove_instance)
    self.assertFalse(hasattr(op, "destination"))
    self.assertFalse(op.dry_run)
    self.assertFalse(hasattr(op, "force"))

  def testErrors(self):
    clfactory = _FakeClientFactory(_FakeClient)

    for value in ["True", "False"]:
      data = {
        "remove_instance": value,
        }
      handler = _CreateHandler(rlib2.R_2_instances_name_export, ["err1"], {},
                               data, self._clfactory)
      self.assertRaises(http.HttpBadRequest, handler.PUT)


class TestInstanceMigrate(RAPITestCase):
  def test(self):
    name = "instYooho6ek"

    for cleanup in [False, True]:
      for mode in constants.HT_MIGRATION_MODES:
        data = {
          "cleanup": cleanup,
          "mode": mode,
          }

        op = self.getSubmittedOpcode(rlib2.R_2_instances_name_migrate, [name],
                                     {}, data, "PUT", opcodes.OpInstanceMigrate)

        self.assertEqual(op.instance_name, name)
        self.assertEqual(op.mode, mode)
        self.assertEqual(op.cleanup, cleanup)
        self.assertFalse(op.dry_run)
        self.assertFalse(hasattr(op, "force"))

  def testDefaults(self):
    name = "instnohZeex0"

    op = self.getSubmittedOpcode(rlib2.R_2_instances_name_migrate, [name], {},
                                 {}, "PUT", opcodes.OpInstanceMigrate)

    self.assertEqual(op.instance_name, name)
    self.assertTrue(op.mode is None)
    self.assertFalse(op.cleanup)
    self.assertFalse(op.dry_run)
    self.assertFalse(hasattr(op, "force"))


class TestParseRenameInstanceRequest(RAPITestCase):
  def test(self):
    name = "instij0eeph7"

    for new_name in ["ua0aiyoo", "fai3ongi"]:
      for ip_check in [False, True]:
        for name_check in [False, True]:
          data = {
            "new_name": new_name,
            "ip_check": ip_check,
            "name_check": name_check,
            }

          op = self.getSubmittedOpcode(rlib2.R_2_instances_name_rename, [name],
                                       {}, data, "PUT",
                                       opcodes.OpInstanceRename)

          self.assertEqual(op.instance_name, name)
          self.assertEqual(op.new_name, new_name)
          self.assertEqual(op.ip_check, ip_check)
          self.assertEqual(op.name_check, name_check)
          self.assertFalse(op.dry_run)
          self.assertFalse(hasattr(op, "force"))

  def testDefaults(self):
    name = "instahchie3t"

    for new_name in ["thag9mek", "quees7oh"]:
      data = {
        "new_name": new_name,
        }

      op = self.getSubmittedOpcode(rlib2.R_2_instances_name_rename, [name],
                                   {}, data, "PUT", opcodes.OpInstanceRename)

      self.assertEqual(op.instance_name, name)
      self.assertEqual(op.new_name, new_name)
      self.assertTrue(op.ip_check)
      self.assertTrue(op.name_check)
      self.assertFalse(op.dry_run)
      self.assertFalse(hasattr(op, "force"))


class TestParseModifyInstanceRequest(RAPITestCase):
  def test(self):
    name = "instush8gah"

    test_disks = [
      [],
      [(1, { constants.IDISK_MODE: constants.DISK_RDWR, })],
      ]

    for osparams in [{}, { "some": "value", "other": "Hello World", }]:
      for hvparams in [{}, { constants.HV_KERNEL_PATH: "/some/kernel", }]:
        for beparams in [{}, { constants.BE_MAXMEM: 128, }]:
          for force in [False, True]:
            for nics in [[], [(0, { constants.INIC_IP: "192.0.2.1", })]]:
              for disks in test_disks:
                for disk_template in constants.DISK_TEMPLATES:
                  data = {
                    "osparams": osparams,
                    "hvparams": hvparams,
                    "beparams": beparams,
                    "nics": nics,
                    "disks": disks,
                    "force": force,
                    "disk_template": disk_template,
                    }

                  op = self.getSubmittedOpcode(
                    rlib2.R_2_instances_name_modify, [name], {}, data, "PUT",
                    opcodes.OpInstanceSetParams
                  )

                  self.assertEqual(op.instance_name, name)
                  self.assertEqual(op.hvparams, hvparams)
                  self.assertEqual(op.beparams, beparams)
                  self.assertEqual(op.osparams, osparams)
                  self.assertEqual(op.force, force)
                  self.assertEqual(op.nics, nics)
                  self.assertEqual(op.disks, disks)
                  self.assertEqual(op.disk_template, disk_template)
                  self.assertTrue(op.remote_node is None)
                  self.assertTrue(op.os_name is None)
                  self.assertFalse(op.force_variant)
                  self.assertFalse(op.dry_run)

  def testDefaults(self):
    name = "instir8aish31"

    op = self.getSubmittedOpcode(rlib2.R_2_instances_name_modify, [name], {},
                                 {}, "PUT", opcodes.OpInstanceSetParams)

    for i in ["hvparams", "beparams", "osparams", "force", "nics", "disks",
              "disk_template", "remote_node", "os_name", "force_variant"]:
      self.assertTrue(hasattr(op, i))


class TestParseInstanceReinstallRequest(testutils.GanetiTestCase):
  def setUp(self):
    testutils.GanetiTestCase.setUp(self)

    self.Parse = rlib2._ParseInstanceReinstallRequest

  def _Check(self, ops, name):
    expcls = [
      opcodes.OpInstanceShutdown,
      opcodes.OpInstanceReinstall,
      opcodes.OpInstanceStartup,
      ]

    self.assert_(compat.all(isinstance(op, exp)
                            for op, exp in zip(ops, expcls)))
    self.assert_(compat.all(op.instance_name == name for op in ops))

  def test(self):
    name = "shoo0tihohma"

    ops = self.Parse(name, {"os": "sys1", "start": True,})
    self.assertEqual(len(ops), 3)
    self._Check(ops, name)
    self.assertEqual(ops[1].os_type, "sys1")
    self.assertFalse(ops[1].osparams)

    ops = self.Parse(name, {"os": "sys2", "start": False,})
    self.assertEqual(len(ops), 2)
    self._Check(ops, name)
    self.assertEqual(ops[1].os_type, "sys2")

    osparams = {
      "reformat": "1",
      }
    ops = self.Parse(name, {"os": "sys4035", "start": True,
                            "osparams": osparams,})
    self.assertEqual(len(ops), 3)
    self._Check(ops, name)
    self.assertEqual(ops[1].os_type, "sys4035")
    self.assertEqual(ops[1].osparams, osparams)

  def testDefaults(self):
    name = "noolee0g"

    ops = self.Parse(name, {"os": "linux1"})
    self.assertEqual(len(ops), 3)
    self._Check(ops, name)
    self.assertEqual(ops[1].os_type, "linux1")
    self.assertFalse(ops[1].osparams)

  def testErrors(self):
    self.assertRaises(http.HttpBadRequest, self.Parse,
                      "foo", "not a dictionary")


class TestGroupRename(RAPITestCase):
  def test(self):
    name = "group608242564"
    data = {
      "new_name": "ua0aiyoo15112",
      }

    op = self.getSubmittedOpcode(rlib2.R_2_groups_name_rename, [name], {}, data,
                                 "PUT", opcodes.OpGroupRename)

    self.assertEqual(op.group_name, name)
    self.assertEqual(op.new_name, "ua0aiyoo15112")
    self.assertFalse(op.dry_run)

  def testDryRun(self):
    name = "group28548"
    query_args = {
      "dry-run": ["1"],
      }
    data = {
      "new_name": "ua0aiyoo",
      }

    op = self.getSubmittedOpcode(rlib2.R_2_groups_name_rename, [name],
                                 query_args, data, "PUT", opcodes.OpGroupRename)

    self.assertEqual(op.group_name, name)
    self.assertEqual(op.new_name, "ua0aiyoo")
    self.assertTrue(op.dry_run)


class TestInstanceReplaceDisks(RAPITestCase):
  def test(self):
    name = "inst22568"

    for disks in [range(1, 4), "1,2,3", "1, 2, 3"]:
      data = {
        "mode": constants.REPLACE_DISK_SEC,
        "disks": disks,
        "iallocator": "myalloc",
        }

      op = self.getSubmittedOpcode(rlib2.R_2_instances_name_replace_disks,
                                   [name], {}, data, "POST",
                                   opcodes.OpInstanceReplaceDisks)

      self.assertEqual(op.instance_name, name)
      self.assertEqual(op.mode, constants.REPLACE_DISK_SEC)
      self.assertEqual(op.disks, [1, 2, 3])
      self.assertEqual(op.iallocator, "myalloc")

  def testDefaults(self):
    name = "inst11413"
    data = {
      "mode": constants.REPLACE_DISK_AUTO,
      }

    op = self.getSubmittedOpcode(rlib2.R_2_instances_name_replace_disks,
                                 [name], {}, data, "POST",
                                 opcodes.OpInstanceReplaceDisks)

    self.assertEqual(op.instance_name, name)
    self.assertEqual(op.mode, constants.REPLACE_DISK_AUTO)
    self.assertTrue(op.iallocator is None)
    self.assertEqual(op.disks, [])

  def testNoDisks(self):
    handler = _CreateHandler(rlib2.R_2_instances_name_replace_disks,
                             ["inst20661"], {}, {}, self._clfactory)
    self.assertRaises(http.HttpBadRequest, handler.POST)

    for disks in [None, "", {}]:
      handler = _CreateHandler(rlib2.R_2_instances_name_replace_disks,
                               ["inst20661"], {}, {
        "disks": disks,
        }, self._clfactory)
      self.assertRaises(http.HttpBadRequest, handler.POST)

  def testWrong(self):
    data = {
      "mode": constants.REPLACE_DISK_AUTO,
      "disks": "hello world",
      }

    handler = _CreateHandler(rlib2.R_2_instances_name_replace_disks,
                             ["foo"], {}, data, self._clfactory)
    self.assertRaises(http.HttpBadRequest, handler.POST)


class TestGroupModify(RAPITestCase):
  def test(self):
    name = "group6002"

    for policy in constants.VALID_ALLOC_POLICIES:
      data = {
        "alloc_policy": policy,
        }

      op = self.getSubmittedOpcode(rlib2.R_2_groups_name_modify, [name], {},
                                   data, "PUT", opcodes.OpGroupSetParams)

      self.assertEqual(op.group_name, name)
      self.assertEqual(op.alloc_policy, policy)
      self.assertFalse(op.dry_run)

  def testUnknownPolicy(self):
    data = {
      "alloc_policy": "_unknown_policy_",
      }

    handler = _CreateHandler(rlib2.R_2_groups_name_modify, ["xyz"], {}, data,
                             self._clfactory)
    self.assertRaises(http.HttpBadRequest, handler.PUT)
    self.assertNoNextClient()

  def testDefaults(self):
    name = "group6679"

    op = self.getSubmittedOpcode(rlib2.R_2_groups_name_modify, [name], {}, {},
                                 "PUT", opcodes.OpGroupSetParams)

    self.assertEqual(op.group_name, name)
    self.assertTrue(op.alloc_policy is None)
    self.assertFalse(op.dry_run)

  def testCustomParamRename(self):
    name = "groupie"
    data = {
      "custom_diskparams": {},
      "custom_ipolicy": {},
      "custom_ndparams": {},
      }

    op = self.getSubmittedOpcode(rlib2.R_2_groups_name_modify, [name], {}, data,
                                 "PUT", opcodes.OpGroupSetParams)

    self.assertEqual(op.diskparams, {})
    self.assertEqual(op.ipolicy, {})
    self.assertEqual(op.ndparams, {})

    # Define both
    data["diskparams"] = {}
    assert "diskparams" in data and "custom_diskparams" in data
    handler = _CreateHandler(rlib2.R_2_groups_name_modify, [name], {}, data,
                             self._clfactory)
    self.assertRaises(http.HttpBadRequest, handler.PUT)


class TestGroupAdd(RAPITestCase):
  def test(self):
    name = "group3618"

    for policy in constants.VALID_ALLOC_POLICIES:
      data = {
        "group_name": name,
        "alloc_policy": policy,
        }

      op = self.getSubmittedOpcode(rlib2.R_2_groups, [], {}, data, "POST",
                                   opcodes.OpGroupAdd)

      self.assertEqual(op.group_name, name)
      self.assertEqual(op.alloc_policy, policy)
      self.assertFalse(op.dry_run)

  def testUnknownPolicy(self):
    data = {
      "alloc_policy": "_unknown_policy_",
      }

    handler = _CreateHandler(rlib2.R_2_groups, [], {}, data, self._clfactory)
    self.assertRaises(http.HttpBadRequest, handler.POST)
    self.assertNoNextClient()

  def testDefaults(self):
    name = "group15395"
    data = {
      "group_name": name,
      }

    op = self.getSubmittedOpcode(rlib2.R_2_groups, [], {}, data, "POST",
                                 opcodes.OpGroupAdd)

    self.assertEqual(op.group_name, name)
    self.assertTrue(op.alloc_policy is None)
    self.assertFalse(op.dry_run)

  def testLegacyName(self):
    name = "group29852"
    query_args = {
      "dry-run": ["1"],
      }
    data = {
      "name": name,
      }

    op = self.getSubmittedOpcode(rlib2.R_2_groups, [], query_args, data, "POST",
                                 opcodes.OpGroupAdd)

    self.assertEqual(op.group_name, name)
    self.assertTrue(op.alloc_policy is None)
    self.assertTrue(op.dry_run)


class TestNodeRole(RAPITestCase):
  def test(self):
    for role in rlib2._NR_MAP.values():
      handler = _CreateHandler(rlib2.R_2_nodes_name_role,
                               ["node-z"], {}, role, self._clfactory)
      if role == rlib2._NR_MASTER:
        self.assertRaises(http.HttpBadRequest, handler.PUT)
      else:
        job_id = handler.PUT()

        cl = self._clfactory.GetNextClient()
        self.assertNoNextClient()

        (exp_job_id, (op, )) = cl.GetNextSubmittedJob()
        self.assertEqual(job_id, exp_job_id)
        self.assertTrue(isinstance(op, opcodes.OpNodeSetParams))
        self.assertEqual(op.node_name, "node-z")
        self.assertFalse(op.force)
        self.assertFalse(op.dry_run)

        if role == rlib2._NR_REGULAR:
          self.assertFalse(op.drained)
          self.assertFalse(op.offline)
          self.assertFalse(op.master_candidate)
        elif role == rlib2._NR_MASTER_CANDIDATE:
          self.assertFalse(op.drained)
          self.assertFalse(op.offline)
          self.assertTrue(op.master_candidate)
        elif role == rlib2._NR_DRAINED:
          self.assertTrue(op.drained)
          self.assertFalse(op.offline)
          self.assertFalse(op.master_candidate)
        elif role == rlib2._NR_OFFLINE:
          self.assertFalse(op.drained)
          self.assertTrue(op.offline)
          self.assertFalse(op.master_candidate)
        else:
          self.fail("Unknown role '%s'" % role)

      self.assertRaises(IndexError, cl.GetNextSubmittedJob)


class TestSimpleResources(RAPITestCase):
  def tearDown(self):
    self.assertNoNextClient()

  def testFeatures(self):
    handler = _CreateHandler(rlib2.R_2_features, [], {}, None, self._clfactory)
    self.assertEqual(set(handler.GET()), rlib2.ALL_FEATURES)

  def testEmpty(self):
    for cls in [rlib2.R_root, rlib2.R_2]:
      handler = _CreateHandler(cls, [], {}, None, self._clfactory)
      self.assertTrue(handler.GET() is None)

  def testVersion(self):
    handler = _CreateHandler(rlib2.R_version, [], {}, None, self._clfactory)
    self.assertEqual(handler.GET(), constants.RAPI_VERSION)


class TestClusterInfo(unittest.TestCase):
  class _ClusterInfoClient:
    def __init__(self, address=None):
      self.cluster_info = None

    def QueryClusterInfo(self):
      assert self.cluster_info is None
      self.cluster_info = {}
      return self.cluster_info

  def test(self):
    clfactory = _FakeClientFactory(self._ClusterInfoClient)
    handler = _CreateHandler(rlib2.R_2_info, [], {}, None, clfactory)
    result = handler.GET()
    cl = clfactory.GetNextClient()
    self.assertRaises(IndexError, clfactory.GetNextClient)
    self.assertEqual(result, cl.cluster_info)


class TestInstancesMultiAlloc(unittest.TestCase):
  def testInstanceUpdate(self):
    clfactory = _FakeClientFactory(_FakeClient)
    data = {
      "instances": [{
        "name": "bar",
        "mode": "create",
        "disks": [{"size": 1024}],
        "disk_template": "plain",
        "nics": [{}],
        }, {
        "name": "foo",
        "mode": "create",
        "disks": [{"size": 1024}],
        "disk_template": "drbd",
        "nics": [{}],
        }],
      }
    handler = _CreateHandler(rlib2.R_2_instances_multi_alloc, [], {}, data,
                             clfactory)

    (body, _) = handler.GetPostOpInput()

    self.assertTrue(compat.all(
      [isinstance(inst, opcodes.OpInstanceCreate) for inst in body["instances"]]
    ))


class TestPermissions(unittest.TestCase):
  def testEquality(self):
    self.assertEqual(rlib2.R_2_query.GET_ACCESS, rlib2.R_2_query.PUT_ACCESS)
    self.assertEqual(rlib2.R_2_query.GET_ACCESS,
                     rlib2.R_2_instances_name_console.GET_ACCESS)

  def testMethodAccess(self):
    for handler in connector.CONNECTOR.values():
      for method in baserlib._SUPPORTED_METHODS:
        access = baserlib.GetHandlerAccess(handler, method)
        self.assertFalse(access is None)
        self.assertFalse(set(access) - rapi.RAPI_ACCESS_ALL,
                         msg=("Handler '%s' uses unknown access options for"
                              " method %s" % (handler, method)))
        self.assertTrue(rapi.RAPI_ACCESS_READ not in access or
                        rapi.RAPI_ACCESS_WRITE in access,
                        msg=("Handler '%s' gives query, but not write access"
                             " for method %s (the latter includes query and"
                             " should therefore be given as well)" %
                             (handler, method)))


class ForbiddenOpcode(opcodes.OpCode):
  OP_PARAMS = [
    ("obligatory", None, ht.TString, None),
    ("forbidden", None, ht.TMaybe(ht.TString), None),
    ("forbidden_true", None, ht.TMaybe(ht.TBool), None),
    ]


class ForbiddenRAPI(baserlib.OpcodeResource):
  POST_OPCODE = ForbiddenOpcode
  POST_FORBIDDEN = [
    "forbidden",
    ("forbidden_true", [True]),
  ]
  POST_RENAME = {
    "totally_not_forbidden": "forbidden"
  }


class TestForbiddenParams(RAPITestCase):
  def testTestOpcode(self):
    obligatory_value = "a"
    forbidden_value = "b"
    forbidden_true_value = True
    op = ForbiddenOpcode(
      obligatory=obligatory_value,
      forbidden=forbidden_value,
      forbidden_true=forbidden_true_value
    )
    self.assertEqualValues(op.obligatory, obligatory_value)
    self.assertEqualValues(op.forbidden, forbidden_value)
    self.assertEqualValues(op.forbidden_true, forbidden_true_value)

  def testCorrectRequest(self):
    value = "o"
    op = self.getSubmittedOpcode(ForbiddenRAPI, [], {}, {"obligatory": value},
                                 "POST", ForbiddenOpcode)
    self.assertEqual(op.obligatory, value)

  def testValueForbidden(self):
    value = "o"
    data = {
      "obligatory": value,
      "forbidden": value,
    }
    handler = _CreateHandler(ForbiddenRAPI, [], {}, data, self._clfactory)
    self.assertRaises(http.HttpForbidden, handler.POST)

  def testSpecificValueForbidden(self):
    for value in [True, False, "True"]:
      data = {
        "obligatory": "o",
        "forbidden_true": value,
      }
      handler = _CreateHandler(ForbiddenRAPI, [], {}, data, self._clfactory)

      if value == True:
        self.assertRaises(http.HttpForbidden, handler.POST)
      elif value == "True":
        self.assertRaises(http.HttpBadRequest, handler.POST)
      else:
        handler.POST()
        cl = self._clfactory.GetNextClient()
        (_, (op, )) = cl.GetNextSubmittedJob()
        self.assertTrue(isinstance(op, ForbiddenOpcode))
        self.assertEqual(op.forbidden_true, value)

  def testRenameIntoForbidden(self):
    data = {
      "obligatory": "o",
      "totally_not_forbidden": "o",
    }
    handler = _CreateHandler(ForbiddenRAPI, [], {}, data, self._clfactory)
    self.assertRaises(http.HttpForbidden, handler.POST)

if __name__ == "__main__":
  testutils.GanetiTestProgram()