tests/unit/benchmark/scenarios/storage/test_storperf.py

   1 #!/usr/bin/env python
   2
   3 ##############################################################################
   4 # Copyright (c) 2016 Huawei Technologies Co.,Ltd.
   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.scenarios.storage.storperf.StorPerf
  13
  14 import mock
  15 import unittest
  16 import requests
  17 import json
  18
  19 from yardstick.benchmark.scenarios.storage import storperf
  20
  21
  22 def mocked_requests_config_post(*args, **kwargs):
  23     class MockResponseConfigPost:
  24         def __init__(self, json_data, status_code):
  25             self.content = json_data
  26             self.status_code = status_code
  27
  28     return MockResponseConfigPost('{"stack_id": "dac27db1-3502-4300-b301-91c64e6a1622","stack_created": "false"}', 200)
  29
  30
  31 def mocked_requests_config_get(*args, **kwargs):
  32     class MockResponseConfigGet:
  33         def __init__(self, json_data, status_code):
  34             self.content = json_data
  35             self.status_code = status_code
  36
  37     return MockResponseConfigGet('{"stack_id": "dac27db1-3502-4300-b301-91c64e6a1622","stack_created": "true"}', 200)
  38
  39
  40 def mocked_requests_job_get(*args, **kwargs):
  41     class MockResponseJobGet:
  42         def __init__(self, json_data, status_code):
  43             self.content = json_data
  44             self.status_code = status_code
  45
  46     return MockResponseJobGet('{"status": "completed", "_ssd_preconditioning.queue-depth.8.block-size.16384.duration": 6}', 200)
  47
  48
  49 def mocked_requests_job_post(*args, **kwargs):
  50     class MockResponseJobPost:
  51         def __init__(self, json_data, status_code):
  52             self.content = json_data
  53             self.status_code = status_code
  54
  55     return MockResponseJobPost('{"job_id": \
  56                                  "d46bfb8c-36f4-4a40-813b-c4b4a437f728"}', 200)
  57
  58
  59 def mocked_requests_job_delete(*args, **kwargs):
  60     class MockResponseJobDelete:
  61         def __init__(self, json_data, status_code):
  62             self.content = json_data
  63             self.status_code = status_code
  64
  65     return MockResponseJobDelete('{}', 200)
  66
  67
  68 def mocked_requests_delete(*args, **kwargs):
  69     class MockResponseDelete:
  70         def __init__(self, json_data, status_code):
  71             self.json_data = json_data
  72             self.status_code = status_code
  73
  74     return MockResponseDelete('{}', 200)
  75
  76
  77 def mocked_requests_delete_failed(*args, **kwargs):
  78     class MockResponseDeleteFailed:
  79         def __init__(self, json_data, status_code):
  80             self.json_data = json_data
  81             self.status_code = status_code
  82
  83     if args[0] == "http://172.16.0.137:5000/api/v1.0/configurations":
  84         return MockResponseDeleteFailed('{"message": "Teardown failed"}', 400)
  85
  86     return MockResponseDeleteFailed('{}', 404)
  87
  88
  89 class StorPerfTestCase(unittest.TestCase):
  90
  91     def setUp(self):
  92         self.ctx = {
  93             'host': {
  94                 'ip': '172.16.0.137',
  95                 'user': 'cirros',
  96                 'key_filename': "mykey.key"
  97             }
  98         }
  99
 100         self.result = {}
 101
 102     @mock.patch('yardstick.benchmark.scenarios.storage.storperf.requests.post',
 103                 side_effect=mocked_requests_config_post)
 104     @mock.patch('yardstick.benchmark.scenarios.storage.storperf.requests.get',
 105                 side_effect=mocked_requests_config_get)
 106     def test_successful_setup(self, mock_post, mock_get):
 107         options = {
 108             "agent_count": 8,
 109             "public_network": 'ext-net',
 110             "volume_size": 10,
 111             "block_sizes": 4096,
 112             "queue_depths": 4,
 113             "workload": "rs",
 114             "StorPerf_ip": "192.168.23.2",
 115             "query_interval": 10,
 116             "timeout": 60
 117         }
 118
 119         args = {
 120             "options": options
 121         }
 122
 123         s = storperf.StorPerf(args, self.ctx)
 124
 125         s.setup()
 126
 127         self.assertTrue(s.setup_done)
 128
 129     @mock.patch('yardstick.benchmark.scenarios.storage.storperf.requests.post',
 130                 side_effect=mocked_requests_job_post)
 131     @mock.patch('yardstick.benchmark.scenarios.storage.storperf.requests.get',
 132                 side_effect=mocked_requests_job_get)
 133     @mock.patch('yardstick.benchmark.scenarios.storage.storperf.requests.delete',
 134                 side_effect=mocked_requests_job_delete)
 135     def test_successful_run(self, mock_post, mock_get, mock_delete):
 136         options = {
 137             "agent_count": 8,
 138             "public_network": 'ext-net',
 139             "volume_size": 10,
 140             "block_sizes": 4096,
 141             "queue_depths": 4,
 142             "workload": "rs",
 143             "StorPerf_ip": "192.168.23.2",
 144             "query_interval": 10,
 145             "timeout": 60
 146         }
 147
 148         args = {
 149             "options": options
 150         }
 151
 152         s = storperf.StorPerf(args, self.ctx)
 153         s.setup_done = True
 154
 155         sample_output = '{"status": "completed", "_ssd_preconditioning.queue-depth.8.block-size.16384.duration": 6}'
 156
 157         expected_result = json.loads(sample_output)
 158
 159         s.run(self.result)
 160
 161         self.assertEqual(self.result, expected_result)
 162
 163     @mock.patch('yardstick.benchmark.scenarios.storage.storperf.requests.delete', side_effect=mocked_requests_delete)
 164     def test_successful_teardown(self, mock_delete):
 165         options = {
 166             "agent_count": 8,
 167             "public_network": 'ext-net',
 168             "volume_size": 10,
 169             "block_sizes": 4096,
 170             "queue_depths": 4,
 171             "workload": "rs",
 172             "StorPerf_ip": "192.168.23.2",
 173             "query_interval": 10,
 174             "timeout": 60
 175         }
 176
 177         args = {
 178             "options": options
 179         }
 180
 181         s = storperf.StorPerf(args, self.ctx)
 182
 183         s.teardown()
 184
 185         self.assertFalse(s.setup_done)
 186
 187     @mock.patch('yardstick.benchmark.scenarios.storage.storperf.requests.delete', side_effect=mocked_requests_delete_failed)
 188     def test_failed_teardown(self, mock_delete):
 189         options = {
 190             "agent_count": 8,
 191             "public_network": 'ext-net',
 192             "volume_size": 10,
 193             "block_sizes": 4096,
 194             "queue_depths": 4,
 195             "workload": "rs",
 196             "StorPerf_ip": "192.168.23.2",
 197             "query_interval": 10,
 198             "timeout": 60
 199         }
 200
 201         args = {
 202             "options": options
 203         }
 204
 205         s = storperf.StorPerf(args, self.ctx)
 206
 207         self.assertRaises(AssertionError, s.teardown(), self.result)
 208
 209
 210 def main():
 211     unittest.main()
 212
 213 if __name__ == '__main__':
 214     main()