# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
#         http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.

import copy
import io
import subprocess
from unittest import mock

from openstack import exceptions as sdk_exc
from osc_lib import exceptions as exc

from senlinclient.common import utils as senlin_utils
from senlinclient.tests.unit.v1 import fakes
from senlinclient.v1 import cluster as osc_cluster


class TestCluster(fakes.TestClusteringv1):
    def setUp(self):
        super(TestCluster, self).setUp()
        self.mock_client = self.app.client_manager.clustering


class TestClusterList(TestCluster):

    columns = ['id', 'name', 'status', 'created_at', 'updated_at']
    defaults = {
        'global_project': False,
        'marker': None,
        'limit': None,
        'sort': None,
    }

    def setUp(self):
        super(TestClusterList, self).setUp()
        self.cmd = osc_cluster.ListCluster(self.app, None)
        fake_cluster = mock.Mock(
            created_at="2015-02-10T14:26:14",
            data={},
            desired_capacity=4,
            domain_id=None,
            id="7d85f602-a948-4a30-afd4-e84f47471c15",
            init_time="2015-02-10T14:26:11",
            max_size=-1,
            metadata={},
            min_size=0,
            node_ids=[
                "b07c57c8-7ab2-47bf-bdf8-e894c0c601b9",
                "ecc23d3e-bb68-48f8-8260-c9cf6bcb6e61",
                "da1e9c87-e584-4626-a120-022da5062dac"
            ],
            policies=[],
            profile_id="edc63d0a-2ca4-48fa-9854-27926da76a4a",
            profile_name="mystack",
            project_id="6e18cc2bdbeb48a5b3cad2dc499f6804",
            status="ACTIVE",
            status_reason="Cluster scale-in succeeded",
            timeout=3600,
            updated_at=None,
            user_id="5e5bf8027826429c96af157f68dc9072"
        )
        fake_cluster.name = "cluster1"
        fake_cluster.to_dict = mock.Mock(return_value={})

        self.mock_client.clusters = mock.Mock(return_value=[fake_cluster])

    def test_cluster_list_defaults(self):
        arglist = []
        parsed_args = self.check_parser(self.cmd, arglist, [])
        columns, data = self.cmd.take_action(parsed_args)
        self.mock_client.clusters.assert_called_with(**self.defaults)
        self.assertEqual(self.columns, columns)

    def test_cluster_list_full_id(self):
        arglist = ['--full-id']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        columns, data = self.cmd.take_action(parsed_args)
        self.mock_client.clusters.assert_called_with(**self.defaults)
        self.assertEqual(self.columns, columns)

    def test_cluster_list_limit(self):
        kwargs = copy.deepcopy(self.defaults)
        kwargs['limit'] = '3'
        arglist = ['--limit', '3']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        columns, data = self.cmd.take_action(parsed_args)
        self.mock_client.clusters.assert_called_with(**kwargs)
        self.assertEqual(self.columns, columns)

    def test_cluster_list_sort(self):
        kwargs = copy.deepcopy(self.defaults)
        kwargs['sort'] = 'name:asc'
        arglist = ['--sort', 'name:asc']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        columns, data = self.cmd.take_action(parsed_args)
        self.mock_client.clusters.assert_called_with(**kwargs)
        self.assertEqual(self.columns, columns)

    def test_cluster_list_sort_invalid_key(self):
        kwargs = copy.deepcopy(self.defaults)
        kwargs['sort'] = 'bad_key'
        arglist = ['--sort', 'bad_key']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.mock_client.clusters.side_effect = sdk_exc.HttpException()
        self.assertRaises(sdk_exc.HttpException,
                          self.cmd.take_action, parsed_args)

    def test_cluster_list_sort_invalid_direction(self):
        kwargs = copy.deepcopy(self.defaults)
        kwargs['sort'] = 'name:bad_direction'
        arglist = ['--sort', 'name:bad_direction']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.mock_client.clusters.side_effect = sdk_exc.HttpException()
        self.assertRaises(sdk_exc.HttpException,
                          self.cmd.take_action, parsed_args)

    def test_cluster_list_filter(self):
        kwargs = copy.deepcopy(self.defaults)
        kwargs['name'] = 'my_cluster'
        arglist = ['--filter', 'name=my_cluster']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        columns, data = self.cmd.take_action(parsed_args)
        self.mock_client.clusters.assert_called_with(**kwargs)
        self.assertEqual(self.columns, columns)

    def test_cluster_list_marker(self):
        kwargs = copy.deepcopy(self.defaults)
        kwargs['marker'] = 'a9448bf6'
        arglist = ['--marker', 'a9448bf6']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        columns, data = self.cmd.take_action(parsed_args)
        self.mock_client.clusters.assert_called_with(**kwargs)
        self.assertEqual(self.columns, columns)


class TestClusterShow(TestCluster):

    def setUp(self):
        super(TestClusterShow, self).setUp()
        self.cmd = osc_cluster.ShowCluster(self.app, None)
        fake_cluster = mock.Mock(
            config={},
            created_at="2015-02-11T15:13:20",
            data={},
            desired_capacity=0,
            domain_id=None,
            id="7d85f602-a948-4a30-afd4-e84f47471c15",
            init_time="2015-02-10T14:26:11",
            max_size=-1,
            metadata={},
            min_size=0,
            node_ids=[],
            policies=[],
            profile_id="edc63d0a-2ca4-48fa-9854-27926da76a4a",
            profile_name="mystack",
            project_id="6e18cc2bdbeb48a5b3cad2dc499f6804",
            status="ACTIVE",
            status_reason="Cluster scale-in succeeded",
            timeout=3600,
            updated_at=None,
            user_id="5e5bf8027826429c96af157f68dc9072"
        )
        fake_cluster.name = "my_cluster"
        fake_cluster.to_dict = mock.Mock(return_value={})
        self.mock_client.get_cluster = mock.Mock(return_value=fake_cluster)

    def test_cluster_show(self):
        arglist = ['my_cluster']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        self.mock_client.get_cluster.assert_called_with('my_cluster')

    def test_cluster_show_not_found(self):
        arglist = ['my_cluster']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.mock_client.get_cluster.side_effect = sdk_exc.ResourceNotFound()
        error = self.assertRaises(exc.CommandError, self.cmd.take_action,
                                  parsed_args)
        self.assertEqual('Cluster not found: my_cluster', str(error))


class TestClusterCreate(TestCluster):

    defaults = {
        "config": {},
        "desired_capacity": 0,
        "max_size": -1,
        "metadata": {},
        "min_size": 0,
        "name": "test_cluster",
        "profile_id": "mystack",
        "timeout": None
    }

    def setUp(self):
        super(TestClusterCreate, self).setUp()
        self.cmd = osc_cluster.CreateCluster(self.app, None)
        self.cluster_id = '7d85f602-a948-4a30-afd4-e84f47471c15'
        fake_cluster = mock.Mock(
            config={},
            created_at="2015-02-11T15:13:20",
            data={},
            desired_capacity=0,
            domain_id=None,
            id=self.cluster_id,
            init_time="2015-02-10T14:26:11",
            max_size=-1,
            metadata={},
            min_size=0,
            node_ids=[],
            policies=[],
            profile_id="edc63d0a-2ca4-48fa-9854-27926da76a4a",
            profile_name="mystack",
            project_id="6e18cc2bdbeb48a5b3cad2dc499f6804",
            status="ACTIVE",
            status_reason="Cluster scale-in succeeded",
            timeout=3600,
            updated_at=None,
            user_id="5e5bf8027826429c96af157f68dc9072"
        )
        fake_cluster.name = "my_cluster"
        fake_cluster.to_dict = mock.Mock(return_value={})
        self.mock_client.create_cluster = mock.Mock(return_value=fake_cluster)
        self.mock_client.get_cluster = mock.Mock(return_value=fake_cluster)

    def test_cluster_create_defaults(self):
        arglist = ['test_cluster', '--profile', 'mystack']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        self.mock_client.create_cluster.assert_called_with(**self.defaults)

    def test_cluster_create_with_metadata(self):
        arglist = ['test_cluster', '--profile', 'mystack',
                   '--metadata', 'key1=value1;key2=value2']
        kwargs = copy.deepcopy(self.defaults)
        kwargs['metadata'] = {'key1': 'value1', 'key2': 'value2'}
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        self.mock_client.create_cluster.assert_called_with(**kwargs)

    def test_cluster_create_with_config(self):
        arglist = ['test_cluster', '--profile', 'mystack',
                   '--config', 'key1=value1;key2=value2']
        kwargs = copy.deepcopy(self.defaults)
        kwargs['config'] = {'key1': 'value1', 'key2': 'value2'}
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        self.mock_client.create_cluster.assert_called_with(**kwargs)

    def test_cluster_create_with_size(self):
        arglist = ['test_cluster', '--profile', 'mystack',
                   '--min-size', '1', '--max-size', '10',
                   '--desired-capacity', '2']
        kwargs = copy.deepcopy(self.defaults)
        kwargs['min_size'] = '1'
        kwargs['max_size'] = '10'
        kwargs['desired_capacity'] = '2'
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        self.mock_client.create_cluster.assert_called_with(**kwargs)

    @mock.patch.object(senlin_utils, 'await_cluster_status')
    def test_cluster_create_with_wait(self, mock_await):
        arglist = ['test_cluster', '--profile', 'mystack',
                   '--min-size', '1', '--max-size', '10',
                   '--desired-capacity', '2', '--wait']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        mock_await.assert_called_once_with(self.mock_client, self.cluster_id)

    @mock.patch.object(senlin_utils, 'await_cluster_status')
    def test_cluster_create_without_wait(self, mock_await):
        arglist = ['test_cluster', '--profile', 'mystack',
                   '--min-size', '1', '--max-size', '10',
                   '--desired-capacity', '2']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        mock_await.assert_not_called()


class TestClusterUpdate(TestCluster):

    defaults = {
        "metadata": {
            "nk1": "nv1",
            "nk2": "nv2",
        },
        "config": {
            "cluster.stop_node_before_delete": "true",
        },
        "name": 'new_cluster',
        "profile_id": 'new_profile',
        "profile_only": False,
        "timeout": "30"
    }

    def setUp(self):
        super(TestClusterUpdate, self).setUp()
        self.cmd = osc_cluster.UpdateCluster(self.app, None)
        self.fake_cluster = mock.Mock(
            created_at="2015-02-11T15:13:20",
            data={},
            desired_capacity=0,
            domain_id=None,
            id="7d85f602-a948-4a30-afd4-e84f47471c15",
            init_time="2015-02-10T14:26:11",
            max_size=-1,
            metadata={},
            min_size=0,
            node_ids=[],
            policies=[],
            profile_id="edc63d0a-2ca4-48fa-9854-27926da76a4a",
            profile_name="mystack",
            project_id="6e18cc2bdbeb48a5b3cad2dc499f6804",
            status="ACTIVE",
            status_reason="Cluster scale-in succeeded",
            timeout=3600,
            updated_at=None,
            user_id="5e5bf8027826429c96af157f68dc9072"
        )
        self.fake_cluster.name = "my_cluster"
        self.fake_cluster.to_dict = mock.Mock(return_value={})
        self.mock_client.update_cluster = mock.Mock(
            return_value=self.fake_cluster)
        self.mock_client.get_cluster = mock.Mock(
            return_value=self.fake_cluster)
        self.mock_client.find_cluster = mock.Mock(
            return_value=self.fake_cluster)

    def test_cluster_update_defaults(self):
        arglist = ['--name', 'new_cluster', '--metadata', 'nk1=nv1;nk2=nv2',
                   '--config', 'cluster.stop_node_before_delete=true',
                   '--profile', 'new_profile', '--timeout', '30', '45edadcb']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        self.mock_client.update_cluster.assert_called_with(
            self.fake_cluster, **self.defaults)

    def test_cluster_update_not_found(self):
        arglist = ['--name', 'new_cluster', '--metadata', 'nk1=nv1;nk2=nv2',
                   '--profile', 'new_profile', 'c6b8b252']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.mock_client.find_cluster.return_value = None
        error = self.assertRaises(exc.CommandError,
                                  self.cmd.take_action,
                                  parsed_args)
        self.assertIn('Cluster not found: c6b8b252', str(error))

    @mock.patch.object(senlin_utils, 'await_cluster_status')
    def test_cluster_update_with_wait(self, mock_await):
        arglist = ['--name', 'new_cluster', '--metadata', 'nk1=nv1;nk2=nv2',
                   '--profile', 'new_profile', '--timeout', '30', '45edadcb',
                   '--wait']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        mock_await.assert_called_once_with(self.mock_client,
                                           self.fake_cluster.id)

    @mock.patch.object(senlin_utils, 'await_cluster_status')
    def test_cluster_update_without_wait(self, mock_await):
        arglist = ['--name', 'new_cluster', '--metadata', 'nk1=nv1;nk2=nv2',
                   '--profile', 'new_profile', '--timeout', '30', '45edadcb']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        mock_await.assert_not_called()


class TestClusterDelete(TestCluster):
    def setUp(self):
        super(TestClusterDelete, self).setUp()
        self.cmd = osc_cluster.DeleteCluster(self.app, None)
        mock_cluster = mock.Mock(location='abc/fake_action_id')
        self.mock_client.delete_cluster = mock.Mock(return_value=mock_cluster)

    def test_cluster_delete(self):
        arglist = ['cluster1', 'cluster2', 'cluster3']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        self.mock_client.delete_cluster.assert_has_calls(
            [mock.call('cluster1', False, False),
             mock.call('cluster2', False, False),
             mock.call('cluster3', False, False)]
        )

    def test_cluster_delete_force(self):
        arglist = ['cluster1', 'cluster2', 'cluster3', '--force']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        self.mock_client.delete_cluster.assert_has_calls(
            [mock.call('cluster1', False, False),
             mock.call('cluster2', False, False),
             mock.call('cluster3', False, False)]
        )

    def test_cluster_delete_force_delete(self):
        arglist = ['cluster1', 'cluster2', 'cluster3', '--force-delete']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        self.mock_client.delete_cluster.assert_has_calls(
            [mock.call('cluster1', False, True),
             mock.call('cluster2', False, True),
             mock.call('cluster3', False, True)]
        )

    def test_cluster_delete_not_found(self):
        arglist = ['my_cluster']
        self.mock_client.delete_cluster.side_effect = sdk_exc.ResourceNotFound
        parsed_args = self.check_parser(self.cmd, arglist, [])

        self.cmd.take_action(parsed_args)

        self.mock_client.delete_cluster.assert_has_calls(
            [mock.call('my_cluster', False, False)]
        )

    def test_cluster_delete_one_found_one_not_found(self):
        arglist = ['cluster1', 'cluster2']
        self.mock_client.delete_cluster.side_effect = (
            [None, sdk_exc.ResourceNotFound]
        )
        parsed_args = self.check_parser(self.cmd, arglist, [])

        self.cmd.take_action(parsed_args)

        self.mock_client.delete_cluster.assert_has_calls(
            [mock.call('cluster1', False, False),
             mock.call('cluster2', False, False)]
        )

    @mock.patch('sys.stdin', spec=io.StringIO)
    def test_cluster_delete_prompt_yes(self, mock_stdin):
        arglist = ['my_cluster']
        mock_stdin.isatty.return_value = True
        mock_stdin.readline.return_value = 'y'
        parsed_args = self.check_parser(self.cmd, arglist, [])

        self.cmd.take_action(parsed_args)

        mock_stdin.readline.assert_called_with()
        self.mock_client.delete_cluster.assert_called_with(
            'my_cluster', False, False)

    @mock.patch('sys.stdin', spec=io.StringIO)
    def test_cluster_delete_prompt_no(self, mock_stdin):
        arglist = ['my_cluster']
        mock_stdin.isatty.return_value = True
        mock_stdin.readline.return_value = 'n'
        parsed_args = self.check_parser(self.cmd, arglist, [])

        self.cmd.take_action(parsed_args)

        mock_stdin.readline.assert_called_with()
        self.mock_client.delete_cluster.assert_not_called()

    @mock.patch.object(senlin_utils, 'await_action')
    @mock.patch.object(senlin_utils, 'await_cluster_delete')
    def test_cluster_delete_with_wait(self, mock_await_cluster,
                                      mock_await_action):
        fake_action = {'id': 'fake-action-id'}
        self.mock_client.delete_cluster = mock.Mock(return_value=fake_action)
        arglist = ['my_cluster', '--force', '--wait']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        mock_await_action.assert_called_once_with(self.mock_client,
                                                  fake_action['id'])
        mock_await_cluster.assert_called_once_with(self.mock_client,
                                                   'my_cluster')

    @mock.patch.object(senlin_utils, 'await_action')
    @mock.patch.object(senlin_utils, 'await_cluster_delete')
    def test_cluster_delete_without_wait(self, mock_await_cluster,
                                         mock_await_action):
        fake_action = {'id': 'fake-action-id'}
        self.mock_client.delete_cluster = mock.Mock(return_value=fake_action)
        arglist = ['my_cluster', '--force']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        mock_await_action.assert_not_called()
        mock_await_cluster.assert_not_called()

    @mock.patch.object(senlin_utils, 'await_action')
    @mock.patch.object(senlin_utils, 'await_cluster_delete')
    def test_cluster_delete_with_wait_bad_action(self, mock_await_cluster,
                                                 mock_await_action):
        self.mock_client.delete_cluster.side_effect = (
            Exception('test exception')
        )
        arglist = ['my_cluster', '--force', '--wait']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        mock_await_action.assert_not_called()
        mock_await_cluster.assert_not_called()


class TestClusterResize(TestCluster):
    response = {"action": "8bb476c3-0f4c-44ee-9f64-c7b0260814de"}
    defaults = {
        "min_step": None,
        "adjustment_type": "EXACT_CAPACITY",
        "number": 2,
        "min_size": 1,
        "strict": True,
        "max_size": 20}

    def setUp(self):
        super(TestClusterResize, self).setUp()
        self.cmd = osc_cluster.ResizeCluster(self.app, None)
        self.mock_client.resize_cluster = mock.Mock(
            return_value=self.response)

    def test_cluster_resize_no_params(self):
        arglist = ['my_cluster']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        error = self.assertRaises(exc.CommandError,
                                  self.cmd.take_action,
                                  parsed_args)
        self.assertEqual(("At least one parameter of 'capacity', "
                          "'adjustment', 'percentage', 'min_size' and "
                          "'max_size' should be specified."), str(error))

    def test_cluster_resize_multi_params(self):
        arglist = ['--capacity', '2', '--percentage', '50.0', '--adjustment',
                   '1', '--min-size', '1', '--max-size', '20', 'my_cluster']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        error = self.assertRaises(exc.CommandError,
                                  self.cmd.take_action,
                                  parsed_args)
        self.assertEqual("Only one of 'capacity', 'adjustment' "
                         "and 'percentage' can be specified.", str(error))

    def test_cluster_resize_capacity(self):
        arglist = ['--capacity', '2', '--min-size', '1', '--max-size', '20',
                   'my_cluster', '--strict']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        self.mock_client.resize_cluster.assert_called_with('my_cluster',
                                                           **self.defaults)

    def test_cluster_resize_invalid_capacity(self):
        arglist = ['--capacity', '-1', '--min-size', '1', '--max-size', '20',
                   'my_cluster', '--strict']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        error = self.assertRaises(exc.CommandError,
                                  self.cmd.take_action,
                                  parsed_args)
        self.assertEqual('Cluster capacity must be larger than or equal to'
                         ' zero.', str(error))

    def test_cluster_resize_adjustment(self):
        arglist = ['--adjustment', '1', '--min-size', '1', '--max-size', '20',
                   'my_cluster', '--strict']
        kwargs = copy.deepcopy(self.defaults)
        kwargs['adjustment_type'] = 'CHANGE_IN_CAPACITY'
        kwargs['number'] = 1
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        self.mock_client.resize_cluster.assert_called_with('my_cluster',
                                                           **kwargs)

    def test_cluster_resize_invalid_adjustment(self):
        arglist = ['--adjustment', '0', '--min-size', '1', '--max-size', '20',
                   'my_cluster', '--strict']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        error = self.assertRaises(exc.CommandError,
                                  self.cmd.take_action,
                                  parsed_args)
        self.assertEqual('Adjustment cannot be zero.', str(error))

    def test_cluster_resize_percentage(self):
        arglist = ['--percentage', '50.0', '--min-size', '1', '--max-size',
                   '20', 'my_cluster', '--strict']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        kwargs = copy.deepcopy(self.defaults)
        kwargs['adjustment_type'] = 'CHANGE_IN_PERCENTAGE'
        kwargs['number'] = 50.0
        self.cmd.take_action(parsed_args)
        self.mock_client.resize_cluster.assert_called_with('my_cluster',
                                                           **kwargs)

    def test_cluster_resize_invalid_percentage(self):
        arglist = ['--percentage', '0', '--min-size', '1', '--max-size', '20',
                   'my_cluster', '--strict']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        error = self.assertRaises(exc.CommandError,
                                  self.cmd.take_action,
                                  parsed_args)
        self.assertEqual('Percentage cannot be zero.', str(error))

    def test_cluster_resize_invalid_min_step_capacity(self):
        arglist = ['--capacity', '2', '--min-size', '1', '--max-size', '20',
                   'my_cluster', '--strict', '--min-step', '1']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        error = self.assertRaises(exc.CommandError,
                                  self.cmd.take_action,
                                  parsed_args)
        self.assertEqual('Min step is only used with percentage.', str(error))

    def test_cluster_resize_invalid_min_size_capacity(self):
        arglist = ['--capacity', '2', '--min-size', '-1', '--max-size', '20',
                   'my_cluster', '--strict']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        error = self.assertRaises(exc.CommandError,
                                  self.cmd.take_action,
                                  parsed_args)
        self.assertEqual('Min size cannot be less than zero.', str(error))

    def test_cluster_resize_invalid_max_size_capacity(self):
        arglist = ['--capacity', '2', '--min-size', '5', '--max-size', '3',
                   'my_cluster', '--strict']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        error = self.assertRaises(exc.CommandError,
                                  self.cmd.take_action,
                                  parsed_args)
        self.assertEqual('Min size cannot be larger than max size.',
                         str(error))

    def test_cluster_resize_min_size_larger_than_capacity(self):
        arglist = ['--capacity', '3', '--min-size', '5', '--max-size', '10',
                   'my_cluster', '--strict']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        error = self.assertRaises(exc.CommandError,
                                  self.cmd.take_action,
                                  parsed_args)
        self.assertEqual('Min size cannot be larger than the specified '
                         'capacity', str(error))

    def test_cluster_resize_invalid_max_size_less_capacity(self):
        arglist = ['--capacity', '15', '--min-size', '5', '--max-size', '10',
                   'my_cluster', '--strict']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        error = self.assertRaises(exc.CommandError,
                                  self.cmd.take_action,
                                  parsed_args)
        self.assertEqual('Max size cannot be less than the specified '
                         'capacity.', str(error))

    @mock.patch.object(osc_cluster, '_show_cluster')
    @mock.patch.object(senlin_utils, 'await_action')
    @mock.patch.object(senlin_utils, 'await_cluster_status')
    def test_cluster_resize_with_wait(self, mock_await_status,
                                      mock_await_action, mock_show):
        arglist = ['--capacity', '2', 'my_cluster', "--wait"]
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        mock_await_action.assert_called_once_with(self.mock_client,
                                                  self.response['action'])
        mock_await_status.assert_called_once_with(self.mock_client,
                                                  'my_cluster')
        mock_show.assert_called_once()

    @mock.patch.object(osc_cluster, '_show_cluster')
    @mock.patch.object(senlin_utils, 'await_action')
    @mock.patch.object(senlin_utils, 'await_cluster_status')
    def test_cluster_resize_without_wait(self, mock_await_status,
                                         mock_await_action, mock_show):
        arglist = ['--capacity', '2', 'my_cluster']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        mock_await_action.assert_not_called()
        mock_await_status.assert_not_called()
        mock_show.assert_not_called()

    @mock.patch.object(osc_cluster, '_show_cluster')
    @mock.patch.object(senlin_utils, 'await_action')
    @mock.patch.object(senlin_utils, 'await_cluster_status')
    def test_cluster_resize_with_wait_no_action(self, mock_await_status,
                                                mock_await_action, mock_show):
        error = 'test error'
        self.mock_client.resize_cluster = mock.Mock(return_value=error)
        arglist = ['--capacity', '2', 'my_cluster', '--wait']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        mock_await_action.assert_not_called()
        mock_await_status.assert_not_called()
        mock_show.assert_not_called()


class TestClusterScaleIn(TestCluster):
    response = {"action": "8bb476c3-0f4c-44ee-9f64-c7b0260814de"}

    def setUp(self):
        super(TestClusterScaleIn, self).setUp()
        self.cmd = osc_cluster.ScaleInCluster(self.app, None)
        self.mock_client.scale_in_cluster = mock.Mock(
            return_value=self.response)

    def test_cluster_scale_in(self):
        arglist = ['--count', '2', 'my_cluster']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        self.mock_client.scale_in_cluster.assert_called_with('my_cluster',
                                                             '2')

    @mock.patch.object(osc_cluster, '_show_cluster')
    @mock.patch.object(senlin_utils, 'await_action')
    @mock.patch.object(senlin_utils, 'await_cluster_status')
    def test_cluster_scale_in_with_wait(self, mock_await_status,
                                        mock_await_action, mock_show):
        arglist = ['--count', '2', 'my_cluster', '--wait']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        mock_await_action.assert_called_once_with(self.mock_client,
                                                  self.response['action'])
        mock_await_status.assert_called_once_with(self.mock_client,
                                                  'my_cluster')
        mock_show.assert_called_once()

    @mock.patch.object(osc_cluster, '_show_cluster')
    @mock.patch.object(senlin_utils, 'await_action')
    @mock.patch.object(senlin_utils, 'await_cluster_status')
    def test_cluster_scale_in_without_wait(self, mock_await_status,
                                           mock_await_action, mock_show):
        arglist = ['--count', '2', 'my_cluster']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        mock_await_action.assert_not_called()
        mock_await_status.assert_not_called()
        mock_show.assert_not_called()

    @mock.patch.object(osc_cluster, '_show_cluster')
    @mock.patch.object(senlin_utils, 'await_action')
    @mock.patch.object(senlin_utils, 'await_cluster_status')
    def test_cluster_scale_in_with_wait_no_action(self, mock_await_status,
                                                  mock_await_action,
                                                  mock_show):
        arglist = ['--count', '2', 'my_cluster', '--wait']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        error = {'error': 'test-error'}
        self.mock_client.scale_in_cluster = mock.Mock(return_value=error)

        self.cmd.take_action(parsed_args)
        mock_await_action.assert_not_called()
        mock_await_status.assert_not_called()
        mock_show.assert_not_called()


class TestClusterScaleOut(TestCluster):
    response = {"action": "8bb476c3-0f4c-44ee-9f64-c7b0260814de"}

    def setUp(self):
        super(TestClusterScaleOut, self).setUp()
        self.cmd = osc_cluster.ScaleOutCluster(self.app, None)
        self.mock_client.scale_out_cluster = mock.Mock(
            return_value=self.response)

    def test_cluster_scale_out(self):
        arglist = ['--count', '2', 'my_cluster']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        self.mock_client.scale_out_cluster.assert_called_with('my_cluster',
                                                              '2')

    @mock.patch.object(osc_cluster, '_show_cluster')
    @mock.patch.object(senlin_utils, 'await_action')
    @mock.patch.object(senlin_utils, 'await_cluster_status')
    def test_cluster_scale_out_with_wait(self, mock_await_status,
                                         mock_await_action, mock_show):
        arglist = ['--count', '2', 'my_cluster', '--wait']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        mock_await_action.assert_called_once_with(self.mock_client,
                                                  self.response['action'])
        mock_await_status.assert_called_once_with(self.mock_client,
                                                  'my_cluster')
        mock_show.assert_called_once()

    @mock.patch.object(osc_cluster, '_show_cluster')
    @mock.patch.object(senlin_utils, 'await_action')
    @mock.patch.object(senlin_utils, 'await_cluster_status')
    def test_cluster_scale_out_without_wait(self, mock_await_status,
                                            mock_await_action, mock_show):
        arglist = ['--count', '2', 'my_cluster']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        mock_await_action.assert_not_called()
        mock_await_status.assert_not_called()
        mock_show.assert_not_called()

    @mock.patch.object(osc_cluster, '_show_cluster')
    @mock.patch.object(senlin_utils, 'await_action')
    @mock.patch.object(senlin_utils, 'await_cluster_status')
    def test_cluster_scale_out_with_wait_no_action(self, mock_await_status,
                                                   mock_await_action,
                                                   mock_show):
        arglist = ['--count', '2', 'my_cluster', '--wait']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        error = {'error': 'test-error'}
        self.mock_client.scale_out_cluster = mock.Mock(return_value=error)

        self.cmd.take_action(parsed_args)
        mock_await_action.assert_not_called()
        mock_await_status.assert_not_called()
        mock_show.assert_not_called()


class TestClusterPolicyAttach(TestCluster):
    response = {"action": "8bb476c3-0f4c-44ee-9f64-c7b0260814de"}

    def setUp(self):
        super(TestClusterPolicyAttach, self).setUp()
        self.cmd = osc_cluster.ClusterPolicyAttach(self.app, None)
        self.mock_client.attach_policy_to_cluster = mock.Mock(
            return_value=self.response)

    def test_cluster_policy_attach(self):
        arglist = ['--policy', 'my_policy', '--enabled', 'True', 'my_cluster']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        self.mock_client.attach_policy_to_cluster.assert_called_with(
            'my_cluster',
            'my_policy',
            enabled=True)

    @mock.patch.object(senlin_utils, 'await_action')
    def test_cluster_policy_attach_with_wait(self, mock_await_action):
        arglist = ['--policy', 'my_policy', 'my_cluster', '--wait']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        mock_await_action.assert_called_once_with(self.mock_client,
                                                  self.response['action'])

    @mock.patch.object(senlin_utils, 'await_action')
    def test_cluster_policy_attach_without_wait(self, mock_await_action):
        arglist = ['--policy', 'my_policy', 'my_cluster']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        mock_await_action.assert_not_called()

    @mock.patch.object(senlin_utils, 'await_action')
    def test_cluster_policy_attach_with_wait_no_action(self,
                                                       mock_await_action):
        arglist = ['--policy', 'my_policy', 'my_cluster', '--wait']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        error = {'error': 'test-error'}
        self.mock_client.attach_policy_to_cluster = \
            mock.Mock(return_value=error)
        self.cmd.take_action(parsed_args)
        mock_await_action.assert_not_called()


class TestClusterPolicyDetach(TestCluster):
    response = {"action": "8bb476c3-0f4c-44ee-9f64-c7b0260814de"}

    def setUp(self):
        super(TestClusterPolicyDetach, self).setUp()
        self.cmd = osc_cluster.ClusterPolicyDetach(self.app, None)
        self.mock_client.detach_policy_from_cluster = mock.Mock(
            return_value=self.response)

    def test_cluster_policy_detach(self):
        arglist = ['--policy', 'my_policy', 'my_cluster']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        self.mock_client.detach_policy_from_cluster.assert_called_with(
            'my_cluster',
            'my_policy')

    @mock.patch.object(senlin_utils, 'await_action')
    def test_cluster_policy_dettach_with_wait(self, mock_await_action):
        arglist = ['--policy', 'my_policy', 'my_cluster', '--wait']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        mock_await_action.assert_called_once_with(self.mock_client,
                                                  self.response['action'])

    @mock.patch.object(senlin_utils, 'await_action')
    def test_cluster_policy_dettach_without_wait(self, mock_await_action):
        arglist = ['--policy', 'my_policy', 'my_cluster']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        mock_await_action.assert_not_called()

    @mock.patch.object(senlin_utils, 'await_action')
    def test_cluster_policy_dettach_with_wait_no_action(self,
                                                        mock_await_action):
        arglist = ['--policy', 'my_policy', 'my_cluster', '--wait']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        error = {'error': 'test-error'}
        self.mock_client.detach_policy_from_cluster = \
            mock.Mock(return_value=error)
        self.cmd.take_action(parsed_args)
        mock_await_action.assert_not_called()


class TestClusterNodeList(TestCluster):
    columns = ['id', 'name', 'index', 'status', 'physical_id', 'created_at']
    args = {
        'cluster_id': 'my_cluster',
        'marker': 'a9448bf6',
        'limit': '3',
        'sort': None,
    }

    def setUp(self):
        super(TestClusterNodeList, self).setUp()
        self.cmd = osc_cluster.ClusterNodeList(self.app, None)
        fake_node = mock.Mock(
            cluster_id="",
            created_at="2015-02-11T15:13:20",
            data={},
            details={},
            domain_id=None,
            id="7d85f602-a948-4a30-afd4-e84f47471c15",
            index=-1,
            init_at="2015-02-10T14:26:11",
            metadata={},
            phyiscal_id="cc028275-d078-4729-bf3e-154b7359814b",
            profile_id="edc63d0a-2ca4-48fa-9854-27926da76a4a",
            profile_name="mystack",
            project_id="6e18cc2bdbeb48a5b3cad2dc499f6804",
            status="ACTIVE",
            status_reason="Creation succeeded",
            updated_at=None,
            user_id="5e5bf8027826429c96af157f68dc9072"
        )
        fake_node.name = "node001"
        fake_node.to_dict = mock.Mock(return_value={})
        self.mock_client.nodes = mock.Mock(return_value=[fake_node])

    def test_cluster_node_list(self):
        arglist = ['--limit', '3', '--marker', 'a9448bf6', 'my_cluster']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        columns, data = self.cmd.take_action(parsed_args)
        self.mock_client.nodes.assert_called_with(**self.args)
        self.assertEqual(self.columns, columns)

    def test_cluster_node_list_full_id(self):
        arglist = ['--limit', '3', '--marker', 'a9448bf6', 'my_cluster',
                   '--full-id']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        columns, data = self.cmd.take_action(parsed_args)
        self.mock_client.nodes.assert_called_with(**self.args)
        self.assertEqual(self.columns, columns)

    def test_cluster_node_list_filter(self):
        kwargs = copy.deepcopy(self.args)
        kwargs['name'] = 'my_node'
        arglist = ['--limit', '3', '--marker', 'a9448bf6', 'my_cluster',
                   '--filter', 'name=my_node']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        columns, data = self.cmd.take_action(parsed_args)
        self.mock_client.nodes.assert_called_with(**kwargs)
        self.assertEqual(self.columns, columns)

    def test_cluster_node_list_sort(self):
        kwargs = copy.deepcopy(self.args)
        kwargs['name'] = 'my_node'
        kwargs['sort'] = 'name:asc'
        arglist = ['--limit', '3', '--marker', 'a9448bf6', 'my_cluster',
                   '--filter', 'name=my_node', '--sort', 'name:asc']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        columns, data = self.cmd.take_action(parsed_args)
        self.mock_client.nodes.assert_called_with(**kwargs)
        self.assertEqual(self.columns, columns)


class TestClusterNodeAdd(TestCluster):
    response = {"action": "8bb476c3-0f4c-44ee-9f64-c7b0260814de"}

    def setUp(self):
        super(TestClusterNodeAdd, self).setUp()
        self.cmd = osc_cluster.ClusterNodeAdd(self.app, None)
        self.mock_client.add_nodes_to_cluster = mock.Mock(
            return_value=self.response)

    def test_cluster_node_add(self):
        arglist = ['--nodes', 'node1', 'my_cluster']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        self.mock_client.add_nodes_to_cluster.assert_called_with(
            'my_cluster',
            ['node1'])

    def test_cluster_node_add_multi(self):
        arglist = ['--nodes', 'node1,node2', 'my_cluster']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        self.mock_client.add_nodes_to_cluster.assert_called_with(
            'my_cluster',
            ['node1', 'node2'])

    @mock.patch.object(osc_cluster, "_show_cluster")
    @mock.patch.object(senlin_utils, 'await_action')
    def test_cluster_node_add_with_wait(self, mock_await_action, mock_show):
        arglist = ['--nodes', 'node1', 'my_cluster', '--wait']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)

        mock_await_action.assert_called_once_with(self.mock_client,
                                                  self.response['action'])
        mock_show.assert_called_once_with(self.mock_client, 'my_cluster')

    @mock.patch.object(osc_cluster, "_show_cluster")
    @mock.patch.object(senlin_utils, 'await_action')
    def test_cluster_node_add_without_wait(self, mock_await_action, mock_show):
        arglist = ['--nodes', 'node1', 'my_cluster']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)

        mock_await_action.assert_not_called()
        mock_show.assert_not_called()

    @mock.patch.object(osc_cluster, "_show_cluster")
    @mock.patch.object(senlin_utils, 'await_action')
    def test_cluster_node_add_with_wait_no_action(self, mock_await_action,
                                                  mock_show):
        arglist = ['--nodes', 'node1', 'my_cluster', '--wait']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        error = {'error': 'test-error'}
        self.mock_client.add_nodes_to_cluster = mock.Mock(return_value=error)
        self.cmd.take_action(parsed_args)

        mock_await_action.assert_not_called()
        mock_show.assert_not_called()


class TestClusterNodeDel(TestCluster):
    response = {"action": "8bb476c3-0f4c-44ee-9f64-c7b0260814de"}

    def setUp(self):
        super(TestClusterNodeDel, self).setUp()
        self.cmd = osc_cluster.ClusterNodeDel(self.app, None)
        self.mock_client.remove_nodes_from_cluster = mock.Mock(
            return_value=self.response)

    def test_cluster_node_delete(self):
        arglist = ['-d', 'True', '--nodes', 'node1', 'my_cluster']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        self.mock_client.remove_nodes_from_cluster.assert_called_with(
            'my_cluster',
            ['node1'],
            destroy_after_deletion=True)

    def test_cluster_node_delete_without_destroy(self):
        arglist = ['-d', 'False', '--nodes', 'node1', 'my_cluster']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        self.mock_client.remove_nodes_from_cluster.assert_called_with(
            'my_cluster',
            ['node1'],
            destroy_after_deletion=False)

    def test_cluster_node_delete_multi(self):
        arglist = ['--nodes', 'node1,node2', 'my_cluster']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        self.mock_client.remove_nodes_from_cluster.assert_called_with(
            'my_cluster',
            ['node1', 'node2'],
            destroy_after_deletion=False)

    @mock.patch.object(osc_cluster, "_show_cluster")
    @mock.patch.object(senlin_utils, 'await_action')
    def test_cluster_node_delete_with_wait(self, mock_await_action, mock_show):
        arglist = ['--nodes', 'node1', 'my_cluster', '--wait']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)

        mock_await_action.assert_called_once_with(self.mock_client,
                                                  self.response['action'])
        mock_show.assert_called_once_with(self.mock_client, 'my_cluster')

    @mock.patch.object(osc_cluster, "_show_cluster")
    @mock.patch.object(senlin_utils, 'await_action')
    def test_cluster_node_delete_without_wait(self, mock_await_action,
                                              mock_show):
        arglist = ['--nodes', 'node1', 'my_cluster']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)

        mock_await_action.assert_not_called()
        mock_show.assert_not_called()

    @mock.patch.object(osc_cluster, "_show_cluster")
    @mock.patch.object(senlin_utils, 'await_action')
    def test_cluster_node_delete_with_wait_no_action(self, mock_await_action,
                                                     mock_show):
        arglist = ['--nodes', 'node1', 'my_cluster', '--wait']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        error = {'error': 'test-error'}
        self.mock_client.remove_nodes_from_cluster = \
            mock.Mock(return_value=error)

        self.cmd.take_action(parsed_args)

        mock_await_action.assert_not_called()
        mock_show.assert_not_called()


class TestClusterCheck(TestCluster):
    response = {"action": "8bb476c3-0f4c-44ee-9f64-c7b0260814de"}

    def setUp(self):
        super(TestClusterCheck, self).setUp()
        self.cmd = osc_cluster.CheckCluster(self.app, None)
        self.mock_client.check_cluster = mock.Mock(
            return_value=self.response)

    def test_cluster_check(self):
        arglist = ['cluster1', 'cluster2', 'cluster3']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        self.mock_client.check_cluster.assert_has_calls(
            [mock.call('cluster1'), mock.call('cluster2'),
             mock.call('cluster3')]
        )

    def test_cluster_check_not_found(self):
        arglist = ['cluster1']
        self.mock_client.check_cluster.side_effect = sdk_exc.ResourceNotFound
        parsed_args = self.check_parser(self.cmd, arglist, [])
        error = self.assertRaises(exc.CommandError, self.cmd.take_action,
                                  parsed_args)
        self.assertIn('Cluster not found: cluster1', str(error))

    @mock.patch.object(osc_cluster, "_list_cluster_summaries")
    @mock.patch.object(senlin_utils, 'await_cluster_status')
    @mock.patch.object(senlin_utils, 'await_action')
    def test_cluster_check_with_wait(self, mock_await_action,
                                     mock_await_status, mock_list):
        arglist = ['cluster1', '--wait']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)

        mock_await_action.assert_called_with(self.mock_client,
                                             self.response['action'])
        mock_await_status.assert_called_with(self.mock_client, 'cluster1')
        mock_list.assert_called_with(self.mock_client, {'cluster1'})

    @mock.patch.object(osc_cluster, "_list_cluster_summaries")
    @mock.patch.object(senlin_utils, 'await_cluster_status')
    @mock.patch.object(senlin_utils, 'await_action')
    def test_cluster_check_without_wait(self, mock_await_action,
                                        mock_await_status, mock_list):
        arglist = ['cluster1']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)

        mock_await_action.assert_not_called()
        mock_await_status.assert_not_called()
        mock_list.assert_not_called()

    @mock.patch.object(osc_cluster, "_list_cluster_summaries")
    @mock.patch.object(senlin_utils, 'await_cluster_status')
    @mock.patch.object(senlin_utils, 'await_action')
    def test_cluster_check_with_wait_no_action(self, mock_await_action,
                                               mock_await_status, mock_list):
        arglist = ['cluster1', '--wait']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        error = {'error': 'test-error'}
        self.mock_client.check_cluster = mock.Mock(return_value=error)
        self.cmd.take_action(parsed_args)

        mock_await_action.assert_not_called()
        mock_await_status.assert_not_called()
        mock_list.assert_not_called()


class TestClusterRecover(TestCluster):
    response = {"action": "8bb476c3-0f4c-44ee-9f64-c7b0260814de"}

    def setUp(self):
        super(TestClusterRecover, self).setUp()
        self.cmd = osc_cluster.RecoverCluster(self.app, None)
        self.mock_client.recover_cluster = mock.Mock(
            return_value=self.response)

    def test_cluster_recover(self):
        arglist = ['cluster1', 'cluster2', 'cluster3', '--check', 'false']
        kwargs = {'check': False}
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        self.mock_client.recover_cluster.assert_has_calls(
            [mock.call('cluster1', **kwargs), mock.call('cluster2', **kwargs),
             mock.call('cluster3', **kwargs)]
        )

    def test_cluster_recover_not_found(self):
        arglist = ['cluster1']
        self.mock_client.recover_cluster.side_effect = sdk_exc.ResourceNotFound
        parsed_args = self.check_parser(self.cmd, arglist, [])
        error = self.assertRaises(exc.CommandError, self.cmd.take_action,
                                  parsed_args)
        self.assertIn('Cluster not found: cluster1', str(error))

    @mock.patch.object(osc_cluster, "_list_cluster_summaries")
    @mock.patch.object(senlin_utils, 'await_cluster_status')
    @mock.patch.object(senlin_utils, 'await_action')
    def test_cluster_recover_with_wait(self, mock_await_action,
                                       mock_await_status, mock_list):
        arglist = ['cluster1', '--wait']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)

        mock_await_action.assert_called_with(self.mock_client,
                                             self.response['action'])
        mock_await_status.assert_called_with(self.mock_client, 'cluster1')
        mock_list.assert_called_with(self.mock_client, {'cluster1'})

    @mock.patch.object(osc_cluster, "_list_cluster_summaries")
    @mock.patch.object(senlin_utils, 'await_cluster_status')
    @mock.patch.object(senlin_utils, 'await_action')
    def test_cluster_recover_without_wait(self, mock_await_action,
                                          mock_await_status, mock_list):
        arglist = ['cluster1']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)

        mock_await_action.assert_not_called()
        mock_await_status.assert_not_called()
        mock_list.assert_not_called()

    @mock.patch.object(osc_cluster, "_list_cluster_summaries")
    @mock.patch.object(senlin_utils, 'await_cluster_status')
    @mock.patch.object(senlin_utils, 'await_action')
    def test_cluster_recover_with_wait_no_action(self, mock_await_action,
                                                 mock_await_status, mock_list):
        arglist = ['cluster1', '--wait']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        error = {'error': 'test-error'}
        self.mock_client.recover_cluster = mock.Mock(return_value=error)
        self.cmd.take_action(parsed_args)

        mock_await_action.assert_not_called()
        mock_await_status.assert_not_called()
        mock_list.assert_not_called()


class TestClusterOp(TestCluster):

    response = {"action": "a3c6d04c-3fca-4e4a-b0b3-c0522ef711f1"}

    def setUp(self):
        super(TestClusterOp, self).setUp()
        self.cmd = osc_cluster.ClusterOp(self.app, None)
        self.mock_client.perform_operation_on_cluster = mock.Mock(
            return_value=self.response)

    def test_cluster_op(self):
        arglist = ['--operation', 'dance', '--params', 'style=tango',
                   'my_cluster']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        self.mock_client.perform_operation_on_cluster.assert_called_once_with(
            'my_cluster',
            'dance',
            style='tango')

    def test_cluster_op_not_found(self):
        arglist = ['--operation', 'dance', 'cluster1']
        ex = sdk_exc.ResourceNotFound
        self.mock_client.perform_operation_on_cluster.side_effect = ex
        parsed_args = self.check_parser(self.cmd, arglist, [])
        error = self.assertRaises(exc.CommandError, self.cmd.take_action,
                                  parsed_args)
        self.assertIn('Cluster not found: cluster1', str(error))

    @mock.patch.object(osc_cluster, '_show_cluster')
    @mock.patch.object(senlin_utils, 'await_action')
    @mock.patch.object(senlin_utils, 'await_cluster_status')
    def test_cluster_op_with_wait(self, mock_await_status,
                                  mock_await_action, mock_show):
        arglist = ['--operation', 'dance', 'cluster1', '--wait']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        mock_await_action.assert_called_once_with(self.mock_client,
                                                  self.response['action'])
        mock_await_status.assert_called_once_with(self.mock_client,
                                                  'cluster1')
        mock_show.assert_called_once()

    @mock.patch.object(osc_cluster, '_show_cluster')
    @mock.patch.object(senlin_utils, 'await_action')
    @mock.patch.object(senlin_utils, 'await_cluster_status')
    def test_cluster_op_without_wait(self, mock_await_status,
                                     mock_await_action, mock_show):
        arglist = ['--operation', 'dance', 'cluster1']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        self.cmd.take_action(parsed_args)
        mock_await_action.assert_not_called()
        mock_await_status.assert_not_called()
        mock_show.assert_not_called()

    @mock.patch.object(osc_cluster, '_show_cluster')
    @mock.patch.object(senlin_utils, 'await_action')
    @mock.patch.object(senlin_utils, 'await_cluster_status')
    def test_cluster_op_with_wait_no_action(self, mock_await_status,
                                            mock_await_action, mock_show):
        arglist = ['--operation', 'dance', 'cluster1', '--wait']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        error = {'error': 'test-error'}
        self.mock_client.perform_operation_on_cluster = \
            mock.Mock(return_value=error)

        self.cmd.take_action(parsed_args)
        mock_await_action.assert_not_called()
        mock_await_status.assert_not_called()
        mock_show.assert_not_called()


class TestClusterCollect(TestCluster):
    response = [
        {
            "node_id": "8bb476c3-0f4c-44ee-9f64-c7b0260814de",
            "attr_value": "value 1",
        },
        {
            "node_id": "7d85f602-a948-4a30-afd4-e84f47471c15",
            "attr_value": "value 2",
        }
    ]

    def setUp(self):
        super(TestClusterCollect, self).setUp()
        self.cmd = osc_cluster.ClusterCollect(self.app, None)
        self.mock_client.collect_cluster_attrs = mock.Mock(
            return_value=self.response)

    def test_cluster_collect(self):
        arglist = ['--path', 'path.to.attr', 'cluster1']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        columns, data = self.cmd.take_action(parsed_args)
        self.mock_client.collect_cluster_attrs.assert_called_once_with(
            'cluster1', 'path.to.attr')
        self.assertEqual(['node_id', 'attr_value'], columns)

    def test_cluster_collect_with_full_id(self):
        arglist = ['--path', 'path.to.attr', '--full-id', 'cluster1']
        parsed_args = self.check_parser(self.cmd, arglist, [])
        columns, data = self.cmd.take_action(parsed_args)
        self.mock_client.collect_cluster_attrs.assert_called_once_with(
            'cluster1', 'path.to.attr')
        self.assertEqual(['node_id', 'attr_value'], columns)


class TestClusterRun(TestCluster):
    attrs = [
        mock.Mock(node_id="NODE_ID1",
                  attr_value={"addresses": 'ADDRESS CONTENT 1'}),
        mock.Mock(node_id="NODE_ID2",
                  attr_value={"addresses": 'ADDRESS CONTENT 2'})
    ]

    def setUp(self):
        super(TestClusterRun, self).setUp()
        self.cmd = osc_cluster.ClusterRun(self.app, None)
        self.mock_client.collect_cluster_attrs = mock.Mock(
            return_value=self.attrs)

    @mock.patch('subprocess.Popen')
    def test__run_script(self, mock_proc):
        x_proc = mock.Mock(returncode=0)
        x_stdout = 'OUTPUT'
        x_stderr = 'ERROR'
        x_proc.communicate.return_value = (x_stdout, x_stderr)
        mock_proc.return_value = x_proc

        addr = {
            'private': [
                {
                    'OS-EXT-IPS:type': 'floating',
                    'version': 4,
                    'addr': '1.2.3.4',
                }
            ]
        }
        output = {}

        self.cmd._run_script('NODE_ID', addr, 'private', 'floating', 22,
                             'john', False, 'identity_path', 'echo foo',
                             '-f bar',
                             output=output)
        mock_proc.assert_called_once_with(
            ['ssh', '-4', '-p22', '-i identity_path', '-f bar', 'john@1.2.3.4',
             'echo foo'],
            stdout=subprocess.PIPE)
        self.assertEqual(
            {'status': 'SUCCEEDED (0)', 'output': 'OUTPUT', 'error': 'ERROR'},
            output)

    def test__run_script_network_not_found(self):
        addr = {'foo': 'bar'}
        output = {}

        self.cmd._run_script('NODE_ID', addr, 'private', 'floating', 22,
                             'john', False, 'identity_path', 'echo foo',
                             '-f bar',
                             output=output)
        self.assertEqual(
            {'status': 'FAILED',
             'error': "Node 'NODE_ID' is not attached to network 'private'."
             },
            output)

    def test__run_script_more_than_one_network(self):
        addr = {'foo': 'bar', 'koo': 'tar'}
        output = {}

        self.cmd._run_script('NODE_ID', addr, '', 'floating', 22, 'john',
                             False, 'identity_path', 'echo foo', '-f bar',
                             output=output)
        self.assertEqual(
            {'status': 'FAILED',
             'error': "Node 'NODE_ID' is attached to more than one "
                       "network. Please pick the network to use."},
            output)

    def test__run_script_no_network(self):
        addr = {}
        output = {}

        self.cmd._run_script('NODE_ID', addr, '', 'floating', 22, 'john',
                             False, 'identity_path', 'echo foo', '-f bar',
                             output=output)

        self.assertEqual(
            {'status': 'FAILED',
             'error': "Node 'NODE_ID' is not attached to any network."},
            output)

    def test__run_script_no_matching_address(self):
        addr = {
            'private': [
                {
                    'OS-EXT-IPS:type': 'fixed',
                    'version': 4,
                    'addr': '1.2.3.4',
                }
            ]
        }
        output = {}

        self.cmd._run_script('NODE_ID', addr, 'private', 'floating', 22,
                             'john', False, 'identity_path', 'echo foo',
                             '-f bar',
                             output=output)
        self.assertEqual(
            {'status': 'FAILED',
             'error': "No address that matches network 'private' and "
                      "type 'floating' of IPv4 has been found for node "
                      "'NODE_ID'."},
            output)

    def test__run_script_more_than_one_address(self):
        addr = {
            'private': [
                {
                    'OS-EXT-IPS:type': 'fixed',
                    'version': 4,
                    'addr': '1.2.3.4',
                },
                {
                    'OS-EXT-IPS:type': 'fixed',
                    'version': 4,
                    'addr': '5.6.7.8',
                },
            ]
        }

        output = {}

        self.cmd._run_script('NODE_ID', addr, 'private', 'fixed', 22, 'john',
                             False, 'identity_path', 'echo foo', '-f bar',
                             output=output)
        self.assertEqual(
            {'status': 'FAILED',
             'error': "More than one IPv4 fixed address found."},
            output)

    @mock.patch('threading.Thread')
    @mock.patch.object(osc_cluster.ClusterRun, '_run_script')
    def test_cluster_run(self, mock_script, mock_thread):
        arglist = [
            '--port', '22',
            '--address-type', 'fixed',
            '--network', 'private',
            '--user', 'root',
            '--identity-file', 'path-to-identity',
            '--ssh-options', '-f boo',
            '--script', 'script-file',
            'cluster1'
        ]
        parsed_args = self.check_parser(self.cmd, arglist, [])

        th1 = mock.Mock()
        th2 = mock.Mock()
        mock_thread.side_effect = [th1, th2]
        fake_script = 'blah blah'
        with mock.patch('senlinclient.v1.cluster.open',
                        mock.mock_open(read_data=fake_script)) as mock_open:
            self.cmd.take_action(parsed_args)

        self.mock_client.collect_cluster_attrs.assert_called_once_with(
            'cluster1', 'details')
        mock_open.assert_called_once_with('script-file', 'r')
        mock_thread.assert_has_calls([
            mock.call(target=mock_script,
                      args=('NODE_ID1', 'ADDRESS CONTENT 1', 'private',
                            'fixed', 22, 'root', False, 'path-to-identity',
                            'blah blah', '-f boo'),
                      kwargs={'output': {}}),
            mock.call(target=mock_script,
                      args=('NODE_ID2', 'ADDRESS CONTENT 2', 'private',
                            'fixed', 22, 'root', False, 'path-to-identity',
                            'blah blah', '-f boo'),
                      kwargs={'output': {}})
        ])
        th1.start.assert_called_once_with()
        th2.start.assert_called_once_with()
        th1.join.assert_called_once_with()
        th2.join.assert_called_once_with()
