tests/unit/benchmark/contexts/test_kubernetes.py

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