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 "testing/gtest/include/gtest/gtest.h" |
| 8 |
| 9 namespace proximity_auth { |
| 10 |
| 11 TEST(ProximityAuthWireMessage, Deserialize_EmptyMessage) { |
| 12 bool is_incomplete; |
| 13 scoped_ptr<WireMessage> message = |
| 14 WireMessage::Deserialize(std::string(), &is_incomplete); |
| 15 EXPECT_TRUE(is_incomplete); |
| 16 EXPECT_FALSE(message); |
| 17 } |
| 18 |
| 19 TEST(ProximityAuthWireMessage, Deserialize_IncompleteHeader) { |
| 20 bool is_incomplete; |
| 21 scoped_ptr<WireMessage> message = |
| 22 WireMessage::Deserialize("\3", &is_incomplete); |
| 23 EXPECT_TRUE(is_incomplete); |
| 24 EXPECT_FALSE(message); |
| 25 } |
| 26 |
| 27 TEST(ProximityAuthWireMessage, Deserialize_UnexpectedMessageFormatVersion) { |
| 28 bool is_incomplete; |
| 29 // Version 2 is below the minimum supported version. |
| 30 scoped_ptr<WireMessage> message = |
| 31 WireMessage::Deserialize("\2\1\1", &is_incomplete); |
| 32 EXPECT_FALSE(is_incomplete); |
| 33 EXPECT_FALSE(message); |
| 34 } |
| 35 |
| 36 TEST(ProximityAuthWireMessage, Deserialize_BodyOfSizeZero) { |
| 37 bool is_incomplete; |
| 38 scoped_ptr<WireMessage> message = |
| 39 WireMessage::Deserialize(std::string("\3\0\0", 3), &is_incomplete); |
| 40 EXPECT_FALSE(is_incomplete); |
| 41 EXPECT_FALSE(message); |
| 42 } |
| 43 |
| 44 TEST(ProximityAuthWireMessage, Deserialize_IncompleteBody) { |
| 45 bool is_incomplete; |
| 46 scoped_ptr<WireMessage> message = |
| 47 WireMessage::Deserialize(std::string("\3\0\5", 3), &is_incomplete); |
| 48 EXPECT_TRUE(is_incomplete); |
| 49 EXPECT_FALSE(message); |
| 50 } |
| 51 |
| 52 TEST(ProximityAuthWireMessage, Deserialize_BodyLongerThanSpecifiedInHeader) { |
| 53 bool is_incomplete; |
| 54 scoped_ptr<WireMessage> message = WireMessage::Deserialize( |
| 55 std::string("\3\0\5", 3) + "123456", &is_incomplete); |
| 56 EXPECT_FALSE(is_incomplete); |
| 57 EXPECT_FALSE(message); |
| 58 } |
| 59 |
| 60 TEST(ProximityAuthWireMessage, Deserialize_BodyIsNotValidJSON) { |
| 61 bool is_incomplete; |
| 62 scoped_ptr<WireMessage> message = WireMessage::Deserialize( |
| 63 std::string("\3\0\5", 3) + "12345", &is_incomplete); |
| 64 EXPECT_FALSE(is_incomplete); |
| 65 EXPECT_FALSE(message); |
| 66 } |
| 67 |
| 68 TEST(ProximityAuthWireMessage, Deserialize_BodyIsNotADictionary) { |
| 69 bool is_incomplete; |
| 70 std::string header("\3\0\x29", 3); |
| 71 std::string bytes = |
| 72 header + "[{\"permit_id\": \"Hi!\", \"payload\": \"YQ==\"}]"; |
| 73 scoped_ptr<WireMessage> message = |
| 74 WireMessage::Deserialize(bytes, &is_incomplete); |
| 75 EXPECT_FALSE(is_incomplete); |
| 76 EXPECT_FALSE(message); |
| 77 } |
| 78 |
| 79 TEST(ProximityAuthWireMessage, Deserialize_BodyLacksPermitId) { |
| 80 bool is_incomplete; |
| 81 std::string header("\3\0\x13", 3); |
| 82 std::string bytes = header + "{\"payload\": \"YQ==\"}"; |
| 83 scoped_ptr<WireMessage> message = |
| 84 WireMessage::Deserialize(bytes, &is_incomplete); |
| 85 EXPECT_FALSE(is_incomplete); |
| 86 EXPECT_FALSE(message); |
| 87 } |
| 88 |
| 89 TEST(ProximityAuthWireMessage, Deserialize_BodyLacksPayload) { |
| 90 bool is_incomplete; |
| 91 std::string header("\3\0\x14", 3); |
| 92 std::string bytes = header + "{\"permit_id\": \"Hi!\"}"; |
| 93 scoped_ptr<WireMessage> message = |
| 94 WireMessage::Deserialize(bytes, &is_incomplete); |
| 95 EXPECT_FALSE(is_incomplete); |
| 96 EXPECT_FALSE(message); |
| 97 } |
| 98 |
| 99 TEST(ProximityAuthWireMessage, Deserialize_BodyHasEmptyPermitId) { |
| 100 bool is_incomplete; |
| 101 std::string header("\3\0\x24", 3); |
| 102 std::string bytes = |
| 103 header + "{\"permit_id\": \"\", \"payload\": \"YQ==\"}"; |
| 104 scoped_ptr<WireMessage> message = |
| 105 WireMessage::Deserialize(bytes, &is_incomplete); |
| 106 EXPECT_FALSE(is_incomplete); |
| 107 EXPECT_FALSE(message); |
| 108 } |
| 109 |
| 110 TEST(ProximityAuthWireMessage, Deserialize_BodyHasEmptyPayload) { |
| 111 bool is_incomplete; |
| 112 std::string header("\3\0\x23", 3); |
| 113 std::string bytes = |
| 114 header + "{\"permit_id\": \"Hi!\", \"payload\": \"\"}"; |
| 115 scoped_ptr<WireMessage> message = |
| 116 WireMessage::Deserialize(bytes, &is_incomplete); |
| 117 EXPECT_FALSE(is_incomplete); |
| 118 EXPECT_FALSE(message); |
| 119 } |
| 120 |
| 121 TEST(ProximityAuthWireMessage, Deserialize_PayloadIsNotBase64Encoded) { |
| 122 bool is_incomplete; |
| 123 std::string header("\3\0\x2A", 3); |
| 124 std::string bytes = |
| 125 header + "{\"permit_id\": \"Hi!\", \"payload\": \"garbage\"}"; |
| 126 scoped_ptr<WireMessage> message = |
| 127 WireMessage::Deserialize(bytes, &is_incomplete); |
| 128 EXPECT_FALSE(is_incomplete); |
| 129 EXPECT_FALSE(message); |
| 130 } |
| 131 |
| 132 TEST(ProximityAuthWireMessage, Deserialize_ValidMessage) { |
| 133 bool is_incomplete; |
| 134 std::string header("\3\0\x27", 3); |
| 135 std::string bytes = |
| 136 header + "{\"permit_id\": \"Hi!\", \"payload\": \"YQ==\"}"; |
| 137 scoped_ptr<WireMessage> message = |
| 138 WireMessage::Deserialize(bytes, &is_incomplete); |
| 139 EXPECT_FALSE(is_incomplete); |
| 140 EXPECT_TRUE(message); |
| 141 EXPECT_EQ("Hi!", message->permit_id()); |
| 142 EXPECT_EQ("a", message->payload()); |
| 143 } |
| 144 |
| 145 TEST(ProximityAuthWireMessage, Deserialize_ValidMessageWithExtraUnknownFields) { |
| 146 bool is_incomplete; |
| 147 std::string header("\3\0\x46", 3); |
| 148 std::string bytes = |
| 149 header + |
| 150 "{" |
| 151 " \"permit_id\": \"Hi!\"," |
| 152 " \"payload\": \"YQ==\"," |
| 153 " \"unexpected\": \"surprise!\"" |
| 154 "}"; |
| 155 scoped_ptr<WireMessage> message = |
| 156 WireMessage::Deserialize(bytes, &is_incomplete); |
| 157 EXPECT_FALSE(is_incomplete); |
| 158 EXPECT_TRUE(message); |
| 159 EXPECT_EQ("Hi!", message->permit_id()); |
| 160 EXPECT_EQ("a", message->payload()); |
| 161 } |
| 162 |
| 163 } // namespace proximity_auth |
OLD | NEW |