yardstick/tests/unit/benchmark/contexts/test_kubernetes.py

   1 ##############################################################################
   2 # Copyright (c) 2015 Huawei Technologies Co.,Ltd and others.
   3 #
   4 # All rights reserved. This program and the accompanying materials
   5 # are made available under the terms of the Apache License, Version 2.0
   6 # which accompanies this distribution, and is available at
   7 # http://www.apache.org/licenses/LICENSE-2.0
   8 ##############################################################################
   9
  10 import mock
  11 import unittest
  12
  13 from yardstick.benchmark.contexts import base
  14 from yardstick.benchmark.contexts import kubernetes
  15 from yardstick.orchestrator import kubernetes as orchestrator_kubernetes
  16
  17
  18 CONTEXT_CFG = {
  19     'type': 'Kubernetes',
  20     'name': 'k8s',
  21     'task_id': '1234567890',
  22     'servers': {
  23         'host': {
  24             'image': 'openretriever/yardstick',
  25             'command': '/bin/bash',
  26             'args': ['-c', 'chmod 700 ~/.ssh; chmod 600 ~/.ssh/*; '
  27                      'service ssh restart;while true ; do sleep 10000; done']
  28         },
  29         'target': {
  30             'image': 'openretriever/yardstick',
  31             'command': '/bin/bash',
  32             'args': ['-c', 'chmod 700 ~/.ssh; chmod 600 ~/.ssh/*; '
  33                      'service ssh restart;while true ; do sleep 10000; done']
  34         }
  35     }
  36 }
  37
  38 prefix = 'yardstick.benchmark.contexts.kubernetes'
  39
  40
  41 class KubernetesTestCase(unittest.TestCase):
  42
  43     def setUp(self):
  44         self.k8s_context = kubernetes.KubernetesContext()
  45         self.addCleanup(self._remove_contexts)
  46         self.k8s_context.init(CONTEXT_CFG)
  47
  48     @staticmethod
  49     def _remove_contexts():
  50         for context in base.Context.list:
  51             context._delete_context()
  52         base.Context.list = []
  53
  54     @mock.patch.object(kubernetes.KubernetesContext, '_delete_services')
  55     @mock.patch.object(kubernetes.KubernetesContext, '_delete_ssh_key')
  56     @mock.patch.object(kubernetes.KubernetesContext, '_delete_rcs')
  57     @mock.patch.object(kubernetes.KubernetesContext, '_delete_pods')
  58     def test_undeploy(self,
  59                       mock_delete_pods,
  60                       mock_delete_rcs,
  61                       mock_delete_ssh,
  62                       mock_delete_services):
  63
  64         self.k8s_context.undeploy()
  65         mock_delete_ssh.assert_called_once()
  66         mock_delete_rcs.assert_called_once()
  67         mock_delete_pods.assert_called_once()
  68         mock_delete_services.assert_called_once()
  69
  70     @mock.patch.object(kubernetes.KubernetesContext, '_create_services')
  71     @mock.patch.object(kubernetes.KubernetesContext, '_wait_until_running')
  72     @mock.patch.object(orchestrator_kubernetes.KubernetesTemplate,
  73                        'get_rc_pods')
  74     @mock.patch.object(kubernetes.KubernetesContext, '_create_rcs')
  75     @mock.patch.object(kubernetes.KubernetesContext, '_set_ssh_key')
  76     def test_deploy(self,
  77                     mock_set_ssh_key,
  78                     mock_create_rcs,
  79                     mock_get_rc_pods,
  80                     mock_wait_until_running,
  81                     mock_create_services):
  82
  83         with mock.patch("yardstick.benchmark.contexts.kubernetes.time"):
  84             self.k8s_context.deploy()
  85         mock_set_ssh_key.assert_called_once()
  86         mock_create_rcs.assert_called_once()
  87         mock_create_services.assert_called_once()
  88         mock_get_rc_pods.assert_called_once()
  89         mock_wait_until_running.assert_called_once()
  90
  91     @mock.patch.object(kubernetes, 'paramiko', **{"resource_filename.return_value": ""})
  92     @mock.patch.object(kubernetes, 'pkg_resources', **{"resource_filename.return_value": ""})
  93     @mock.patch.object(kubernetes, 'utils')
  94     @mock.patch.object(kubernetes, 'open', create=True)
  95     @mock.patch.object(kubernetes.k8s_utils, 'delete_config_map')
  96     @mock.patch.object(kubernetes.k8s_utils, 'create_config_map')
  97     def test_ssh_key(self, mock_create, mock_delete, *args):
  98         self.k8s_context._set_ssh_key()
  99         self.k8s_context._delete_ssh_key()
 100
 101         mock_create.assert_called_once()
 102         mock_delete.assert_called_once()
 103
 104     @mock.patch.object(kubernetes.k8s_utils, 'read_pod_status')
 105     def test_wait_until_running(self, mock_read_pod_status):
 106
 107         self.k8s_context.template.pods = ['server']
 108         mock_read_pod_status.return_value = 'Running'
 109         self.k8s_context._wait_until_running()
 110
 111     @mock.patch.object(kubernetes.k8s_utils, 'get_pod_by_name')
 112     @mock.patch.object(kubernetes.KubernetesContext, '_get_node_ip')
 113     @mock.patch.object(kubernetes.k8s_utils, 'get_service_by_name')
 114     def test_get_server(self,
 115                         mock_get_service_by_name,
 116                         mock_get_node_ip,
 117                         mock_get_pod_by_name):
 118         class Service(object):
 119             def __init__(self):
 120                 self.name = 'yardstick'
 121                 self.node_port = 30000
 122
 123         class Services(object):
 124             def __init__(self):
 125                 self.ports = [Service()]
 126
 127         class Status(object):
 128             def __init__(self):
 129                 self.pod_ip = '172.16.10.131'
 130
 131         class Pod(object):
 132             def __init__(self):
 133                 self.status = Status()
 134
 135         mock_get_service_by_name.return_value = Services()
 136         mock_get_pod_by_name.return_value = Pod()
 137         mock_get_node_ip.return_value = '172.16.10.131'
 138
 139         self.assertIsNotNone(self.k8s_context._get_server('server'))
 140
 141     @mock.patch.object(kubernetes.KubernetesContext, '_create_rc')
 142     def test_create_rcs(self, mock_create_rc):
 143         self.k8s_context._create_rcs()
 144         mock_create_rc.assert_called()
 145
 146     @mock.patch.object(kubernetes.k8s_utils, 'create_replication_controller')
 147     def test_create_rc(self, mock_create_replication_controller):
 148         self.k8s_context._create_rc({})
 149         mock_create_replication_controller.assert_called_once()
 150
 151     @mock.patch.object(kubernetes.KubernetesContext, '_delete_rc')
 152     def test_delete_rcs(self, mock_delete_rc):
 153         self.k8s_context._delete_rcs()
 154         mock_delete_rc.assert_called()
 155
 156     @mock.patch.object(kubernetes.k8s_utils, 'delete_replication_controller')
 157     def test_delete_rc(self, mock_delete_replication_controller):
 158         self.k8s_context._delete_rc({})
 159         mock_delete_replication_controller.assert_called_once()
 160
 161     @mock.patch.object(kubernetes.k8s_utils, 'get_node_list')
 162     def test_get_node_ip(self, mock_get_node_list):
 163         self.k8s_context._get_node_ip()
 164         mock_get_node_list.assert_called_once()
 165
 166     @mock.patch('yardstick.orchestrator.kubernetes.ServiceObject.create')
 167     def test_create_services(self, mock_create):
 168         self.k8s_context._create_services()
 169         mock_create.assert_called()
 170
 171     @mock.patch('yardstick.orchestrator.kubernetes.ServiceObject.delete')
 172     def test_delete_services(self, mock_delete):
 173         self.k8s_context._delete_services()
 174         mock_delete.assert_called()
 175
 176     def test_init(self):
 177         self.k8s_context._delete_context()
 178         with mock.patch.object(orchestrator_kubernetes, 'KubernetesTemplate',
 179                 return_value='fake_template') as mock_k8stemplate:
 180             self.k8s_context = kubernetes.KubernetesContext()
 181             self.k8s_context.init(CONTEXT_CFG)
 182         mock_k8stemplate.assert_called_once_with(self.k8s_context.name,
 183                                                  CONTEXT_CFG)
 184         self.assertEqual('fake_template', self.k8s_context.template)
 185
 186     def test__get_physical_nodes(self):
 187         result = self.k8s_context._get_physical_nodes()
 188         self.assertIsNone(result)
 189
 190     def test__get_physical_node_for_server(self):
 191         result = self.k8s_context._get_physical_node_for_server("fake")
 192         self.assertIsNone(result)