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 default=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 default=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 default='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 default=[ 

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 default=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 default=['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 self.assertEqual(test_settings.empty_guid_list, []) 

167 

168 # Test valid GUID updates 

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

170 test_settings.guid_list = valid_guids 

171 self.assertEqual(test_settings.guid_list, valid_guids) 

172 

173 # Test empty list 

174 test_settings.guid_list = [] 

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

176 

177 # Test None value 

178 test_settings.guid_list = None 

179 self.assertIsNone(test_settings.guid_list) 

180 

181 # Test invalid inputs - should raise ValueError 

182 with self.assertRaises(ValueError): 

183 test_settings.guid_list = "not_a_list" 

184 

185 with self.assertRaises(ValueError): 

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

187 

188 with self.assertRaises(ValueError): 

189 test_settings.guid_list = [ 

190 "invalid_guid_format"] # Invalid GUID format 

191 

192 with self.assertRaises(ValueError): 

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

194 

195 # Test config update 

196 config = configparser.ConfigParser(allow_no_value=True) 

197 config.add_section('TestGuidSettings') 

198 config['TestGuidSettings'][ 

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

200 test_settings.update_from_config(config) 

201 self.assertEqual( 

202 test_settings.guid_list, 

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

204 ) 

205 

206 # Test mandatory setting check 

207 with self.assertRaises(ValueError): 

208 test_settings.check_mandatory() 

209 

210 def test_stories_to_load_guids(self): 

211 """Test the stories_to_load_guids setting in BaseSimSettings""" 

212 settings = sim_settings.BaseSimSettings() 

213 

214 # Test default value 

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

216 

217 # Test valid update 

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

219 settings.stories_to_load_guids = valid_guids 

220 self.assertEqual(settings.stories_to_load_guids, valid_guids) 

221 

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

223 config = configparser.ConfigParser(allow_no_value=True) 

224 config.add_section( 

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

226 config['BaseSimSettings'][ 

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

228 

229 # Update settings from config 

230 settings.update_from_config(config) 

231 

232 # Test the value was updated 

233 self.assertEqual(settings.stories_to_load_guids, 

234 ['1HBLcH3L5AgRg8QXUjHQ2T'])