1// Copyright (C) 2013 Google Inc.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15#include "validating_util.h"
16
17#include <string>
18
19#include <gtest/gtest.h>
20
21#define ITOA_HELPER(i) #i
22#define ITOA(i) ITOA_HELPER(i)
23
24#define DATA "{'foo': 'bar'}"
25#define TIMESTAMP 1388001600
26#define TIMESTAMP_HALF_MONTH_AGO 1386705600
27#define TIMESTAMP_TWO_MONTHS_AGO 1382817600
28#define CHECKSUM "dd63dafcbd4d5b28badfcaf86fb6fcdb"
29
30namespace {
31
32using i18n::addressinput::ValidatingUtil;
33
34// The data being wrapped.
35const char kUnwrappedData[] = DATA;
36
37// The timestamp for the wrapped data.
38const time_t kTimestamp = TIMESTAMP;
39
40// The checksum and data together.
41const char kChecksummedData[] = "checksum=" CHECKSUM "\n"
42                                DATA;
43
44// "Randomly" corrupted checksummed data. The "m" in "checksum" is capitalized.
45const char kCorruptedChecksummedData[] = "checksuM=" CHECKSUM "\n"
46                                         DATA;
47
48// The checksum in the middle of data.
49const char kChecksumInMiddle[] = DATA "\n"
50                                 "checksum=" CHECKSUM "\n"
51                                 DATA;
52
53// The file as it is stored on disk.
54const char kWrappedData[] = "timestamp=" ITOA(TIMESTAMP) "\n"
55                            "checksum=" CHECKSUM "\n"
56                            DATA;
57
58// "Randomly" corrupted file. The "p" in "timestamp" is capitalized.
59const char kCorruptedWrappedData[] = "timestamP=" ITOA(TIMESTAMP) "\n"
60                                     "checksum=" CHECKSUM "\n"
61                                     DATA;
62
63// The timestamp in the middle of data.
64const char kTimestampInMiddle[] = DATA "\n"
65                                  "timestamp=" ITOA(TIMESTAMP) "\n"
66                                  DATA;
67
68// A recent timestamp and data together.
69const char kTimestampHalfMonthAgo[] =
70    "timestamp=" ITOA(TIMESTAMP_HALF_MONTH_AGO) "\n"
71    DATA;
72
73// A stale timestamp and data together.
74const char kTimestampTwoMonthsAgo[] =
75    "timestamp=" ITOA(TIMESTAMP_TWO_MONTHS_AGO) "\n"
76    DATA;
77
78TEST(ValidatingUtilTest, UnwrapChecksum_CorruptedData) {
79  std::string data(kCorruptedChecksummedData);
80  EXPECT_FALSE(ValidatingUtil::UnwrapChecksum(&data));
81}
82
83TEST(ValidatingUtilTest, UnwrapChecksum_EmptyString) {
84  std::string data;
85  EXPECT_FALSE(ValidatingUtil::UnwrapChecksum(&data));
86}
87
88TEST(ValidatingUtilTest, UnwrapChecksum_GarbageData) {
89  std::string data("garbage");
90  EXPECT_FALSE(ValidatingUtil::UnwrapChecksum(&data));
91}
92
93TEST(ValidatingUtilTest, UnwrapChecksum_InMiddle) {
94  std::string data(kChecksumInMiddle);
95  EXPECT_FALSE(ValidatingUtil::UnwrapChecksum(&data));
96}
97
98TEST(ValidatingUtilTest, UnwrapChecksum) {
99  std::string data(kChecksummedData);
100  EXPECT_TRUE(ValidatingUtil::UnwrapChecksum(&data));
101  EXPECT_EQ(kUnwrappedData, data);
102}
103
104TEST(ValidatingUtilTest, UnwrapTimestamp_CorruptedData) {
105  std::string data(kCorruptedWrappedData);
106  EXPECT_FALSE(ValidatingUtil::UnwrapTimestamp(&data, kTimestamp));
107}
108
109TEST(ValidatingUtilTest, UnwrapTimestamp_EmptyString) {
110  std::string data;
111  EXPECT_FALSE(ValidatingUtil::UnwrapTimestamp(&data, kTimestamp));
112}
113
114TEST(ValidatingUtilTest, UnwrapTimestamp_GarbageData) {
115  std::string data("garbage");
116  EXPECT_FALSE(ValidatingUtil::UnwrapTimestamp(&data, kTimestamp));
117}
118
119TEST(ValidatingUtilTest, UnwrapTimestamp_InMiddle) {
120  std::string data(kTimestampInMiddle);
121  EXPECT_FALSE(ValidatingUtil::UnwrapTimestamp(&data, kTimestamp));
122}
123
124TEST(ValidatingUtilTest, UnwrapTimestamp_Recent) {
125  std::string data(kTimestampHalfMonthAgo);
126  EXPECT_TRUE(ValidatingUtil::UnwrapTimestamp(&data, kTimestamp));
127  EXPECT_EQ(kUnwrappedData, data);
128}
129
130TEST(ValidatingUtilTest, UnwrapTimestamp_Stale) {
131  std::string data(kTimestampTwoMonthsAgo);
132  EXPECT_FALSE(ValidatingUtil::UnwrapTimestamp(&data, kTimestamp));
133}
134
135TEST(ValidatingUtilTest, UnwrapTimestamp) {
136  std::string data(kWrappedData);
137  EXPECT_TRUE(ValidatingUtil::UnwrapTimestamp(&data, kTimestamp));
138  EXPECT_EQ(kChecksummedData, data);
139}
140
141TEST(ValidatingUtilTest, Wrap) {
142  std::string data = kUnwrappedData;
143  ValidatingUtil::Wrap(kTimestamp, &data);
144  EXPECT_EQ(kWrappedData, data);
145}
146
147TEST(ValidatingUtilTest, WrapUnwrapIt) {
148  std::string data = kUnwrappedData;
149  ValidatingUtil::Wrap(kTimestamp, &data);
150  EXPECT_TRUE(ValidatingUtil::UnwrapTimestamp(&data, kTimestamp));
151  EXPECT_EQ(kChecksummedData, data);
152  EXPECT_TRUE(ValidatingUtil::UnwrapChecksum(&data));
153  EXPECT_EQ(kUnwrappedData, data);
154}
155
156}  // namespace
157