Coverage for manila/tests/share/drivers/netapp/test_common.py: 100%

1# Copyright (c) 2015 Clinton Knight. All rights reserved. 

2# 

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

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

5# a copy of the License at 

6# 

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

8# 

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

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

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

12# License for the specific language governing permissions and limitations 

13# under the License. 

14 

15from unittest import mock 

16 

17from manila import exception 

18from manila.share.drivers.netapp import common as na_common 

19from manila.share.drivers.netapp.dataontap.cluster_mode import drv_multi_svm 

20from manila.share.drivers.netapp import utils as na_utils 

21from manila import test 

22from manila.tests.share.drivers.netapp import fakes as na_fakes 

23 

24 

25class NetAppDriverFactoryTestCase(test.TestCase): 

26 

27 def test_new(self): 

28 

29 self.mock_object(na_utils.OpenStackInfo, 'info', 

30 mock.Mock(return_value='fake_info')) 

31 mock_get_driver_mode = self.mock_object( 

32 na_common.NetAppDriver, '_get_driver_mode', 

33 mock.Mock(return_value='fake_mode')) 

34 mock_create_driver = self.mock_object(na_common.NetAppDriver, 

35 '_create_driver') 

36 

37 config = na_fakes.create_configuration() 

38 config.netapp_storage_family = 'fake_family' 

39 config.driver_handles_share_servers = True 

40 

41 kwargs = {'configuration': config} 

42 na_common.NetAppDriver(**kwargs) 

43 

44 kwargs['app_version'] = 'fake_info' 

45 mock_get_driver_mode.assert_called_once_with('fake_family', True) 

46 mock_create_driver.assert_called_once_with('fake_family', 'fake_mode', 

47 *(), **kwargs) 

48 

49 def test_new_missing_config(self): 

50 

51 self.mock_object(na_utils.OpenStackInfo, 'info') 

52 self.mock_object(na_common.NetAppDriver, '_create_driver') 

53 

54 self.assertRaises(exception.InvalidInput, 

55 na_common.NetAppDriver, **{}) 

56 

57 def test_new_missing_family(self): 

58 

59 self.mock_object(na_utils.OpenStackInfo, 'info') 

60 self.mock_object(na_common.NetAppDriver, '_create_driver') 

61 

62 config = na_fakes.create_configuration() 

63 config.driver_handles_share_servers = True 

64 config.netapp_storage_family = None 

65 

66 kwargs = {'configuration': config} 

67 self.assertRaises(exception.InvalidInput, 

68 na_common.NetAppDriver, 

69 **kwargs) 

70 

71 def test_new_missing_mode(self): 

72 

73 self.mock_object(na_utils.OpenStackInfo, 'info') 

74 self.mock_object(na_common.NetAppDriver, '_create_driver') 

75 

76 config = na_fakes.create_configuration() 

77 config.driver_handles_share_servers = None 

78 config.netapp_storage_family = 'fake_family' 

79 

80 kwargs = {'configuration': config} 

81 self.assertRaises(exception.InvalidInput, 

82 na_common.NetAppDriver, 

83 **kwargs) 

84 

85 def test_get_driver_mode_missing_mode_good_default(self): 

86 

87 result = na_common.NetAppDriver._get_driver_mode('ONTAP_CLUSTER', None) 

88 self.assertEqual(na_common.MULTI_SVM, result) 

89 

90 def test_create_driver_missing_mode_no_default(self): 

91 

92 self.assertRaises(exception.InvalidInput, 

93 na_common.NetAppDriver._get_driver_mode, 

94 'fake_family', None) 

95 

96 def test_get_driver_mode_multi_svm(self): 

97 

98 result = na_common.NetAppDriver._get_driver_mode('ONTAP_CLUSTER', True) 

99 self.assertEqual(na_common.MULTI_SVM, result) 

100 

101 def test_get_driver_mode_single_svm(self): 

102 

103 result = na_common.NetAppDriver._get_driver_mode('ONTAP_CLUSTER', 

104 False) 

105 self.assertEqual(na_common.SINGLE_SVM, result) 

106 

107 def test_create_driver(self): 

108 

109 def get_full_class_name(obj): 

110 return obj.__module__ + '.' + obj.__class__.__name__ 

111 

112 registry = na_common.NETAPP_UNIFIED_DRIVER_REGISTRY 

113 

114 for family in iter(registry.keys()): 

115 for mode, full_class_name in registry[family].items(): 

116 

117 config = na_fakes.create_configuration() 

118 config.local_conf.set_override('driver_handles_share_servers', 

119 mode == na_common.MULTI_SVM) 

120 kwargs = { 

121 'configuration': config, 

122 'private_storage': mock.Mock(), 

123 'app_version': 'fake_info' 

124 } 

125 

126 driver = na_common.NetAppDriver._create_driver( 

127 family, mode, **kwargs) 

128 

129 self.assertEqual(full_class_name, get_full_class_name(driver)) 

130 

131 def test_create_driver_case_insensitive(self): 

132 

133 config = na_fakes.create_configuration() 

134 config.local_conf.set_override('driver_handles_share_servers', True) 

135 

136 kwargs = { 

137 'configuration': config, 

138 'private_storage': mock.Mock(), 

139 'app_version': 'fake_info' 

140 } 

141 

142 driver = na_common.NetAppDriver._create_driver('ONTAP_CLUSTER', 

143 na_common.MULTI_SVM, 

144 **kwargs) 

145 

146 self.assertIsInstance(driver, 

147 drv_multi_svm.NetAppCmodeMultiSvmShareDriver) 

148 

149 def test_create_driver_invalid_family(self): 

150 

151 kwargs = { 

152 'configuration': na_fakes.create_configuration(), 

153 'app_version': 'fake_info', 

154 } 

155 

156 self.assertRaises(exception.InvalidInput, 

157 na_common.NetAppDriver._create_driver, 

158 'fake_family', na_common.MULTI_SVM, 

159 **kwargs) 

160 

161 def test_create_driver_invalid_mode(self): 

162 

163 kwargs = { 

164 'configuration': na_fakes.create_configuration(), 

165 'app_version': 'fake_info', 

166 } 

167 

168 self.assertRaises(exception.InvalidInput, 

169 na_common.NetAppDriver._create_driver, 

170 'ontap_cluster', 'fake_mode', **kwargs)