Index: extensions/renderer/argument_spec_unittest.cc |
diff --git a/extensions/renderer/argument_spec_unittest.cc b/extensions/renderer/argument_spec_unittest.cc |
index 4bf8d256907215398643ac866457d2cf37a0de30..fd89e5f423159dee1699d857f84850da7378c889 100644 |
--- a/extensions/renderer/argument_spec_unittest.cc |
+++ b/extensions/renderer/argument_spec_unittest.cc |
@@ -2,11 +2,12 @@ |
// Use of this source code is governed by a BSD-style license that can be |
// found in the LICENSE file. |
+#include "extensions/renderer/argument_spec.h" |
#include "base/memory/ptr_util.h" |
#include "base/values.h" |
#include "extensions/renderer/api_binding_test_util.h" |
+#include "extensions/renderer/api_invocation_errors.h" |
#include "extensions/renderer/api_type_reference_map.h" |
-#include "extensions/renderer/argument_spec.h" |
#include "gin/converter.h" |
#include "gin/public/isolate_holder.h" |
#include "gin/test/v8_test.h" |
@@ -20,44 +21,77 @@ class ArgumentSpecUnitTest : public gin::V8Test { |
ArgumentSpecUnitTest() |
: type_refs_(APITypeReferenceMap::InitializeTypeCallback()) {} |
~ArgumentSpecUnitTest() override {} |
+ |
+ enum class TestResult { |
+ PASS, |
+ FAIL, |
+ THROW, |
+ }; |
+ |
+ struct RunTestParams { |
+ RunTestParams(const ArgumentSpec& spec, |
+ base::StringPiece script_source, |
+ TestResult result) |
+ : spec(spec), script_source(script_source), expected_result(result) {} |
+ |
+ const ArgumentSpec& spec; |
+ base::StringPiece script_source; |
+ TestResult expected_result; |
+ base::StringPiece expected_json; |
+ base::StringPiece expected_error; |
+ base::StringPiece expected_thrown_message; |
+ const base::Value* expected_value = nullptr; |
+ bool should_convert = true; |
+ }; |
+ |
void ExpectSuccess(const ArgumentSpec& spec, |
const std::string& script_source, |
const std::string& expected_json_single_quotes) { |
- RunTest(spec, script_source, true, TestResult::PASS, |
- ReplaceSingleQuotes(expected_json_single_quotes), nullptr, |
- std::string()); |
+ RunTestParams params(spec, script_source, TestResult::PASS); |
+ std::string expected_json = |
+ ReplaceSingleQuotes(expected_json_single_quotes); |
+ params.expected_json = expected_json; |
+ RunTest(params); |
} |
void ExpectSuccess(const ArgumentSpec& spec, |
const std::string& script_source, |
const base::Value& expected_value) { |
- RunTest(spec, script_source, true, TestResult::PASS, std::string(), |
- &expected_value, std::string()); |
+ RunTestParams params(spec, script_source, TestResult::PASS); |
+ params.expected_value = &expected_value; |
+ RunTest(params); |
} |
void ExpectSuccessWithNoConversion(const ArgumentSpec& spec, |
const std::string& script_source) { |
- RunTest(spec, script_source, false, TestResult::PASS, std::string(), |
- nullptr, std::string()); |
+ RunTestParams params(spec, script_source, TestResult::PASS); |
+ params.should_convert = false; |
+ RunTest(params); |
} |
void ExpectFailure(const ArgumentSpec& spec, |
- const std::string& script_source) { |
- RunTest(spec, script_source, true, TestResult::FAIL, std::string(), nullptr, |
- std::string()); |
+ const std::string& script_source, |
+ const std::string& expected_error) { |
+ RunTestParams params(spec, script_source, TestResult::FAIL); |
+ params.expected_error = expected_error; |
+ RunTest(params); |
} |
void ExpectFailureWithNoConversion(const ArgumentSpec& spec, |
- const std::string& script_source) { |
- RunTest(spec, script_source, false, TestResult::FAIL, std::string(), |
- nullptr, std::string()); |
+ const std::string& script_source, |
+ const std::string& expected_error) { |
+ RunTestParams params(spec, script_source, TestResult::FAIL); |
+ params.should_convert = false; |
+ params.expected_error = expected_error; |
+ RunTest(params); |
} |
void ExpectThrow(const ArgumentSpec& spec, |
const std::string& script_source, |
const std::string& expected_thrown_message) { |
- RunTest(spec, script_source, true, TestResult::THROW, std::string(), |
- nullptr, expected_thrown_message); |
+ RunTestParams params(spec, script_source, TestResult::THROW); |
+ params.expected_thrown_message = expected_thrown_message; |
+ RunTest(params); |
} |
void AddTypeRef(const std::string& id, std::unique_ptr<ArgumentSpec> spec) { |
@@ -65,73 +99,74 @@ class ArgumentSpecUnitTest : public gin::V8Test { |
} |
private: |
- enum class TestResult { PASS, FAIL, THROW, }; |
- |
- void RunTest(const ArgumentSpec& spec, |
- const std::string& script_source, |
- bool should_convert, |
- TestResult expected_result, |
- const std::string& expected_json, |
- const base::Value* expected_value, |
- const std::string& expected_thrown_message); |
+ void RunTest(const RunTestParams& params); |
APITypeReferenceMap type_refs_; |
DISALLOW_COPY_AND_ASSIGN(ArgumentSpecUnitTest); |
}; |
-void ArgumentSpecUnitTest::RunTest(const ArgumentSpec& spec, |
- const std::string& script_source, |
- bool should_convert, |
- TestResult expected_result, |
- const std::string& expected_json, |
- const base::Value* expected_value, |
- const std::string& expected_thrown_message) { |
+void ArgumentSpecUnitTest::RunTest(const RunTestParams& params) { |
v8::Isolate* isolate = instance_->isolate(); |
v8::HandleScope handle_scope(instance_->isolate()); |
v8::Local<v8::Context> context = |
v8::Local<v8::Context>::New(instance_->isolate(), context_); |
v8::TryCatch try_catch(isolate); |
- v8::Local<v8::Value> val = V8ValueFromScriptSource(context, script_source); |
- ASSERT_FALSE(val.IsEmpty()) << script_source; |
+ v8::Local<v8::Value> val = |
+ V8ValueFromScriptSource(context, params.script_source); |
+ ASSERT_FALSE(val.IsEmpty()) << params.script_source; |
std::string error; |
std::unique_ptr<base::Value> out_value; |
- bool did_succeed = |
- spec.ParseArgument(context, val, type_refs_, |
- should_convert ? &out_value : nullptr, &error); |
- bool should_succeed = expected_result == TestResult::PASS; |
- ASSERT_EQ(should_succeed, did_succeed) << script_source << ", " << error; |
- ASSERT_EQ(did_succeed && should_convert, !!out_value); |
- bool should_throw = expected_result == TestResult::THROW; |
- ASSERT_EQ(should_throw, try_catch.HasCaught()) << script_source; |
- if (should_succeed && should_convert) { |
+ bool did_succeed = params.spec.ParseArgument( |
+ context, val, type_refs_, params.should_convert ? &out_value : nullptr, |
+ &error); |
+ bool should_succeed = params.expected_result == TestResult::PASS; |
+ ASSERT_EQ(should_succeed, did_succeed) |
+ << params.script_source << ", " << error; |
+ ASSERT_EQ(did_succeed && params.should_convert, !!out_value); |
+ bool should_throw = params.expected_result == TestResult::THROW; |
+ ASSERT_EQ(should_throw, try_catch.HasCaught()) << params.script_source; |
+ |
+ if (!params.expected_error.empty()) |
+ EXPECT_EQ(params.expected_error, error) << params.script_source; |
+ |
+ if (should_succeed && params.should_convert) { |
ASSERT_TRUE(out_value); |
- if (expected_value) |
- EXPECT_TRUE(expected_value->Equals(out_value.get())) << script_source; |
+ if (params.expected_value) |
+ EXPECT_TRUE(params.expected_value->Equals(out_value.get())) |
+ << params.script_source; |
else |
- EXPECT_EQ(expected_json, ValueToString(*out_value)); |
+ EXPECT_EQ(params.expected_json, ValueToString(*out_value)); |
} else if (should_throw) { |
- EXPECT_EQ(expected_thrown_message, |
+ EXPECT_EQ(params.expected_thrown_message, |
gin::V8ToString(try_catch.Message()->Get())); |
} |
} |
TEST_F(ArgumentSpecUnitTest, Test) { |
+ using namespace api_errors; |
+ |
+ // Shorthand for getting an invalid type error. |
+ auto invalid_type = [](const char* expected, const char* actual) { |
+ return GetError(kInvalidType, expected, actual); |
+ }; |
+ |
{ |
ArgumentSpec spec(*ValueFromString("{'type': 'integer'}")); |
ExpectSuccess(spec, "1", "1"); |
ExpectSuccess(spec, "-1", "-1"); |
ExpectSuccess(spec, "0", "0"); |
ExpectSuccess(spec, "0.0", "0"); |
- ExpectFailure(spec, "undefined"); |
- ExpectFailure(spec, "null"); |
- ExpectFailure(spec, "1.1"); |
- ExpectFailure(spec, "'foo'"); |
- ExpectFailure(spec, "'1'"); |
- ExpectFailure(spec, "{}"); |
- ExpectFailure(spec, "[1]"); |
+ ExpectFailure(spec, "undefined", |
+ invalid_type(kTypeInteger, kTypeUndefined)); |
+ ExpectFailure(spec, "null", invalid_type(kTypeInteger, kTypeNull)); |
+ ExpectFailure(spec, "1.1", invalid_type(kTypeInteger, kTypeDouble)); |
+ ExpectFailure(spec, "'foo'", invalid_type(kTypeInteger, kTypeString)); |
+ ExpectFailure(spec, "'1'", invalid_type(kTypeInteger, kTypeString)); |
+ ExpectFailure(spec, "({})", invalid_type(kTypeInteger, kTypeObject)); |
+ ExpectFailure(spec, "[1]", invalid_type(kTypeInteger, kTypeList)); |
} |
{ |
@@ -142,36 +177,36 @@ TEST_F(ArgumentSpecUnitTest, Test) { |
ExpectSuccess(spec, "1.1", "1.1"); |
ExpectSuccess(spec, "1.", "1.0"); |
ExpectSuccess(spec, ".1", "0.1"); |
- ExpectFailure(spec, "undefined"); |
- ExpectFailure(spec, "null"); |
- ExpectFailure(spec, "'foo'"); |
- ExpectFailure(spec, "'1.1'"); |
- ExpectFailure(spec, "{}"); |
- ExpectFailure(spec, "[1.1]"); |
+ ExpectFailure(spec, "undefined", invalid_type(kTypeDouble, kTypeUndefined)); |
+ ExpectFailure(spec, "null", invalid_type(kTypeDouble, kTypeNull)); |
+ ExpectFailure(spec, "'foo'", invalid_type(kTypeDouble, kTypeString)); |
+ ExpectFailure(spec, "'1.1'", invalid_type(kTypeDouble, kTypeString)); |
+ ExpectFailure(spec, "({})", invalid_type(kTypeDouble, kTypeObject)); |
+ ExpectFailure(spec, "[1.1]", invalid_type(kTypeDouble, kTypeList)); |
} |
{ |
ArgumentSpec spec(*ValueFromString("{'type': 'integer', 'minimum': 1}")); |
ExpectSuccess(spec, "2", "2"); |
ExpectSuccess(spec, "1", "1"); |
- ExpectFailure(spec, "0"); |
- ExpectFailure(spec, "-1"); |
+ ExpectFailure(spec, "0", GetError(kNumberTooSmall, 1)); |
+ ExpectFailure(spec, "-1", GetError(kNumberTooSmall, 1)); |
} |
{ |
ArgumentSpec spec(*ValueFromString("{'type': 'integer', 'maximum': 10}")); |
ExpectSuccess(spec, "10", "10"); |
ExpectSuccess(spec, "1", "1"); |
- ExpectFailure(spec, "11"); |
+ ExpectFailure(spec, "11", GetError(kNumberTooLarge, 10)); |
} |
{ |
ArgumentSpec spec(*ValueFromString("{'type': 'string'}")); |
ExpectSuccess(spec, "'foo'", "'foo'"); |
ExpectSuccess(spec, "''", "''"); |
- ExpectFailure(spec, "1"); |
- ExpectFailure(spec, "{}"); |
- ExpectFailure(spec, "['foo']"); |
+ ExpectFailure(spec, "1", invalid_type(kTypeString, kTypeInteger)); |
+ ExpectFailure(spec, "({})", invalid_type(kTypeString, kTypeObject)); |
+ ExpectFailure(spec, "['foo']", invalid_type(kTypeString, kTypeList)); |
} |
{ |
@@ -179,11 +214,11 @@ TEST_F(ArgumentSpecUnitTest, Test) { |
*ValueFromString("{'type': 'string', 'enum': ['foo', 'bar']}")); |
ExpectSuccess(spec, "'foo'", "'foo'"); |
ExpectSuccess(spec, "'bar'", "'bar'"); |
- ExpectFailure(spec, "['foo']"); |
- ExpectFailure(spec, "'fo'"); |
- ExpectFailure(spec, "'foobar'"); |
- ExpectFailure(spec, "'baz'"); |
- ExpectFailure(spec, "''"); |
+ ExpectFailure(spec, "['foo']", invalid_type(kTypeString, kTypeList)); |
+ ExpectFailure(spec, "'fo'", GetError(kInvalidEnumValue, "bar, foo")); |
+ ExpectFailure(spec, "'foobar'", GetError(kInvalidEnumValue, "bar, foo")); |
+ ExpectFailure(spec, "'baz'", GetError(kInvalidEnumValue, "bar, foo")); |
+ ExpectFailure(spec, "''", GetError(kInvalidEnumValue, "bar, foo")); |
} |
{ |
@@ -191,20 +226,20 @@ TEST_F(ArgumentSpecUnitTest, Test) { |
"{'type': 'string', 'enum': [{'name': 'foo'}, {'name': 'bar'}]}")); |
ExpectSuccess(spec, "'foo'", "'foo'"); |
ExpectSuccess(spec, "'bar'", "'bar'"); |
- ExpectFailure(spec, "['foo']"); |
- ExpectFailure(spec, "'fo'"); |
- ExpectFailure(spec, "'foobar'"); |
- ExpectFailure(spec, "'baz'"); |
- ExpectFailure(spec, "''"); |
+ ExpectFailure(spec, "['foo']", invalid_type(kTypeString, kTypeList)); |
+ ExpectFailure(spec, "'fo'", GetError(kInvalidEnumValue, "bar, foo")); |
+ ExpectFailure(spec, "'foobar'", GetError(kInvalidEnumValue, "bar, foo")); |
+ ExpectFailure(spec, "'baz'", GetError(kInvalidEnumValue, "bar, foo")); |
+ ExpectFailure(spec, "''", GetError(kInvalidEnumValue, "bar, foo")); |
} |
{ |
ArgumentSpec spec(*ValueFromString("{'type': 'boolean'}")); |
ExpectSuccess(spec, "true", "true"); |
ExpectSuccess(spec, "false", "false"); |
- ExpectFailure(spec, "1"); |
- ExpectFailure(spec, "'true'"); |
- ExpectFailure(spec, "null"); |
+ ExpectFailure(spec, "1", invalid_type(kTypeBoolean, kTypeInteger)); |
+ ExpectFailure(spec, "'true'", invalid_type(kTypeBoolean, kTypeString)); |
+ ExpectFailure(spec, "null", invalid_type(kTypeBoolean, kTypeNull)); |
} |
{ |
@@ -214,13 +249,16 @@ TEST_F(ArgumentSpecUnitTest, Test) { |
ExpectSuccess(spec, "['foo']", "['foo']"); |
ExpectSuccess(spec, "['foo', 'bar']", "['foo','bar']"); |
ExpectSuccess(spec, "var x = new Array(); x[0] = 'foo'; x;", "['foo']"); |
- ExpectFailure(spec, "'foo'"); |
- ExpectFailure(spec, "[1, 2]"); |
- ExpectFailure(spec, "['foo', 1]"); |
+ ExpectFailure(spec, "'foo'", invalid_type(kTypeList, kTypeString)); |
+ ExpectFailure(spec, "[1, 2]", |
+ GetIndexError(0u, invalid_type(kTypeString, kTypeInteger))); |
+ ExpectFailure(spec, "['foo', 1]", |
+ GetIndexError(1u, invalid_type(kTypeString, kTypeInteger))); |
ExpectFailure(spec, |
"var x = ['a', 'b', 'c'];" |
"x[4] = 'd';" // x[3] is undefined, violating the spec. |
- "x;"); |
+ "x;", |
+ GetIndexError(3u, invalid_type(kTypeString, kTypeUndefined))); |
ExpectThrow( |
spec, |
"var x = [];" |
@@ -246,27 +284,35 @@ TEST_F(ArgumentSpecUnitTest, Test) { |
ExpectSuccess(spec, "({prop1: 'foo'})", "{'prop1':'foo'}"); |
ExpectSuccess(spec, "({prop1: 'foo', prop2: null})", "{'prop1':'foo'}"); |
ExpectSuccess(spec, "x = {}; x.prop1 = 'foo'; x;", "{'prop1':'foo'}"); |
- ExpectFailure(spec, "({prop1: 'foo', prop2: 'bar'})"); |
- ExpectFailure(spec, "({prop2: 2})"); |
+ ExpectFailure( |
+ spec, "({prop1: 'foo', prop2: 'bar'})", |
+ GetPropertyError("prop2", invalid_type(kTypeInteger, kTypeString))); |
+ ExpectFailure(spec, "({prop2: 2})", |
+ GetError(kMissingRequiredProperty, "prop1")); |
// Unknown properties are not allowed. |
- ExpectFailure(spec, "({prop1: 'foo', prop2: 2, prop3: 'blah'})"); |
+ ExpectFailure(spec, "({prop1: 'foo', prop2: 2, prop3: 'blah'})", |
+ GetError(kUnexpectedProperty, "prop3")); |
// We only consider properties on the object itself, not its prototype |
// chain. |
ExpectFailure(spec, |
"function X() {}\n" |
"X.prototype = { prop1: 'foo' };\n" |
"var x = new X();\n" |
- "x;"); |
+ "x;", |
+ GetError(kMissingRequiredProperty, "prop1")); |
ExpectFailure(spec, |
"function X() {}\n" |
"X.prototype = { prop1: 'foo' };\n" |
"function Y() { this.__proto__ = X.prototype; }\n" |
"var z = new Y();\n" |
- "z;"); |
+ "z;", |
+ GetError(kMissingRequiredProperty, "prop1")); |
// Self-referential fun. Currently we don't have to worry about these much |
// because the spec won't match at some point (and V8ValueConverter has |
// cycle detection and will fail). |
- ExpectFailure(spec, "x = {}; x.prop1 = x; x;"); |
+ ExpectFailure( |
+ spec, "x = {}; x.prop1 = x; x;", |
+ GetPropertyError("prop1", invalid_type(kTypeString, kTypeObject))); |
ExpectThrow( |
spec, |
"({ get prop1() { throw new Error('Badness'); }});", |
@@ -300,9 +346,12 @@ TEST_F(ArgumentSpecUnitTest, Test) { |
ExpectSuccessWithNoConversion(spec, "(function() {})"); |
ExpectSuccessWithNoConversion(spec, "(function(a, b) { a(); b(); })"); |
ExpectSuccessWithNoConversion(spec, "(function(a, b) { a(); b(); })"); |
- ExpectFailureWithNoConversion(spec, "({a: function() {}})"); |
- ExpectFailureWithNoConversion(spec, "([function() {}])"); |
- ExpectFailureWithNoConversion(spec, "1"); |
+ ExpectFailureWithNoConversion(spec, "({a: function() {}})", |
+ invalid_type(kTypeFunction, kTypeObject)); |
+ ExpectFailureWithNoConversion(spec, "([function() {}])", |
+ invalid_type(kTypeFunction, kTypeList)); |
+ ExpectFailureWithNoConversion(spec, "1", |
+ invalid_type(kTypeFunction, kTypeInteger)); |
} |
{ |
@@ -334,7 +383,7 @@ TEST_F(ArgumentSpecUnitTest, Test) { |
"b;", |
*expected_value); |
} |
- ExpectFailure(spec, "1"); |
+ ExpectFailure(spec, "1", invalid_type(kTypeBinary, kTypeInteger)); |
} |
{ |
const char kAnySpec[] = "{ 'type': 'any' }"; |
@@ -358,12 +407,14 @@ TEST_F(ArgumentSpecUnitTest, Test) { |
// null, which is a potentially important distinction. However, this means |
// that in serialization of an object {a: 1, foo:undefined}, we lose the |
// 'foo' property. |
- ExpectFailure(spec, "undefined"); |
+ ExpectFailure(spec, "undefined", kUnserializableValue); |
+ |
ExpectSuccess(spec, "({prop1: 1, prop2: undefined})", "{'prop1':1}"); |
} |
} |
TEST_F(ArgumentSpecUnitTest, TypeRefsTest) { |
+ using namespace api_errors; |
const char kObjectType[] = |
"{" |
" 'id': 'refObj'," |
@@ -393,8 +444,11 @@ TEST_F(ArgumentSpecUnitTest, TypeRefsTest) { |
ArgumentSpec spec(*ValueFromString(kObjectWithRefEnumSpec)); |
ExpectSuccess(spec, "({e: 'alpha', sub: 1})", "{'e':'alpha','sub':1}"); |
ExpectSuccess(spec, "({e: 'beta', sub: 1})", "{'e':'beta','sub':1}"); |
- ExpectFailure(spec, "({e: 'gamma', sub: 1})"); |
- ExpectFailure(spec, "({e: 'alpha'})"); |
+ ExpectFailure( |
+ spec, "({e: 'gamma', sub: 1})", |
+ GetPropertyError("e", GetError(kInvalidEnumValue, "alpha, beta"))); |
+ ExpectFailure(spec, "({e: 'alpha'})", |
+ GetError(kMissingRequiredProperty, "sub")); |
} |
{ |
@@ -410,7 +464,11 @@ TEST_F(ArgumentSpecUnitTest, TypeRefsTest) { |
ExpectSuccess(spec, "({o: {prop1: 'foo'}})", "{'o':{'prop1':'foo'}}"); |
ExpectSuccess(spec, "({o: {prop1: 'foo', prop2: 2}})", |
"{'o':{'prop1':'foo','prop2':2}}"); |
- ExpectFailure(spec, "({o: {prop1: 1}})"); |
+ ExpectFailure( |
+ spec, "({o: {prop1: 1}})", |
+ GetPropertyError( |
+ "o", GetPropertyError("prop1", GetError(kInvalidType, kTypeString, |
+ kTypeInteger)))); |
} |
{ |
@@ -420,18 +478,21 @@ TEST_F(ArgumentSpecUnitTest, TypeRefsTest) { |
ExpectSuccess(spec, "['alpha']", "['alpha']"); |
ExpectSuccess(spec, "['alpha', 'alpha']", "['alpha','alpha']"); |
ExpectSuccess(spec, "['alpha', 'beta']", "['alpha','beta']"); |
- ExpectFailure(spec, "['alpha', 'beta', 'gamma']"); |
+ ExpectFailure( |
+ spec, "['alpha', 'beta', 'gamma']", |
+ GetIndexError(2u, GetError(kInvalidEnumValue, "alpha, beta"))); |
} |
} |
TEST_F(ArgumentSpecUnitTest, TypeChoicesTest) { |
+ using namespace api_errors; |
{ |
const char kSimpleChoices[] = |
"{'choices': [{'type': 'string'}, {'type': 'integer'}]}"; |
ArgumentSpec spec(*ValueFromString(kSimpleChoices)); |
ExpectSuccess(spec, "'alpha'", "'alpha'"); |
ExpectSuccess(spec, "42", "42"); |
- ExpectFailure(spec, "true"); |
+ ExpectFailure(spec, "true", kInvalidChoice); |
} |
{ |
@@ -446,13 +507,14 @@ TEST_F(ArgumentSpecUnitTest, TypeChoicesTest) { |
ExpectSuccess(spec, "['alpha']", "['alpha']"); |
ExpectSuccess(spec, "['alpha', 'beta']", "['alpha','beta']"); |
ExpectSuccess(spec, "({prop1: 'alpha'})", "{'prop1':'alpha'}"); |
- ExpectFailure(spec, "({prop1: 1})"); |
- ExpectFailure(spec, "'alpha'"); |
- ExpectFailure(spec, "42"); |
+ ExpectFailure(spec, "({prop1: 1})", kInvalidChoice); |
+ ExpectFailure(spec, "'alpha'", kInvalidChoice); |
+ ExpectFailure(spec, "42", kInvalidChoice); |
} |
} |
TEST_F(ArgumentSpecUnitTest, AdditionalPropertiesTest) { |
+ using namespace api_errors; |
{ |
const char kOnlyAnyAdditionalProperties[] = |
"{" |
@@ -533,8 +595,11 @@ TEST_F(ArgumentSpecUnitTest, AdditionalPropertiesTest) { |
"{'prop1':'alpha','prop2':42,'prop3':{'foo':'bar'}}"); |
// Additional properties are optional. |
ExpectSuccess(spec, "({prop1: 'foo'})", "{'prop1':'foo'}"); |
- ExpectFailure(spec, "({prop2: 42, prop3: {foo: 'bar'}})"); |
- ExpectFailure(spec, "({prop1: 42})"); |
+ ExpectFailure(spec, "({prop2: 42, prop3: {foo: 'bar'}})", |
+ GetError(kMissingRequiredProperty, "prop1")); |
+ ExpectFailure(spec, "({prop1: 42})", |
+ GetPropertyError("prop1", GetError(kInvalidType, kTypeString, |
+ kTypeInteger))); |
} |
{ |
const char kTypedAdditionalProperties[] = |
@@ -545,11 +610,14 @@ TEST_F(ArgumentSpecUnitTest, AdditionalPropertiesTest) { |
ArgumentSpec spec(*ValueFromString(kTypedAdditionalProperties)); |
ExpectSuccess(spec, "({prop1: 'alpha', prop2: 'beta', prop3: 'gamma'})", |
"{'prop1':'alpha','prop2':'beta','prop3':'gamma'}"); |
- ExpectFailure(spec, "({prop1: 'alpha', prop2: 42})"); |
+ ExpectFailure(spec, "({prop1: 'alpha', prop2: 42})", |
+ GetPropertyError("prop2", GetError(kInvalidType, kTypeString, |
+ kTypeInteger))); |
} |
} |
TEST_F(ArgumentSpecUnitTest, InstanceOfTest) { |
+ using namespace api_errors; |
{ |
const char kInstanceOfRegExp[] = |
"{" |
@@ -572,10 +640,12 @@ TEST_F(ArgumentSpecUnitTest, InstanceOfTest) { |
" return new RegExp();\n" |
"})()", |
"{}"); |
- ExpectFailure(spec, "({})"); |
- ExpectFailure(spec, "('')"); |
- ExpectFailure(spec, "('.*')"); |
- ExpectFailure(spec, "({ __proto__: Date.prototype })"); |
+ ExpectFailure(spec, "({})", GetError(kNotAnInstance, "RegExp")); |
+ ExpectFailure(spec, "('')", GetError(kInvalidType, "RegExp", kTypeString)); |
+ ExpectFailure(spec, "('.*')", |
+ GetError(kInvalidType, "RegExp", kTypeString)); |
+ ExpectFailure(spec, "({ __proto__: Date.prototype })", |
+ GetError(kNotAnInstance, "RegExp")); |
} |
{ |
@@ -600,23 +670,25 @@ TEST_F(ArgumentSpecUnitTest, InstanceOfTest) { |
" return new otherClass();\n" |
"})()", |
"{}"); |
- ExpectFailure(spec, "({})"); |
+ ExpectFailure(spec, "({})", GetError(kNotAnInstance, "customClass")); |
ExpectFailure(spec, |
"(function() {\n" |
" function otherClass() {}\n" |
" return new otherClass();\n" |
- "})()"); |
+ "})()", |
+ GetError(kNotAnInstance, "customClass")); |
} |
} |
TEST_F(ArgumentSpecUnitTest, MinAndMaxLengths) { |
+ using namespace api_errors; |
{ |
const char kMinLengthString[] = "{'type': 'string', 'minLength': 3}"; |
ArgumentSpec spec(*ValueFromString(kMinLengthString)); |
ExpectSuccess(spec, "'aaa'", "'aaa'"); |
ExpectSuccess(spec, "'aaaa'", "'aaaa'"); |
- ExpectFailure(spec, "'aa'"); |
- ExpectFailure(spec, "''"); |
+ ExpectFailure(spec, "'aa'", GetError(kTooFewStringChars, 3)); |
+ ExpectFailure(spec, "''", GetError(kTooFewStringChars, 3)); |
} |
{ |
@@ -625,7 +697,7 @@ TEST_F(ArgumentSpecUnitTest, MinAndMaxLengths) { |
ExpectSuccess(spec, "'aaa'", "'aaa'"); |
ExpectSuccess(spec, "'aa'", "'aa'"); |
ExpectSuccess(spec, "''", "''"); |
- ExpectFailure(spec, "'aaaa'"); |
+ ExpectFailure(spec, "'aaaa'", GetError(kTooManyStringChars, 3)); |
} |
{ |
@@ -634,8 +706,8 @@ TEST_F(ArgumentSpecUnitTest, MinAndMaxLengths) { |
ArgumentSpec spec(*ValueFromString(kMinLengthArray)); |
ExpectSuccess(spec, "[1, 2, 3]", "[1,2,3]"); |
ExpectSuccess(spec, "[1, 2, 3, 4]", "[1,2,3,4]"); |
- ExpectFailure(spec, "[1, 2]"); |
- ExpectFailure(spec, "[]"); |
+ ExpectFailure(spec, "[1, 2]", GetError(kTooFewArrayItems, 3)); |
+ ExpectFailure(spec, "[]", GetError(kTooFewArrayItems, 3)); |
} |
{ |
@@ -645,7 +717,7 @@ TEST_F(ArgumentSpecUnitTest, MinAndMaxLengths) { |
ExpectSuccess(spec, "[1, 2, 3]", "[1,2,3]"); |
ExpectSuccess(spec, "[1, 2]", "[1,2]"); |
ExpectSuccess(spec, "[]", "[]"); |
- ExpectFailure(spec, "[1, 2, 3, 4]"); |
+ ExpectFailure(spec, "[1, 2, 3, 4]", GetError(kTooManyArrayItems, 3)); |
} |
} |