?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Use temporary zoom level for virtual keyboard.
[chromium-blink-merge.git] / net / dns / mdns_cache_unittest.cc
blobc12ad6b6ec3c830fbb88489aea4d8c41df3ea5f4
1 // Copyright (c) 2013 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 <algorithm>
6
7 #include "base/bind.h"
8 #include "net/dns/dns_response.h"
9 #include "net/dns/dns_test_util.h"
10 #include "net/dns/mdns_cache.h"
11 #include "net/dns/record_parsed.h"
12 #include "net/dns/record_rdata.h"
13 #include "testing/gmock/include/gmock/gmock.h"
14 #include "testing/gtest/include/gtest/gtest.h"
15
16 using ::testing::Return;
17 using ::testing::StrictMock;
18
19 namespace net {
20
21 static const uint8 kTestResponsesDifferentAnswers[] = {
22 // Answer 1
23 // ghs.l.google.com in DNS format.
24 3, 'g', 'h', 's',
25 1, 'l',
26 6, 'g', 'o', 'o', 'g', 'l', 'e',
27 3, 'c', 'o', 'm',
28 0x00,
29 0x00, 0x01, // TYPE is A.
30 0x00, 0x01, // CLASS is IN.
31 0, 0, 0, 53, // TTL (4 bytes) is 53 seconds.
32 0, 4, // RDLENGTH is 4 bytes.
33 74, 125, 95, 121, // RDATA is the IP: 74.125.95.121
34
35 // Answer 2
36 // Pointer to answer 1
37 0xc0, 0x00,
38 0x00, 0x01, // TYPE is A.
39 0x00, 0x01, // CLASS is IN.
40 0, 0, 0, 53, // TTL (4 bytes) is 53 seconds.
41 0, 4, // RDLENGTH is 4 bytes.
42 74, 125, 95, 122, // RDATA is the IP: 74.125.95.122
43 };
44
45 static const uint8 kTestResponsesSameAnswers[] = {
46 // Answer 1
47 // ghs.l.google.com in DNS format.
48 3, 'g', 'h', 's',
49 1, 'l',
50 6, 'g', 'o', 'o', 'g', 'l', 'e',
51 3, 'c', 'o', 'm',
52 0x00,
53 0x00, 0x01, // TYPE is A.
54 0x00, 0x01, // CLASS is IN.
55 0, 0, 0, 53, // TTL (4 bytes) is 53 seconds.
56 0, 4, // RDLENGTH is 4 bytes.
57 74, 125, 95, 121, // RDATA is the IP: 74.125.95.121
58
59 // Answer 2
60 // Pointer to answer 1
61 0xc0, 0x00,
62 0x00, 0x01, // TYPE is A.
63 0x00, 0x01, // CLASS is IN.
64 0, 0, 0, 112, // TTL (4 bytes) is 112 seconds.
65 0, 4, // RDLENGTH is 4 bytes.
66 74, 125, 95, 121, // RDATA is the IP: 74.125.95.121
67 };
68
69 static const uint8 kTestResponseTwoRecords[] = {
70 // Answer 1
71 // ghs.l.google.com in DNS format. (A)
72 3, 'g', 'h', 's',
73 1, 'l',
74 6, 'g', 'o', 'o', 'g', 'l', 'e',
75 3, 'c', 'o', 'm',
76 0x00,
77 0x00, 0x01, // TYPE is A.
78 0x00, 0x01, // CLASS is IN.
79 0, 0, 0, 53, // TTL (4 bytes) is 53 seconds.
80 0, 4, // RDLENGTH is 4 bytes.
81 74, 125, 95, 121, // RDATA is the IP: 74.125.95.121
82
83 // Answer 2
84 // ghs.l.google.com in DNS format. (AAAA)
85 3, 'g', 'h', 's',
86 1, 'l',
87 6, 'g', 'o', 'o', 'g', 'l', 'e',
88 3, 'c', 'o', 'm',
89 0x00,
90 0x00, 0x1c, // TYPE is AAA.
91 0x00, 0x01, // CLASS is IN.
92 0, 0, 0, 53, // TTL (4 bytes) is 53 seconds.
93 0, 16, // RDLENGTH is 16 bytes.
94 0x4a, 0x7d, 0x4a, 0x7d,
95 0x5f, 0x79, 0x5f, 0x79,
96 0x5f, 0x79, 0x5f, 0x79,
97 0x5f, 0x79, 0x5f, 0x79,
98 };
99
100 static const uint8 kTestResponsesGoodbyePacket[] = {
101 // Answer 1
102 // ghs.l.google.com in DNS format. (Goodbye packet)
103 3, 'g', 'h', 's',
104 1, 'l',
105 6, 'g', 'o', 'o', 'g', 'l', 'e',
106 3, 'c', 'o', 'm',
107 0x00,
108 0x00, 0x01, // TYPE is A.
109 0x00, 0x01, // CLASS is IN.
110 0, 0, 0, 0, // TTL (4 bytes) is zero.
111 0, 4, // RDLENGTH is 4 bytes.
112 74, 125, 95, 121, // RDATA is the IP: 74.125.95.121
113
114 // Answer 2
115 // ghs.l.google.com in DNS format.
116 3, 'g', 'h', 's',
117 1, 'l',
118 6, 'g', 'o', 'o', 'g', 'l', 'e',
119 3, 'c', 'o', 'm',
120 0x00,
121 0x00, 0x01, // TYPE is A.
122 0x00, 0x01, // CLASS is IN.
123 0, 0, 0, 53, // TTL (4 bytes) is 53 seconds.
124 0, 4, // RDLENGTH is 4 bytes.
125 74, 125, 95, 121, // RDATA is the IP: 74.125.95.121
126 };
127
128 class RecordRemovalMock {
129 public:
130 MOCK_METHOD1(OnRecordRemoved, void(const RecordParsed*));
131 };
132
133 class MDnsCacheTest : public ::testing::Test {
134 public:
135 MDnsCacheTest()
136 : default_time_(base::Time::FromDoubleT(1234.0)) {}
137 virtual ~MDnsCacheTest() {}
138
139 protected:
140 base::Time default_time_;
141 StrictMock<RecordRemovalMock> record_removal_;
142 MDnsCache cache_;
143 };
144
145 // Test a single insert, corresponding lookup, and unsuccessful lookup.
146 TEST_F(MDnsCacheTest, InsertLookupSingle) {
147 DnsRecordParser parser(kT1ResponseDatagram, sizeof(kT1ResponseDatagram),
148 sizeof(dns_protocol::Header));
149 parser.SkipQuestion();
150
151 scoped_ptr<const RecordParsed> record1;
152 scoped_ptr<const RecordParsed> record2;
153 std::vector<const RecordParsed*> results;
154
155 record1 = RecordParsed::CreateFrom(&parser, default_time_);
156 record2 = RecordParsed::CreateFrom(&parser, default_time_);
157
158 EXPECT_EQ(MDnsCache::RecordAdded, cache_.UpdateDnsRecord(record1.Pass()));
159
160 EXPECT_EQ(MDnsCache::RecordAdded, cache_.UpdateDnsRecord(record2.Pass()));
161
162 cache_.FindDnsRecords(ARecordRdata::kType, "ghs.l.google.com", &results,
163 default_time_);
164
165 EXPECT_EQ(1u, results.size());
166 EXPECT_EQ(default_time_, results.front()->time_created());
167
168 EXPECT_EQ("ghs.l.google.com", results.front()->name());
169
170 results.clear();
171 cache_.FindDnsRecords(PtrRecordRdata::kType, "ghs.l.google.com", &results,
172 default_time_);
173
174 EXPECT_EQ(0u, results.size());
175 }
176
177 // Test that records expire when their ttl has passed.
178 TEST_F(MDnsCacheTest, Expiration) {
179 DnsRecordParser parser(kT1ResponseDatagram, sizeof(kT1ResponseDatagram),
180 sizeof(dns_protocol::Header));
181 parser.SkipQuestion();
182 scoped_ptr<const RecordParsed> record1;
183 scoped_ptr<const RecordParsed> record2;
184
185 std::vector<const RecordParsed*> results;
186 const RecordParsed* record_to_be_deleted;
187
188 record1 = RecordParsed::CreateFrom(&parser, default_time_);
189 base::TimeDelta ttl1 = base::TimeDelta::FromSeconds(record1->ttl());
190
191 record2 = RecordParsed::CreateFrom(&parser, default_time_);
192 base::TimeDelta ttl2 = base::TimeDelta::FromSeconds(record2->ttl());
193 record_to_be_deleted = record2.get();
194
195 EXPECT_EQ(MDnsCache::RecordAdded, cache_.UpdateDnsRecord(record1.Pass()));
196 EXPECT_EQ(MDnsCache::RecordAdded, cache_.UpdateDnsRecord(record2.Pass()));
197
198 cache_.FindDnsRecords(ARecordRdata::kType, "ghs.l.google.com", &results,
199 default_time_);
200
201 EXPECT_EQ(1u, results.size());
202
203 EXPECT_EQ(default_time_ + ttl2, cache_.next_expiration());
204
205
206 cache_.FindDnsRecords(ARecordRdata::kType, "ghs.l.google.com", &results,
207 default_time_ + ttl2);
208
209 EXPECT_EQ(0u, results.size());
210
211 EXPECT_CALL(record_removal_, OnRecordRemoved(record_to_be_deleted));
212
213 cache_.CleanupRecords(default_time_ + ttl2, base::Bind(
214 &RecordRemovalMock::OnRecordRemoved, base::Unretained(&record_removal_)));
215
216 // To make sure that we've indeed removed them from the map, check no funny
217 // business happens once they're deleted for good.
218
219 EXPECT_EQ(default_time_ + ttl1, cache_.next_expiration());
220 cache_.FindDnsRecords(ARecordRdata::kType, "ghs.l.google.com", &results,
221 default_time_ + ttl2);
222
223 EXPECT_EQ(0u, results.size());
224 }
225
226 // Test that a new record replacing one with the same identity (name/rrtype for
227 // unique records) causes the cache to output a "record changed" event.
228 TEST_F(MDnsCacheTest, RecordChange) {
229 DnsRecordParser parser(kTestResponsesDifferentAnswers,
230 sizeof(kTestResponsesDifferentAnswers),
231 0);
232
233 scoped_ptr<const RecordParsed> record1;
234 scoped_ptr<const RecordParsed> record2;
235 std::vector<const RecordParsed*> results;
236
237 record1 = RecordParsed::CreateFrom(&parser, default_time_);
238 record2 = RecordParsed::CreateFrom(&parser, default_time_);
239
240 EXPECT_EQ(MDnsCache::RecordAdded, cache_.UpdateDnsRecord(record1.Pass()));
241 EXPECT_EQ(MDnsCache::RecordChanged,
242 cache_.UpdateDnsRecord(record2.Pass()));
243 }
244
245 // Test that a new record replacing an otherwise identical one already in the
246 // cache causes the cache to output a "no change" event.
247 TEST_F(MDnsCacheTest, RecordNoChange) {
248 DnsRecordParser parser(kTestResponsesSameAnswers,
249 sizeof(kTestResponsesSameAnswers),
250 0);
251
252 scoped_ptr<const RecordParsed> record1;
253 scoped_ptr<const RecordParsed> record2;
254 std::vector<const RecordParsed*> results;
255
256 record1 = RecordParsed::CreateFrom(&parser, default_time_);
257 record2 = RecordParsed::CreateFrom(&parser, default_time_ +
258 base::TimeDelta::FromSeconds(1));
259
260 EXPECT_EQ(MDnsCache::RecordAdded, cache_.UpdateDnsRecord(record1.Pass()));
261 EXPECT_EQ(MDnsCache::NoChange, cache_.UpdateDnsRecord(record2.Pass()));
262 }
263
264 // Test that the next expiration time of the cache is updated properly on record
265 // insertion.
266 TEST_F(MDnsCacheTest, RecordPreemptExpirationTime) {
267 DnsRecordParser parser(kTestResponsesSameAnswers,
268 sizeof(kTestResponsesSameAnswers),
269 0);
270
271 scoped_ptr<const RecordParsed> record1;
272 scoped_ptr<const RecordParsed> record2;
273 std::vector<const RecordParsed*> results;
274
275 record1 = RecordParsed::CreateFrom(&parser, default_time_);
276 record2 = RecordParsed::CreateFrom(&parser, default_time_);
277 base::TimeDelta ttl1 = base::TimeDelta::FromSeconds(record1->ttl());
278 base::TimeDelta ttl2 = base::TimeDelta::FromSeconds(record2->ttl());
279
280 EXPECT_EQ(base::Time(), cache_.next_expiration());
281 EXPECT_EQ(MDnsCache::RecordAdded, cache_.UpdateDnsRecord(record2.Pass()));
282 EXPECT_EQ(default_time_ + ttl2, cache_.next_expiration());
283 EXPECT_EQ(MDnsCache::NoChange, cache_.UpdateDnsRecord(record1.Pass()));
284 EXPECT_EQ(default_time_ + ttl1, cache_.next_expiration());
285 }
286
287 // Test that the cache handles mDNS "goodbye" packets correctly, not adding the
288 // records to the cache if they are not already there, and eventually removing
289 // records from the cache if they are.
290 TEST_F(MDnsCacheTest, GoodbyePacket) {
291 DnsRecordParser parser(kTestResponsesGoodbyePacket,
292 sizeof(kTestResponsesGoodbyePacket),
293 0);
294
295 scoped_ptr<const RecordParsed> record_goodbye;
296 scoped_ptr<const RecordParsed> record_hello;
297 scoped_ptr<const RecordParsed> record_goodbye2;
298 std::vector<const RecordParsed*> results;
299
300 record_goodbye = RecordParsed::CreateFrom(&parser, default_time_);
301 record_hello = RecordParsed::CreateFrom(&parser, default_time_);
302 parser = DnsRecordParser(kTestResponsesGoodbyePacket,
303 sizeof(kTestResponsesGoodbyePacket),
304 0);
305 record_goodbye2 = RecordParsed::CreateFrom(&parser, default_time_);
306
307 base::TimeDelta ttl = base::TimeDelta::FromSeconds(record_hello->ttl());
308
309 EXPECT_EQ(base::Time(), cache_.next_expiration());
310 EXPECT_EQ(MDnsCache::NoChange, cache_.UpdateDnsRecord(record_goodbye.Pass()));
311 EXPECT_EQ(base::Time(), cache_.next_expiration());
312 EXPECT_EQ(MDnsCache::RecordAdded,
313 cache_.UpdateDnsRecord(record_hello.Pass()));
314 EXPECT_EQ(default_time_ + ttl, cache_.next_expiration());
315 EXPECT_EQ(MDnsCache::NoChange,
316 cache_.UpdateDnsRecord(record_goodbye2.Pass()));
317 EXPECT_EQ(default_time_ + base::TimeDelta::FromSeconds(1),
318 cache_.next_expiration());
319 }
320
321 TEST_F(MDnsCacheTest, AnyRRType) {
322 DnsRecordParser parser(kTestResponseTwoRecords,
323 sizeof(kTestResponseTwoRecords),
324 0);
325
326 scoped_ptr<const RecordParsed> record1;
327 scoped_ptr<const RecordParsed> record2;
328 std::vector<const RecordParsed*> results;
329
330 record1 = RecordParsed::CreateFrom(&parser, default_time_);
331 record2 = RecordParsed::CreateFrom(&parser, default_time_);
332 EXPECT_EQ(MDnsCache::RecordAdded, cache_.UpdateDnsRecord(record1.Pass()));
333 EXPECT_EQ(MDnsCache::RecordAdded, cache_.UpdateDnsRecord(record2.Pass()));
334
335 cache_.FindDnsRecords(0, "ghs.l.google.com", &results, default_time_);
336
337 EXPECT_EQ(2u, results.size());
338 EXPECT_EQ(default_time_, results.front()->time_created());
339
340 EXPECT_EQ("ghs.l.google.com", results[0]->name());
341 EXPECT_EQ("ghs.l.google.com", results[1]->name());
342 EXPECT_EQ(dns_protocol::kTypeA,
343 std::min(results[0]->type(), results[1]->type()));
344 EXPECT_EQ(dns_protocol::kTypeAAAA,
345 std::max(results[0]->type(), results[1]->type()));
346 }
347
348 TEST_F(MDnsCacheTest, RemoveRecord) {
349 DnsRecordParser parser(kT1ResponseDatagram, sizeof(kT1ResponseDatagram),
350 sizeof(dns_protocol::Header));
351 parser.SkipQuestion();
352
353 scoped_ptr<const RecordParsed> record1;
354 std::vector<const RecordParsed*> results;
355
356 record1 = RecordParsed::CreateFrom(&parser, default_time_);
357 EXPECT_EQ(MDnsCache::RecordAdded, cache_.UpdateDnsRecord(record1.Pass()));
358
359 cache_.FindDnsRecords(dns_protocol::kTypeCNAME, "codereview.chromium.org",
360 &results, default_time_);
361
362 EXPECT_EQ(1u, results.size());
363
364 scoped_ptr<const RecordParsed> record_out =
365 cache_.RemoveRecord(results.front());
366
367 EXPECT_EQ(record_out.get(), results.front());
368
369 cache_.FindDnsRecords(dns_protocol::kTypeCNAME, "codereview.chromium.org",
370 &results, default_time_);
371
372 EXPECT_EQ(0u, results.size());
373 }
374
375 } // namespace net