Coverage for tests/test_frame_data.py: 100%

1"""Test Frame building.""" 

2 

3from unittest import TestCase 

4 

5from galaxy_beep_frame.exception.frame import ( 

6 AboveRangeError, 

7 BelowRangeError, 

8 InvalidContinuationIndicatorError, 

9 AnswerNumberError, 

10 MissingAnswerNumberError, 

11) 

12from galaxy_beep_frame.frame import ContinuationIndicator, Frame 

13from galaxy_beep_frame.header_type import PossibleHeaderType 

14 

15 

16class TestFrameBuilding(TestCase): 

17 """Test BEEP Frame building.""" 

18 

19 def test_frame_state(self) -> None: 

20 """Test bad values in frame state.""" 

21 header_type = PossibleHeaderType.MSG 

22 bad_channel_numbers = [-1, 2147483648] 

23 bad_message_numbers = [-1, 2147483648] 

24 bad_answer_numbers = [-1, 2147483648] 

25 bad_sequence_numbers = [-1, 4294967296] 

26 

27 good_channel_numbers = [0, 2147483647] 

28 good_message_numbers = [0, 2147483647] 

29 good_answer_numbers = [0, 1247482647] 

30 good_sequence_numbers = [0, 4294967295] 

31 

32 for bad_channel_number in bad_channel_numbers: 

33 with ( 

34 self.subTest( 

35 msg="bad channel number", 

36 channel_number=bad_channel_number, 

37 ), 

38 self.assertRaises((BelowRangeError, AboveRangeError)), 

39 ): 

40 Frame( 

41 payload=b"", 

42 channel_number=bad_channel_number, 

43 message_number=0, 

44 sequence_number=0, 

45 answer_number=None, 

46 continuation_indicator=ContinuationIndicator.COMPLETE, 

47 header_type=header_type, 

48 ) 

49 for bad_message_number in bad_message_numbers: 

50 with ( 

51 self.subTest( 

52 msg="bad message number", 

53 message_number=bad_message_number, 

54 ), 

55 self.assertRaises((BelowRangeError, AboveRangeError)), 

56 ): 

57 Frame( 

58 payload=b"", 

59 channel_number=0, 

60 message_number=bad_message_number, 

61 sequence_number=0, 

62 answer_number=None, 

63 continuation_indicator=ContinuationIndicator.COMPLETE, 

64 header_type=header_type, 

65 ) 

66 for bad_sequence_number in bad_sequence_numbers: 

67 with ( 

68 self.subTest( 

69 msg="bad sequence number", 

70 sequence_number=bad_sequence_number, 

71 ), 

72 self.assertRaises((BelowRangeError, AboveRangeError)), 

73 ): 

74 Frame( 

75 payload=b"", 

76 channel_number=0, 

77 message_number=0, 

78 sequence_number=bad_sequence_number, 

79 answer_number=None, 

80 continuation_indicator=ContinuationIndicator.COMPLETE, 

81 header_type=header_type, 

82 ) 

83 

84 for bad_answer_number in bad_answer_numbers: 

85 with ( 

86 self.subTest( 

87 msg="bad answer number", 

88 answer_number=bad_answer_number, 

89 ), 

90 self.assertRaises((BelowRangeError, AboveRangeError)), 

91 ): 

92 Frame( 

93 payload=b"", 

94 channel_number=0, 

95 message_number=0, 

96 sequence_number=0, 

97 answer_number=bad_answer_number, 

98 continuation_indicator=ContinuationIndicator.COMPLETE, 

99 header_type=PossibleHeaderType.ANS, 

100 ) 

101 

102 for ( 

103 good_channel_number, 

104 good_message_number, 

105 good_sequence_number, 

106 ) in zip( 

107 good_channel_numbers, 

108 good_message_numbers, 

109 good_sequence_numbers, 

110 strict=True, 

111 ): 

112 with self.subTest( 

113 msg="All numbers should be valid.", 

114 channel_number=good_channel_number, 

115 message_number=good_message_number, 

116 sequence_number=good_sequence_number, 

117 ): 

118 Frame( 

119 payload=b"", 

120 channel_number=good_channel_number, 

121 message_number=good_message_number, 

122 sequence_number=good_sequence_number, 

123 answer_number=None, 

124 continuation_indicator=ContinuationIndicator.COMPLETE, 

125 header_type=header_type, 

126 ) 

127 

128 for good_answer_number in good_answer_numbers: 

129 with self.subTest( 

130 msg="Answer number should be valid.", 

131 answer_number=good_answer_number, 

132 ): 

133 Frame( 

134 payload=b"", 

135 channel_number=0, 

136 message_number=0, 

137 sequence_number=0, 

138 answer_number=good_answer_number, 

139 continuation_indicator=ContinuationIndicator.COMPLETE, 

140 header_type=PossibleHeaderType.ANS, 

141 ) 

142 

143 with self.assertRaises(InvalidContinuationIndicatorError): 

144 Frame( 

145 payload=b"", 

146 channel_number=0, 

147 message_number=0, 

148 sequence_number=0, 

149 answer_number=None, 

150 continuation_indicator=ContinuationIndicator.INTERMEDIATE, 

151 header_type=PossibleHeaderType.NUL, 

152 ) 

153 

154 Frame( 

155 payload=b"", 

156 channel_number=0, 

157 message_number=0, 

158 sequence_number=0, 

159 answer_number=None, 

160 continuation_indicator=ContinuationIndicator.COMPLETE, 

161 header_type=PossibleHeaderType.NUL, 

162 ) 

163 

164 with self.assertRaises(AnswerNumberError): 

165 Frame( 

166 payload=b"", 

167 channel_number=0, 

168 message_number=0, 

169 sequence_number=0, 

170 answer_number=0, 

171 continuation_indicator=ContinuationIndicator.INTERMEDIATE, 

172 header_type=PossibleHeaderType.MSG, 

173 ) 

174 

175 with self.assertRaises(MissingAnswerNumberError): 

176 Frame( 

177 payload=b"", 

178 channel_number=0, 

179 message_number=0, 

180 sequence_number=0, 

181 answer_number=None, 

182 continuation_indicator=ContinuationIndicator.COMPLETE, 

183 header_type=PossibleHeaderType.ANS, 

184 )