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 "sync/test/fake_server/fake_server_verifier.h"
6
7#include "base/memory/scoped_ptr.h"
8#include "base/values.h"
9#include "sync/internal_api/public/base/model_type.h"
10#include "sync/test/fake_server/fake_server.h"
11#include "testing/gtest/include/gtest/gtest.h"
12
13using std::string;
14using testing::AssertionFailure;
15using testing::AssertionResult;
16using testing::AssertionSuccess;
17
18namespace {
19
20AssertionResult DictionaryCreationAssertionFailure() {
21  return AssertionFailure() << "FakeServer failed to create an entities "
22                            << "dictionary.";
23}
24
25AssertionResult VerificationCountAssertionFailure(size_t actual_count,
26                                                  size_t expected_count) {
27  return AssertionFailure() << "Actual count: " << actual_count << "; "
28                            << "Expected count: " << expected_count;
29}
30
31AssertionResult UnknownTypeAssertionFailure(const string& model_type) {
32  return AssertionFailure() << "Verification not attempted. Unknown ModelType: "
33                            << model_type;
34}
35
36}  // namespace
37
38namespace fake_server {
39
40FakeServerVerifier::FakeServerVerifier(FakeServer* fake_server)
41    : fake_server_(fake_server) { }
42
43FakeServerVerifier::~FakeServerVerifier() {}
44
45AssertionResult FakeServerVerifier::VerifyEntityCountByType(
46    size_t expected_count,
47    syncer::ModelType model_type) const {
48  scoped_ptr<base::DictionaryValue> entities =
49      fake_server_->GetEntitiesAsDictionaryValue();
50  if (!entities.get()) {
51    return DictionaryCreationAssertionFailure();
52  }
53
54  string model_type_string = ModelTypeToString(model_type);
55  base::ListValue* entity_list = NULL;
56  if (!entities->GetList(model_type_string, &entity_list)) {
57    return UnknownTypeAssertionFailure(model_type_string);
58  } else if  (expected_count != entity_list->GetSize()) {
59    return VerificationCountAssertionFailure(entity_list->GetSize(),
60                                             expected_count);
61  }
62
63  return AssertionSuccess();
64}
65
66AssertionResult FakeServerVerifier::VerifyEntityCountByTypeAndName(
67    size_t expected_count,
68    syncer::ModelType model_type,
69    const string& name) const {
70  scoped_ptr<base::DictionaryValue> entities =
71      fake_server_->GetEntitiesAsDictionaryValue();
72  if (!entities.get()) {
73    return DictionaryCreationAssertionFailure();
74  }
75
76  string model_type_string = ModelTypeToString(model_type);
77  base::ListValue* entity_list = NULL;
78  size_t actual_count = 0;
79  if (entities->GetList(model_type_string, &entity_list)) {
80    scoped_ptr<base::Value> name_value(new base::StringValue(name));
81    for (base::ListValue::const_iterator it = entity_list->begin();
82         it != entity_list->end(); ++it) {
83      if (name_value->Equals(*it)) {
84        actual_count++;
85      }
86    }
87  }
88
89  if (!entity_list) {
90    return UnknownTypeAssertionFailure(model_type_string);
91  } else if (actual_count != expected_count) {
92    return VerificationCountAssertionFailure(actual_count, expected_count)
93        << "; Name: " << name;
94  }
95
96  return AssertionSuccess();
97}
98
99}  // namespace fake_server
100