| 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 |
|---|
Chromium Code Reviews
Issue 2561203002:
Migrate weave-related classes from proximity_auth/ble to cryptauth/ble. (Closed)
