Coverage for tests/test_xmlparser/test_attributes.py: 100%

138 statements  

« prev     ^ index     » next       coverage.py v7.9.1, created at 2025-06-21 15:58 +0200

1from sbe2.xmlparser.attributes import ( 

2 parse_name, 

3 parse_description, 

4 parse_since_version, 

5 parse_deprecated, 

6 parse_alignment, 

7 parse_offset, 

8 parse_block_length, 

9 parse_id, 

10 parse_presence, 

11 parse_semantic_type, 

12 parse_encoding_type, 

13 parse_character_encoding, 

14 parse_max_value, 

15 parse_min_value, 

16 parse_null_value, 

17 parse_value_ref, 

18 parse_primitive_type, 

19 parse_type, 

20 parse_length, 

21 parse_semantic_version, 

22 parse_byte_order, 

23 parse_header_type, 

24 parse_package, 

25 parse_version 

26) 

27from sbe2.schema import Presence, ByteOrder 

28from sbe2.xmlparser.errors import SchemaParsingError 

29from sbe2.xmlparser.ctx import ParsingContext 

30from lxml.etree import XML as xml 

31from pytest import raises 

32 

33 

34def test_parse_name(): 

35 node = xml("<element name='testName'/>") 

36 assert parse_name(node) == "testName" 

37 with raises(SchemaParsingError): 

38 parse_name(xml("<element/>")) 

39 

40 

41def test_parse_description(): 

42 node = xml("<element description='This is a test description'/>") 

43 assert parse_description(node) == "This is a test description" 

44 assert parse_description(xml("<element/>")) == "" 

45 

46 

47def test_parse_since_version(): 

48 node = xml("<element sinceVersion='5'/>") 

49 assert parse_since_version(node) == 5 

50 assert parse_since_version(xml("<element/>")) == 0 

51 

52 

53def test_parse_deprecated(): 

54 node = xml("<element deprecated='1'/>") 

55 assert parse_deprecated(node) == 1 

56 assert parse_deprecated(xml("<element/>")) is None 

57 assert parse_deprecated(xml("<element deprecated='0'/>")) == 0 

58 with raises(SchemaParsingError): 

59 parse_deprecated(xml("<element deprecated='invalid'/>")) 

60 

61 

62def test_parse_alignment(): 

63 node = xml("<element alignment='8'/>") 

64 assert parse_alignment(node) == 8 

65 assert parse_alignment(xml("<element/>")) is None 

66 with raises(SchemaParsingError): 

67 parse_alignment(xml("<element alignment='invalid'/>")) 

68 

69 

70def test_parse_offset(): 

71 node = xml("<element offset='16'/>") 

72 assert parse_offset(node) == 16 

73 assert parse_offset(xml("<element/>")) is None 

74 with raises(SchemaParsingError): 

75 parse_offset(xml("<element offset='invalid'/>")) 

76 

77 

78def test_parse_block_length(): 

79 node = xml("<element blockLength='32'/>") 

80 assert parse_block_length(node) == 32 

81 assert parse_block_length(xml("<element/>")) is None 

82 with raises(SchemaParsingError): 

83 parse_block_length(xml("<element blockLength='invalid'/>")) 

84 

85 

86def test_parse_id(): 

87 node = xml("<element id='123'/>") 

88 assert parse_id(node) == 123 

89 with raises(SchemaParsingError): 

90 parse_id(xml("<element/>")) 

91 with raises(SchemaParsingError): 

92 parse_id(xml("<element id='invalid'/>")) 

93 

94 

95def test_parse_presence(): 

96 assert parse_presence(xml("<element presence='optional'/>")) == Presence.OPTIONAL 

97 assert parse_presence(xml("<element presence='required'/>")) == Presence.REQUIRED 

98 assert parse_presence(xml("<element presence='constant'/>")) == Presence.CONSTANT 

99 assert parse_presence(xml("<element/>")) is None 

100 with raises(SchemaParsingError): 

101 parse_presence(xml("<element presence='invalid'/>")) 

102 

103 

104def test_parse_semantic_type(): 

105 node = xml("<element semanticType='price'/>") 

106 assert parse_semantic_type(node) == "price" 

107 assert parse_semantic_type(xml("<element/>")) == "" 

108 

109 

110def test_parse_encoding_type(): 

111 node = xml("<element encodingType='int'/>") 

112 assert parse_encoding_type(node) == 'int' 

113 with raises(SchemaParsingError): 

114 parse_encoding_type(xml("<element />")) 

115 

116 

117def test_character_encoding(): 

118 node = xml("<element characterEncoding='UTF-8'/>") 

119 assert parse_character_encoding(node) == "UTF-8" 

120 assert parse_character_encoding(xml("<element/>")) is None 

121 

122 

123def test_parse_max_value(): 

124 node = xml("<element maxValue='100'/>") 

125 assert parse_max_value(node) == 100 

126 assert parse_max_value(xml("<element/>")) is None 

127 with raises(SchemaParsingError): 

128 parse_max_value(xml("<element maxValue='invalid'/>")) 

129 

130 

131def test_parse_min_value(): 

132 node = xml("<element minValue='10'/>") 

133 assert parse_min_value(node) == 10 

134 assert parse_min_value(xml("<element/>")) is None 

135 with raises(SchemaParsingError): 

136 parse_min_value(xml("<element minValue='invalid'/>")) 

137 

138def test_parse_null_value(): 

139 node = xml("<element nullValue='0'/>") 

140 assert parse_null_value(node) == 0 

141 assert parse_null_value(xml("<element/>")) is None 

142 with raises(SchemaParsingError): 

143 parse_null_value(xml("<element nullValue='invalid'/>")) 

144 

145def test_parse_value_ref(): 

146 node = xml("<element valueRef='someValue'/>") 

147 assert parse_value_ref(node) == "someValue" 

148 assert parse_value_ref(xml("<element/>")) is None 

149 

150 

151def test_parse_primitive_type(): 

152 assert parse_primitive_type(xml("<element primitiveType='int'/>")).name == "int" 

153 assert parse_primitive_type(xml("<element primitiveType='float'/>")).name == "float" 

154 with raises(SchemaParsingError): 

155 parse_primitive_type(xml("<element primitiveType='invalid'/>")) 

156 with raises(SchemaParsingError): 

157 parse_primitive_type(xml("<element/>")) 

158 

159 

160def test_parse_type(): 

161 node = xml("<element type='int'/>") 

162 assert parse_type(node) == "int" 

163 with raises(SchemaParsingError): 

164 parse_type(xml("<element/>")) 

165 

166 

167def test_parse_length(): 

168 node = xml("<element length='10'/>") 

169 assert parse_length(node) == 10 

170 assert parse_length(xml("<element/>")) == 1 

171 with raises(SchemaParsingError): 

172 parse_length(xml("<element length='invalid'/>")) 

173 

174 

175def test_parse_semantic_version(): 

176 node = xml("<element semanticVersion='1.0.0'/>") 

177 assert parse_semantic_version(node) == "1.0.0" 

178 assert parse_semantic_version(xml("<element/>")) == "" 

179 

180 

181def test_parse_byte_order(): 

182 assert parse_byte_order(xml("<element byteOrder='littleEndian'/>")) == ByteOrder.LITTLE_ENDIAN 

183 assert parse_byte_order(xml("<element byteOrder='bigEndian'/>")) == ByteOrder.BIG_ENDIAN 

184 assert parse_byte_order(xml("<element/>")) == ByteOrder.LITTLE_ENDIAN 

185 with raises(SchemaParsingError): 

186 parse_byte_order(xml("<element byteOrder='invalid'/>")) 

187 

188 

189def test_parse_header_type(): 

190 assert parse_header_type(xml('<element headerType="someHeader"/>')) == "someHeader" 

191 assert parse_header_type(xml('<element/>')) == "messageHeader" 

192 with raises(SchemaParsingError): 

193 parse_header_type(xml('<element headerType=""/>')) 

194 

195 

196def test_parse_package(): 

197 node = xml("<element package='com.example'/>") 

198 assert parse_package(node) == "com.example" 

199 with raises(SchemaParsingError): 

200 parse_package(xml("<element/>")) 

201 

202 

203def test_parse_version(): 

204 node = xml("<element version='1'/>") 

205 assert parse_version(node) == 1 

206 with raises(SchemaParsingError): 

207 parse_version(xml("<element/>")) 

208 with raises(SchemaParsingError): 

209 parse_version(xml("<element version='invalid'/>"))