Coverage for manila/tests/scheduler/drivers/test_simple.py: 100%

1# Copyright 2010 United States Government as represented by the 

2# Administrator of the National Aeronautics and Space Administration. 

3# All Rights Reserved. 

4# 

5# Licensed under the Apache License, Version 2.0 (the "License"); you may 

6# not use this file except in compliance with the License. You may obtain 

7# a copy of the License at 

8# 

9# http://www.apache.org/licenses/LICENSE-2.0 

10# 

11# Unless required by applicable law or agreed to in writing, software 

12# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 

13# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 

14# License for the specific language governing permissions and limitations 

15# under the License. 

16""" 

17Tests For Simple Scheduler 

18""" 

19 

20from unittest import mock 

21 

22from oslo_config import cfg 

23 

24from manila import context 

25from manila import db 

26from manila import exception 

27from manila.scheduler.drivers import base 

28from manila.scheduler.drivers import simple 

29from manila.share import rpcapi as share_rpcapi 

30from manila import test 

31from manila.tests import db_utils 

32from manila import utils 

33 

34CONF = cfg.CONF 

35 

36 

37class SimpleSchedulerSharesTestCase(test.TestCase): 

38 """Test case for simple scheduler create share method.""" 

39 

40 def setUp(self): 

41 super(SimpleSchedulerSharesTestCase, self).setUp() 

42 self.mock_object(share_rpcapi, 'ShareAPI') 

43 self.driver = simple.SimpleScheduler() 

44 

45 self.context = context.RequestContext('fake_user', 'fake_project') 

46 self.admin_context = context.RequestContext('fake_admin_user', 

47 'fake_project') 

48 self.admin_context.is_admin = True 

49 

50 @mock.patch.object(utils, 'service_is_up', mock.Mock(return_value=True)) 

51 def test_create_share_if_two_services_up(self): 

52 share_id = 'fake' 

53 fake_share = {'id': share_id, 'size': 1} 

54 fake_service_1 = {'disabled': False, 'host': 'fake_host1'} 

55 fake_service_2 = {'disabled': False, 'host': 'fake_host2'} 

56 fake_result = [(fake_service_1, 2), (fake_service_2, 1)] 

57 fake_request_spec = { 

58 'share_id': share_id, 

59 'share_properties': fake_share, 

60 } 

61 self.mock_object(db, 'service_get_all_share_sorted', 

62 mock.Mock(return_value=fake_result)) 

63 self.mock_object(base, 'share_update_db', 

64 mock.Mock(return_value=db_utils.create_share())) 

65 

66 self.driver.schedule_create_share(self.context, 

67 fake_request_spec, {}) 

68 utils.service_is_up.assert_called_once_with(utils.IsAMatcher(dict)) 

69 db.service_get_all_share_sorted.assert_called_once_with( 

70 utils.IsAMatcher(context.RequestContext)) 

71 base.share_update_db.assert_called_once_with( 

72 utils.IsAMatcher(context.RequestContext), share_id, 'fake_host1') 

73 

74 def test_create_share_if_services_not_available(self): 

75 share_id = 'fake' 

76 fake_share = {'id': share_id, 'size': 1} 

77 fake_result = [] 

78 fake_request_spec = { 

79 'share_id': share_id, 

80 'share_properties': fake_share, 

81 } 

82 with mock.patch.object(db, 'service_get_all_share_sorted', 

83 mock.Mock(return_value=fake_result)): 

84 self.assertRaises(exception.NoValidHost, 

85 self.driver.schedule_create_share, 

86 self.context, fake_request_spec, {}) 

87 db.service_get_all_share_sorted.assert_called_once_with( 

88 utils.IsAMatcher(context.RequestContext)) 

89 

90 def test_create_share_if_max_gigabytes_exceeded(self): 

91 share_id = 'fake' 

92 fake_share = {'id': share_id, 'size': 10001} 

93 fake_service_1 = {'disabled': False, 'host': 'fake_host1'} 

94 fake_service_2 = {'disabled': False, 'host': 'fake_host2'} 

95 fake_result = [(fake_service_1, 5), (fake_service_2, 7)] 

96 fake_request_spec = { 

97 'share_id': share_id, 

98 'share_properties': fake_share, 

99 } 

100 with mock.patch.object(db, 'service_get_all_share_sorted', 

101 mock.Mock(return_value=fake_result)): 

102 self.assertRaises(exception.NoValidHost, 

103 self.driver.schedule_create_share, 

104 self.context, fake_request_spec, {}) 

105 db.service_get_all_share_sorted.assert_called_once_with( 

106 utils.IsAMatcher(context.RequestContext)) 

107 

108 @mock.patch.object(utils, 'service_is_up', mock.Mock(return_value=True)) 

109 def test_create_share_availability_zone(self): 

110 share_id = 'fake' 

111 fake_share = { 

112 'id': share_id, 

113 'size': 1, 

114 } 

115 fake_instance = { 

116 'availability_zone_id': 'fake', 

117 } 

118 fake_service_1 = { 

119 'disabled': False, 'host': 'fake_host1', 

120 'availability_zone_id': 'fake', 

121 } 

122 fake_service_2 = { 

123 'disabled': False, 'host': 'fake_host2', 

124 'availability_zone_id': 'super_fake', 

125 } 

126 fake_result = [(fake_service_1, 0), (fake_service_2, 1)] 

127 fake_request_spec = { 

128 'share_id': share_id, 

129 'share_properties': fake_share, 

130 'share_instance_properties': fake_instance, 

131 } 

132 self.mock_object(db, 'service_get_all_share_sorted', 

133 mock.Mock(return_value=fake_result)) 

134 self.mock_object(base, 'share_update_db', 

135 mock.Mock(return_value=db_utils.create_share())) 

136 

137 self.driver.schedule_create_share(self.context, 

138 fake_request_spec, {}) 

139 utils.service_is_up.assert_called_once_with(fake_service_1) 

140 base.share_update_db.assert_called_once_with( 

141 utils.IsAMatcher(context.RequestContext), share_id, 

142 fake_service_1['host']) 

143 db.service_get_all_share_sorted.assert_called_once_with( 

144 utils.IsAMatcher(context.RequestContext)) 

145 

146 @mock.patch.object(utils, 'service_is_up', mock.Mock(return_value=True)) 

147 def test_create_share_availability_zone_on_host(self): 

148 share_id = 'fake' 

149 fake_share = { 

150 'id': share_id, 

151 'availability_zone': 'fake:fake', 

152 'size': 1, 

153 } 

154 fake_service = {'disabled': False, 'host': 'fake'} 

155 fake_request_spec = { 

156 'share_id': share_id, 

157 'share_properties': fake_share, 

158 } 

159 self.mock_object(db, 'service_get_all_share_sorted', 

160 mock.Mock(return_value=[(fake_service, 1)])) 

161 self.mock_object(base, 'share_update_db', 

162 mock.Mock(return_value=db_utils.create_share())) 

163 

164 self.driver.schedule_create_share(self.admin_context, 

165 fake_request_spec, {}) 

166 utils.service_is_up.assert_called_once_with(fake_service) 

167 db.service_get_all_share_sorted.assert_called_once_with( 

168 utils.IsAMatcher(context.RequestContext)) 

169 base.share_update_db.assert_called_once_with( 

170 utils.IsAMatcher(context.RequestContext), share_id, 'fake')