components/proximity_auth/wire_message_unittest.cc - Issue 2561203002: Migrate weave-related classes from proximity_auth/ble to cryptauth/ble.

Side by Side Diff: components/proximity_auth/wire_message_unittest.cc

Issue 2561203002: Migrate weave-related classes from proximity_auth/ble to cryptauth/ble. (Closed)

Patch Set: Rebase. Created 4 years ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

OLD	NEW
	(Empty)
1 // Copyright 2014 The Chromium Authors. All rights reserved.

2 // Use of this source code is governed by a BSD-style license that can be

3 // found in the LICENSE file.

4

5 #include "components/proximity_auth/wire_message.h"

6

7 #include <stdint.h>

8

9 #include "base/strings/string_util.h"

10 #include "testing/gtest/include/gtest/gtest.h"

11

12 namespace proximity_auth {

13

14 TEST(ProximityAuthWireMessage, Deserialize_EmptyMessage) {

15 bool is_incomplete;

16 std::unique_ptr<WireMessage> message =

17 WireMessage::Deserialize(std::string(), &is_incomplete);

18 EXPECT_TRUE(is_incomplete);

19 EXPECT_FALSE(message);

20 }

21

22 TEST(ProximityAuthWireMessage, Deserialize_IncompleteHeader) {

23 bool is_incomplete;

24 std::unique_ptr<WireMessage> message =

25 WireMessage::Deserialize("\3", &is_incomplete);

26 EXPECT_TRUE(is_incomplete);

27 EXPECT_FALSE(message);

28 }

29

30 TEST(ProximityAuthWireMessage, Deserialize_UnexpectedMessageFormatVersion) {

31 bool is_incomplete;

32 // Version 2 is below the minimum supported version.

33 std::unique_ptr<WireMessage> message =

34 WireMessage::Deserialize("\2\1\1", &is_incomplete);

35 EXPECT_FALSE(is_incomplete);

36 EXPECT_FALSE(message);

37 }

38

39 TEST(ProximityAuthWireMessage, Deserialize_BodyOfSizeZero) {

40 bool is_incomplete;

41 std::unique_ptr<WireMessage> message =

42 WireMessage::Deserialize(std::string("\3\0\0", 3), &is_incomplete);

43 EXPECT_FALSE(is_incomplete);

44 EXPECT_FALSE(message);

45 }

46

47 TEST(ProximityAuthWireMessage, Deserialize_IncompleteBody) {

48 bool is_incomplete;

49 std::unique_ptr<WireMessage> message =

50 WireMessage::Deserialize(std::string("\3\0\5", 3), &is_incomplete);

51 EXPECT_TRUE(is_incomplete);

52 EXPECT_FALSE(message);

53 }

54

55 TEST(ProximityAuthWireMessage, Deserialize_BodyLongerThanSpecifiedInHeader) {

56 bool is_incomplete;

57 std::unique_ptr<WireMessage> message = WireMessage::Deserialize(

58 std::string("\3\0\5", 3) + "123456", &is_incomplete);

59 EXPECT_FALSE(is_incomplete);

60 EXPECT_FALSE(message);

61 }

62

63 TEST(ProximityAuthWireMessage, Deserialize_BodyIsNotValidJSON) {

64 bool is_incomplete;

65 std::unique_ptr<WireMessage> message = WireMessage::Deserialize(

66 std::string("\3\0\5", 3) + "12345", &is_incomplete);

67 EXPECT_FALSE(is_incomplete);

68 EXPECT_FALSE(message);

69 }

70

71 TEST(ProximityAuthWireMessage, Deserialize_BodyIsNotADictionary) {

72 bool is_incomplete;

73 std::string header("\3\0\x29", 3);

74 std::string bytes =

75 header + "[{\"permit_id\": \"Hi!\", \"payload\": \"YQ==\"}]";

76 std::unique_ptr<WireMessage> message =

77 WireMessage::Deserialize(bytes, &is_incomplete);

78 EXPECT_FALSE(is_incomplete);

79 EXPECT_FALSE(message);

80 }

81

82 // The permit ID is optional.

83 TEST(ProximityAuthWireMessage, Deserialize_BodyLacksPermitId) {

84 bool is_incomplete;

85 std::string header("\3\0\x13", 3);

86 std::string bytes = header + "{\"payload\": \"YQ==\"}";

87 std::unique_ptr<WireMessage> message =

88 WireMessage::Deserialize(bytes, &is_incomplete);

89 EXPECT_FALSE(is_incomplete);

90 EXPECT_TRUE(message);

91 EXPECT_EQ(std::string(), message->permit_id());

92 EXPECT_EQ("a", message->payload());

93 }

94

95 TEST(ProximityAuthWireMessage, Deserialize_BodyLacksPayload) {

96 bool is_incomplete;

97 std::string header("\3\0\x14", 3);

98 std::string bytes = header + "{\"permit_id\": \"Hi!\"}";

99 std::unique_ptr<WireMessage> message =

100 WireMessage::Deserialize(bytes, &is_incomplete);

101 EXPECT_FALSE(is_incomplete);

102 EXPECT_FALSE(message);

103 }

104

105 // The permit ID is optional.

106 TEST(ProximityAuthWireMessage, Deserialize_BodyHasEmptyPermitId) {

107 bool is_incomplete;

108 std::string header("\3\0\x24", 3);

109 std::string bytes = header + "{\"permit_id\": \"\", \"payload\": \"YQ==\"}";

110 std::unique_ptr<WireMessage> message =

111 WireMessage::Deserialize(bytes, &is_incomplete);

112 EXPECT_FALSE(is_incomplete);

113 EXPECT_TRUE(message);

114 EXPECT_EQ(std::string(), message->permit_id());

115 EXPECT_EQ("a", message->payload());

116 }

117

118 TEST(ProximityAuthWireMessage, Deserialize_BodyHasEmptyPayload) {

119 bool is_incomplete;

120 std::string header("\3\0\x23", 3);

121 std::string bytes = header + "{\"permit_id\": \"Hi!\", \"payload\": \"\"}";

122 std::unique_ptr<WireMessage> message =

123 WireMessage::Deserialize(bytes, &is_incomplete);

124 EXPECT_FALSE(is_incomplete);

125 EXPECT_FALSE(message);

126 }

127

128 TEST(ProximityAuthWireMessage, Deserialize_PayloadIsNotBase64Encoded) {

129 bool is_incomplete;

130 std::string header("\3\0\x2A", 3);

131 std::string bytes =

132 header + "{\"permit_id\": \"Hi!\", \"payload\": \"garbage\"}";

133 std::unique_ptr<WireMessage> message =

134 WireMessage::Deserialize(bytes, &is_incomplete);

135 EXPECT_FALSE(is_incomplete);

136 EXPECT_FALSE(message);

137 }

138

139 TEST(ProximityAuthWireMessage, Deserialize_ValidMessage) {

140 bool is_incomplete;

141 std::string header("\3\0\x27", 3);

142 std::string bytes =

143 header + "{\"permit_id\": \"Hi!\", \"payload\": \"YQ==\"}";

144 std::unique_ptr<WireMessage> message =

145 WireMessage::Deserialize(bytes, &is_incomplete);

146 EXPECT_FALSE(is_incomplete);

147 ASSERT_TRUE(message);

148 EXPECT_EQ("Hi!", message->permit_id());

149 EXPECT_EQ("a", message->payload());

150 }

151

152 TEST(ProximityAuthWireMessage, Deserialize_ValidMessageWithBase64UrlEncoding) {

153 bool is_incomplete;

154 std::string header("\3\0\x27", 3);

155 std::string bytes =

156 header + "{\"permit_id\": \"Hi!\", \"payload\": \"_-Y=\"}";

157 std::unique_ptr<WireMessage> message =

158 WireMessage::Deserialize(bytes, &is_incomplete);

159 EXPECT_FALSE(is_incomplete);

160 ASSERT_TRUE(message);

161 EXPECT_EQ("Hi!", message->permit_id());

162 EXPECT_EQ("\xFF\xE6", message->payload());

163 }

164

165 TEST(ProximityAuthWireMessage, Deserialize_ValidMessageWithExtraUnknownFields) {

166 bool is_incomplete;

167 std::string header("\3\0\x46", 3);

168 std::string bytes = header +

169 "{"

170 " \"permit_id\": \"Hi!\","

171 " \"payload\": \"YQ==\","

172 " \"unexpected\": \"surprise!\""

173 "}";

174 std::unique_ptr<WireMessage> message =

175 WireMessage::Deserialize(bytes, &is_incomplete);

176 EXPECT_FALSE(is_incomplete);

177 ASSERT_TRUE(message);

178 EXPECT_EQ("Hi!", message->permit_id());

179 EXPECT_EQ("a", message->payload());

180 }

181

182 TEST(ProximityAuthWireMessage, Deserialize_SizeEquals0x01FF) {

183 // Create a message with a body of 0x01FF bytes to test the size contained in

184 // the header is parsed correctly.

185 std::string header("\3\x01\xff", 3);

186 char json_template[] = "{\"payload\":\"YQ==\", \"filler\":\"$1\"}";

187 // Add 3 to the size to take into account the "$1" and NUL terminator ("\0")

188 // characters in \|json_template\|.

189 uint16_t filler_size = 0x01ff - sizeof(json_template) + 3;

190 std::string filler(filler_size, 'F');

191

192 std::string body = base::ReplaceStringPlaceholders(

193 json_template, std::vector<std::string>(1u, filler), nullptr);

194 std::string serialized_message = header + body;

195

196 bool is_incomplete;

197 std::unique_ptr<WireMessage> message =

198 WireMessage::Deserialize(serialized_message, &is_incomplete);

199 EXPECT_FALSE(is_incomplete);

200 ASSERT_TRUE(message);

201 EXPECT_EQ("a", message->payload());

202 }

203

204 TEST(ProximityAuthWireMessage, Serialize_WithPermitId) {

205 WireMessage message1("example payload", "example id");

206 std::string bytes = message1.Serialize();

207 ASSERT_FALSE(bytes.empty());

208

209 bool is_incomplete;

210 std::unique_ptr<WireMessage> message2 =

211 WireMessage::Deserialize(bytes, &is_incomplete);

212 EXPECT_FALSE(is_incomplete);

213 ASSERT_TRUE(message2);

214 EXPECT_EQ("example id", message2->permit_id());

215 EXPECT_EQ("example payload", message2->payload());

216 }

217

218 TEST(ProximityAuthWireMessage, Serialize_WithoutPermitId) {

219 WireMessage message1("example payload");

220 std::string bytes = message1.Serialize();

221 ASSERT_FALSE(bytes.empty());

222

223 bool is_incomplete;

224 std::unique_ptr<WireMessage> message2 =

225 WireMessage::Deserialize(bytes, &is_incomplete);

226 EXPECT_FALSE(is_incomplete);

227 ASSERT_TRUE(message2);

228 EXPECT_EQ(std::string(), message2->permit_id());

229 EXPECT_EQ("example payload", message2->payload());

230 }

231

232 TEST(ProximityAuthWireMessage, Serialize_FailsWithoutPayload) {

233 WireMessage message1(std::string(), "example id");

234 std::string bytes = message1.Serialize();

235 EXPECT_TRUE(bytes.empty());

236 }

237

238 } // namespace proximity_auth

OLD	NEW

« components/cryptauth/ble/bluetooth_low_energy_characteristics_finder_unittest.cc ('K') | « components/proximity_auth/wire_message.cc ('k') | no next file » | no next file with comments »