sync/test/fake_server/fake_server_verifier.cc

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