blob: d3adb3995fd6ae3e403b1dd5d9d829f694036211 [file] [log] [blame]
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "tools/json_schema_compiler/test/simple_api.h"
#include <memory>
#include <string>
#include "base/json/json_reader.h"
#include "base/strings/utf_string_conversions.h"
#include "base/values.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "tools/json_schema_compiler/test/enums.h"
namespace simple_api = test::api::simple_api;
namespace enums = test::api::enums;
namespace {
static std::unique_ptr<base::DictionaryValue> CreateTestTypeDictionary() {
auto value = std::make_unique<base::DictionaryValue>();
value->SetKey("number", base::Value(1.1));
value->SetKey("integer", base::Value(4));
value->SetKey("string", base::Value("bling"));
value->SetKey("boolean", base::Value(true));
return value;
}
void GetManifestParseError(base::StringPiece manifest_json,
std::string* error) {
base::Optional<base::Value> manifest = base::JSONReader::Read(manifest_json);
ASSERT_TRUE(manifest);
simple_api::ManifestKeys manifest_keys;
base::string16 error_16;
bool result = simple_api::ManifestKeys::ParseFromDictionary(
base::Value::AsDictionaryValue(*manifest), &manifest_keys, &error_16);
ASSERT_FALSE(result);
*error = base::UTF16ToASCII(error_16);
}
void PopulateManifestKeys(base::StringPiece manifest_json,
simple_api::ManifestKeys* manifest_keys) {
base::Optional<base::Value> manifest = base::JSONReader::Read(manifest_json);
ASSERT_TRUE(manifest.has_value());
base::string16 error_16;
bool result = simple_api::ManifestKeys::ParseFromDictionary(
base::Value::AsDictionaryValue(*manifest), manifest_keys, &error_16);
ASSERT_TRUE(result) << error_16;
ASSERT_TRUE(error_16.empty()) << error_16;
}
} // namespace
TEST(JsonSchemaCompilerSimpleTest, IncrementIntegerResultCreate) {
std::unique_ptr<base::ListValue> results =
simple_api::IncrementInteger::Results::Create(5);
base::ListValue expected;
expected.AppendInteger(5);
EXPECT_TRUE(results->Equals(&expected));
}
TEST(JsonSchemaCompilerSimpleTest, IncrementIntegerParamsCreate) {
auto params_value = std::make_unique<base::ListValue>();
params_value->AppendInteger(6);
std::unique_ptr<simple_api::IncrementInteger::Params> params(
simple_api::IncrementInteger::Params::Create(*params_value));
EXPECT_TRUE(params.get());
EXPECT_EQ(6, params->num);
}
TEST(JsonSchemaCompilerSimpleTest, NumberOfParams) {
{
auto params_value = std::make_unique<base::ListValue>();
params_value->AppendString("text");
params_value->AppendString("text");
std::unique_ptr<simple_api::OptionalString::Params> params(
simple_api::OptionalString::Params::Create(*params_value));
EXPECT_FALSE(params.get());
}
{
auto params_value = std::make_unique<base::ListValue>();
std::unique_ptr<simple_api::IncrementInteger::Params> params(
simple_api::IncrementInteger::Params::Create(*params_value));
EXPECT_FALSE(params.get());
}
}
TEST(JsonSchemaCompilerSimpleTest, OptionalStringParamsCreate) {
{
auto params_value = std::make_unique<base::ListValue>();
std::unique_ptr<simple_api::OptionalString::Params> params(
simple_api::OptionalString::Params::Create(*params_value));
EXPECT_TRUE(params.get());
EXPECT_FALSE(params->str.get());
}
{
auto params_value = std::make_unique<base::ListValue>();
params_value->AppendString("asdf");
std::unique_ptr<simple_api::OptionalString::Params> params(
simple_api::OptionalString::Params::Create(*params_value));
EXPECT_TRUE(params.get());
EXPECT_TRUE(params->str.get());
EXPECT_EQ("asdf", *params->str);
}
}
TEST(JsonSchemaCompilerSimpleTest, OptionalParamsTakingNull) {
{
auto params_value = std::make_unique<base::ListValue>();
params_value->Append(std::make_unique<base::Value>());
std::unique_ptr<simple_api::OptionalString::Params> params(
simple_api::OptionalString::Params::Create(*params_value));
EXPECT_TRUE(params.get());
EXPECT_FALSE(params->str.get());
}
}
TEST(JsonSchemaCompilerSimpleTest, OptionalStringParamsWrongType) {
{
auto params_value = std::make_unique<base::ListValue>();
params_value->AppendInteger(5);
std::unique_ptr<simple_api::OptionalString::Params> params(
simple_api::OptionalString::Params::Create(*params_value));
EXPECT_FALSE(params.get());
}
}
TEST(JsonSchemaCompilerSimpleTest, OptionalBeforeRequired) {
{
auto params_value = std::make_unique<base::ListValue>();
params_value->Append(std::make_unique<base::Value>());
params_value->AppendString("asdf");
std::unique_ptr<simple_api::OptionalBeforeRequired::Params> params(
simple_api::OptionalBeforeRequired::Params::Create(*params_value));
EXPECT_TRUE(params.get());
EXPECT_FALSE(params->first.get());
EXPECT_EQ("asdf", params->second);
}
}
TEST(JsonSchemaCompilerSimpleTest, NoParamsResultCreate) {
std::unique_ptr<base::ListValue> results =
simple_api::OptionalString::Results::Create();
base::ListValue expected;
EXPECT_TRUE(results->Equals(&expected));
}
TEST(JsonSchemaCompilerSimpleTest, TestTypePopulate) {
{
auto test_type = std::make_unique<simple_api::TestType>();
std::unique_ptr<base::DictionaryValue> value = CreateTestTypeDictionary();
EXPECT_TRUE(simple_api::TestType::Populate(*value, test_type.get()));
EXPECT_EQ("bling", test_type->string);
EXPECT_EQ(1.1, test_type->number);
EXPECT_EQ(4, test_type->integer);
EXPECT_EQ(true, test_type->boolean);
EXPECT_TRUE(value->Equals(test_type->ToValue().get()));
}
{
auto test_type = std::make_unique<simple_api::TestType>();
std::unique_ptr<base::DictionaryValue> value = CreateTestTypeDictionary();
value->Remove("number", NULL);
EXPECT_FALSE(simple_api::TestType::Populate(*value, test_type.get()));
}
}
TEST(JsonSchemaCompilerSimpleTest, GetTestType) {
{
std::unique_ptr<base::DictionaryValue> value = CreateTestTypeDictionary();
auto test_type = std::make_unique<simple_api::TestType>();
EXPECT_TRUE(simple_api::TestType::Populate(*value, test_type.get()));
std::unique_ptr<base::ListValue> results =
simple_api::GetTestType::Results::Create(*test_type);
base::DictionaryValue* result = NULL;
results->GetDictionary(0, &result);
EXPECT_TRUE(result->Equals(value.get()));
}
}
TEST(JsonSchemaCompilerSimpleTest, OnIntegerFiredCreate) {
{
std::unique_ptr<base::ListValue> results(
simple_api::OnIntegerFired::Create(5));
base::ListValue expected;
expected.AppendInteger(5);
EXPECT_TRUE(results->Equals(&expected));
}
}
TEST(JsonSchemaCompilerSimpleTest, OnStringFiredCreate) {
{
std::unique_ptr<base::ListValue> results(
simple_api::OnStringFired::Create("yo dawg"));
base::ListValue expected;
expected.AppendString("yo dawg");
EXPECT_TRUE(results->Equals(&expected));
}
}
TEST(JsonSchemaCompilerSimpleTest, OnTestTypeFiredCreate) {
{
simple_api::TestType some_test_type;
std::unique_ptr<base::DictionaryValue> expected =
CreateTestTypeDictionary();
ASSERT_TRUE(expected->GetDouble("number", &some_test_type.number));
ASSERT_TRUE(expected->GetString("string", &some_test_type.string));
ASSERT_TRUE(expected->GetInteger("integer", &some_test_type.integer));
ASSERT_TRUE(expected->GetBoolean("boolean", &some_test_type.boolean));
std::unique_ptr<base::ListValue> results(
simple_api::OnTestTypeFired::Create(some_test_type));
base::DictionaryValue* result = NULL;
results->GetDictionary(0, &result);
EXPECT_TRUE(result->Equals(expected.get()));
}
}
TEST(JsonSchemaCompilerSimpleTest, ManifestKeyParsing_RequiredKeyError) {
const char kPartialManifestJson[] = R"({
"key_string": "abc",
"key_ref": {
"string": "ref_string",
"boolean": true,
"number": 25.4
}
})";
std::string error;
ASSERT_NO_FATAL_FAILURE(GetManifestParseError(kPartialManifestJson, &error));
EXPECT_EQ("Error at key 'key_ref.integer'. Manifest key is required.", error);
}
TEST(JsonSchemaCompilerSimpleTest, ManifestKeyParsing_InvalidTypeError) {
const char kPartialManifestJson[] = R"({
"key_string": "abc",
"key_ref": {
"string": "ref_string",
"boolean": true,
"number": 25.4,
"integer": 32,
"object": {
"foo": "bar"
},
"key_enum": "one"
}
})";
std::string error;
ASSERT_NO_FATAL_FAILURE(GetManifestParseError(kPartialManifestJson, &error));
EXPECT_EQ(
"Error at key 'key_ref.object.foo'. Type is invalid. Expected integer, "
"found string.",
error);
}
TEST(JsonSchemaCompilerSimpleTest, ManifestKeyParsing_ArrayParseError) {
const char kPartialManifestJson[] = R"({
"key_string": "abc",
"key_ref": {
"string": "ref_string",
"boolean": true,
"number": 25.4,
"integer": 32,
"array": ["one", "two", 3]
},
"key_enum": "one"
})";
std::string error;
ASSERT_NO_FATAL_FAILURE(GetManifestParseError(kPartialManifestJson, &error));
EXPECT_EQ(
"Error at key 'key_ref.array'. Parsing array failed: expected string, "
"got integer.",
error);
}
TEST(JsonSchemaCompilerSimpleTest, ManifestKeyParsing_InvalidEnumValue) {
const char kPartialManifestJson[] = R"({
"key_string": "abc",
"key_ref": {
"string": "ref_string",
"boolean": true,
"number": 25.4,
"integer": 32,
"opt_external_enum": "four"
},
"key_enum": "one"
})";
std::string error;
ASSERT_NO_FATAL_FAILURE(GetManifestParseError(kPartialManifestJson, &error));
EXPECT_EQ(
"Error at key 'key_ref.opt_external_enum'. Specified value 'four' is "
"invalid.",
error);
}
TEST(JsonSchemaCompilerSimpleTest, ManifestKeyParsing_Success_AllKeys) {
const char kPartialManifestJson[] = R"({
"key_string": "abc",
"key_ref": {
"string": "ref_string",
"boolean": true,
"number": 25.4,
"integer": 32,
"object": {
"foo": 42
},
"array": ["one", "two"],
"opt_external_enum": "two"
},
"key_obj": {
"obj_string": "foo",
"obj_bool": true
},
"key_enum": "one"
})";
simple_api::ManifestKeys manifest_keys;
ASSERT_NO_FATAL_FAILURE(
PopulateManifestKeys(kPartialManifestJson, &manifest_keys));
EXPECT_EQ("abc", manifest_keys.key_string);
ASSERT_TRUE(manifest_keys.key_obj);
EXPECT_EQ("foo", manifest_keys.key_obj->obj_string);
EXPECT_TRUE(manifest_keys.key_obj->obj_bool);
EXPECT_EQ(simple_api::TEST_ENUM_ONE, manifest_keys.key_enum);
EXPECT_EQ("ref_string", manifest_keys.key_ref.string);
EXPECT_EQ(true, manifest_keys.key_ref.boolean);
EXPECT_DOUBLE_EQ(25.4, manifest_keys.key_ref.number);
EXPECT_EQ(32, manifest_keys.key_ref.integer);
ASSERT_TRUE(manifest_keys.key_ref.object);
EXPECT_EQ(42, manifest_keys.key_ref.object->foo);
ASSERT_TRUE(manifest_keys.key_ref.array);
EXPECT_THAT(*manifest_keys.key_ref.array,
::testing::ElementsAre("one", "two"));
EXPECT_EQ(enums::ENUMERATION_TWO, manifest_keys.key_ref.opt_external_enum);
}
// Ensure leaving out optional keys is not a manifest parse error.
TEST(JsonSchemaCompilerSimpleTest,
ManifestKeyParsing_Success_OptionalKeysIgnored) {
const char kPartialManifestJson[] = R"({
"key_string": "abc",
"key_ref": {
"string": "ref_string",
"boolean": true,
"number": 25.4,
"integer": 32
},
"key_enum": "two"
})";
simple_api::ManifestKeys manifest_keys;
ASSERT_NO_FATAL_FAILURE(
PopulateManifestKeys(kPartialManifestJson, &manifest_keys));
EXPECT_EQ("abc", manifest_keys.key_string);
EXPECT_FALSE(manifest_keys.key_obj);
EXPECT_EQ(simple_api::TEST_ENUM_TWO, manifest_keys.key_enum);
EXPECT_EQ("ref_string", manifest_keys.key_ref.string);
EXPECT_EQ(true, manifest_keys.key_ref.boolean);
EXPECT_DOUBLE_EQ(25.4, manifest_keys.key_ref.number);
EXPECT_EQ(32, manifest_keys.key_ref.integer);
EXPECT_FALSE(manifest_keys.key_ref.array);
EXPECT_EQ(enums::ENUMERATION_NONE, manifest_keys.key_ref.opt_external_enum);
}