Coverage for test/unit/test_sim_settings.py: 100%

1import configparser 

2import unittest 

3 

4from pathlib import Path 

5 

6from bim2sim.utilities.types import LOD 

7from bim2sim import sim_settings 

8from test.unit.elements.helper import SetupHelper 

9 

10 

11class SimSettingsHelper(SetupHelper): 

12 def create_new_sim_setting(self): 

13 class NewSettings(sim_settings.BaseSimSettings): 

14 def __init__(self): 

15 super().__init__( 

16 ) 

17 new_setting_lod = sim_settings.ChoiceSetting( 

18 value=LOD.low, 

19 choices={ 

20 LOD.low: 'not so detailed setting', 

21 LOD.full: 'awesome detailed setting' 

22 }, 

23 description='A new sim_settings lod setting to be created.', 

24 for_frontend=True 

25 ) 

26 new_setting_bool = sim_settings.BooleanSetting( 

27 value=False, 

28 description='A new sim_settings bool setting to be created.', 

29 for_frontend=True 

30 ) 

31 new_setting_str = sim_settings.ChoiceSetting( 

32 value='Perfect', 

33 choices={ 

34 'Perfect': 'A perfect setting', 

35 'Awesome': 'An awesome setting' 

36 }, 

37 description='A new sim_settings str setting to be created.', 

38 for_frontend=True 

39 ) 

40 new_setting_list = sim_settings.ChoiceSetting( 

41 value=[ 

42 'a', 'b', 'c'], 

43 choices={ 

44 'a': 'option a', 

45 'b': 'option b', 

46 'c': 'option c' 

47 }, 

48 description='A new sim_settings list setting to be created.', 

49 multiple_choice=True, 

50 for_frontend=True 

51 ) 

52 new_setting_path = sim_settings.PathSetting( 

53 value=Path(__file__), 

54 description='Setting to get a path.' 

55 ) 

56 

57 # instantiate the new wf 

58 new_wf = NewSettings() 

59 return new_wf 

60 

61 

62class TestSimSettings(unittest.TestCase): 

63 helper = SimSettingsHelper() 

64 

65 def tearDown(self): 

66 self.helper.reset() 

67 

68 def test_default_settings(self): 

69 """Test loading of default settings""" 

70 standard_wf = sim_settings.BaseSimSettings() 

71 self.assertFalse(standard_wf.dymola_simulation) 

72 self.assertFalse(standard_wf.create_external_elements) 

73 

74 def test_update_from_config(self): 

75 """Test loading sim_settings settings from config""" 

76 new_wf = self.helper.create_new_sim_setting() 

77 self.assertEqual( 

78 new_wf.new_setting_lod, LOD.low) 

79 self.assertFalse(new_wf.new_setting_bool) 

80 self.assertEqual(new_wf.new_setting_str, 'Perfect') 

81 config = configparser.ConfigParser(allow_no_value=True) 

82 config.add_section('NewSettings') 

83 # set full LOD (3) for new setting in config 

84 config['NewSettings']['new_setting_lod'] = 'LOD.full' 

85 config['NewSettings']['new_setting_bool'] = 'True' 

86 config['NewSettings']['new_setting_str'] = 'Awesome' 

87 config['NewSettings']['new_setting_list'] = '["a","b","c"]' 

88 config['NewSettings']['new_setting_path'] = str(Path(__file__).parent) 

89 new_wf.update_from_config(config) 

90 self.assertEqual( 

91 new_wf.new_setting_lod, LOD.full) 

92 self.assertTrue(new_wf.new_setting_bool) 

93 self.assertEqual(new_wf.new_setting_str, 'Awesome') 

94 self.assertEqual(new_wf.new_setting_list, ['a', 'b', 'c']) 

95 self.assertEqual(new_wf.new_setting_path, Path(__file__).parent) 

96 

97 def test_LOD(self): 

98 """Test setting and getting the different LODs""" 

99 set_detail = LOD.low 

100 self.assertEqual(set_detail, LOD.low) 

101 set_detail = LOD(1) 

102 self.assertEqual(set_detail, LOD.low) 

103 set_detail = LOD.medium 

104 self.assertEqual(set_detail, LOD.medium) 

105 set_detail = LOD(2) 

106 self.assertEqual(set_detail, LOD.medium) 

107 set_detail = LOD.full 

108 self.assertEqual(set_detail, LOD.full) 

109 set_detail = LOD(3) 

110 self.assertEqual(set_detail, LOD.full) 

111 

112 def test_auto_name_setting(self): 

113 """Test if name is correctly set by meta class AutoSettingNameMeta""" 

114 new_wf = self.helper.create_new_sim_setting() 

115 # get attribute by name 

116 new_setting = getattr(new_wf, 'new_setting_lod') 

117 self.assertEqual(new_setting, LOD.low) 

118 

119 def test_new_sim_settings_creation(self): 

120 """Test if the creation of new sim settings work""" 

121 new_sim_setting = self.helper.create_new_sim_setting() 

122 # test default 

123 self.assertEqual( 

124 new_sim_setting.new_setting_lod, LOD.low) 

125 # test description 

126 self.assertEqual( 

127 new_sim_setting.manager['new_setting_lod'].description, 

128 'A new sim_settings lod setting to be created.') 

129 # test set new value 

130 new_sim_setting.new_setting_lod = LOD.full 

131 self.assertEqual( 

132 new_sim_setting.new_setting_lod, LOD.full) 

133 

134 def test_guid_list_setting(self): 

135 """Test the GuidListSetting class for handling IFC GUIDs""" 

136 

137 # Create a test settings class with GuidListSetting 

138 class TestGuidSettings(sim_settings.BaseSimSettings): 

139 def __init__(self): 

140 super().__init__() 

141 

142 guid_list = sim_settings.GuidListSetting( 

143 value=['0rB_VAJfDAowPYhJGd9wjZ', '3V8lRtj8n5AxfePCnKtF31'], 

144 description='Test GUID list setting', 

145 for_frontend=True 

146 ) 

147 

148 empty_guid_list = sim_settings.GuidListSetting( 

149 description='Test empty GUID list setting', 

150 for_frontend=True 

151 ) 

152 

153 mandatory_guid_list = sim_settings.GuidListSetting( 

154 description='Test mandatory GUID list setting', 

155 mandatory=True 

156 ) 

157 

158 # Create settings instance 

159 test_settings = TestGuidSettings() 

160 

161 # Test default values are correctly set 

162 self.assertEqual( 

163 test_settings.guid_list, 

164 ['0rB_VAJfDAowPYhJGd9wjZ', '3V8lRtj8n5AxfePCnKtF31'] 

165 ) 

166 dings = test_settings.empty_guid_list 

167 

168 self.assertEqual(test_settings.empty_guid_list, None) 

169 

170 # Test valid GUID updates 

171 valid_guids = ['1HBLcH3L5AgRg8QXUjHQ2T', '2MBmFkSRv59wfBR9XN_dIe'] 

172 test_settings.guid_list = valid_guids 

173 self.assertEqual(test_settings.guid_list, valid_guids) 

174 

175 # Test empty list 

176 test_settings.guid_list = [] 

177 self.assertEqual(test_settings.guid_list, []) 

178 

179 # Test None value 

180 test_settings.guid_list = None 

181 self.assertIsNone(test_settings.guid_list) 

182 

183 # Test invalid inputs - should raise ValueError 

184 with self.assertRaises(ValueError): 

185 test_settings.guid_list = "not_a_list" 

186 

187 with self.assertRaises(ValueError): 

188 test_settings.guid_list = [123, 456] # Not strings 

189 

190 with self.assertRaises(ValueError): 

191 test_settings.guid_list = [ 

192 "invalid_guid_format"] # Invalid GUID format 

193 

194 with self.assertRaises(ValueError): 

195 test_settings.guid_list = ["0rB_VAJfDAowPYhJGd9wjZ", "invalid_guid"] 

196 

197 # Test config update 

198 config = configparser.ConfigParser(allow_no_value=True) 

199 config.add_section('TestGuidSettings') 

200 config['TestGuidSettings'][ 

201 'guid_list'] = '["3V8lRtj8n5AxfePCnKtF31", "0rB_VAJfDAowPYhJGd9wjZ"]' 

202 test_settings.update_from_config(config) 

203 self.assertEqual( 

204 test_settings.guid_list, 

205 ['3V8lRtj8n5AxfePCnKtF31', '0rB_VAJfDAowPYhJGd9wjZ'] 

206 ) 

207 

208 # Test mandatory setting check 

209 with self.assertRaises(ValueError): 

210 test_settings.check_mandatory() 

211 

212 def test_stories_to_load_guids(self): 

213 """Test the stories_to_load_guids setting in BaseSimSettings""" 

214 settings = sim_settings.BaseSimSettings() 

215 

216 # Test default value 

217 self.assertEqual(settings.stories_to_load_guids, []) 

218 

219 # Test valid update 

220 valid_guids = ['0rB_VAJfDAowPYhJGd9wjZ', '3V8lRtj8n5AxfePCnKtF31'] 

221 settings.stories_to_load_guids = valid_guids 

222 self.assertEqual(settings.stories_to_load_guids, valid_guids) 

223 

224 # Create a config that matches the exact format used in Project.config 

225 config = configparser.ConfigParser(allow_no_value=True) 

226 config.add_section( 

227 'BaseSimSettings') # Use the actual class name, not "Generic Simulation Settings" 

228 config['BaseSimSettings'][ 

229 'stories_to_load_guids'] = '["1HBLcH3L5AgRg8QXUjHQ2T"]' 

230 

231 # Update settings from config 

232 settings.update_from_config(config) 

233 

234 # Test the value was updated 

235 self.assertEqual(settings.stories_to_load_guids, 

236 ['1HBLcH3L5AgRg8QXUjHQ2T'])