| // Copyright 2017 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "extensions/renderer/bindings/api_signature.h" |
| |
| #include <string_view> |
| |
| #include "base/values.h" |
| #include "extensions/renderer/bindings/api_binding_test.h" |
| #include "extensions/renderer/bindings/api_binding_test_util.h" |
| #include "extensions/renderer/bindings/api_invocation_errors.h" |
| #include "extensions/renderer/bindings/api_type_reference_map.h" |
| #include "extensions/renderer/bindings/argument_spec.h" |
| #include "extensions/renderer/bindings/argument_spec_builder.h" |
| #include "extensions/renderer/bindings/binding_access_checker.h" |
| #include "extensions/renderer/bindings/returns_async_builder.h" |
| #include "gin/converter.h" |
| #include "gin/dictionary.h" |
| |
| namespace extensions { |
| |
| using api_errors::ArgumentError; |
| using api_errors::InvalidType; |
| using api_errors::kTypeBoolean; |
| using api_errors::kTypeInteger; |
| using api_errors::kTypeString; |
| using api_errors::NoMatchingSignature; |
| |
| namespace { |
| |
| using SpecVector = std::vector<std::unique_ptr<ArgumentSpec>>; |
| using ReturnsAsync = APISignature::ReturnsAsync; |
| |
| std::unique_ptr<APISignature> OneString() { |
| SpecVector specs; |
| specs.push_back(ArgumentSpecBuilder(ArgumentType::STRING, "string").Build()); |
| return std::make_unique<APISignature>( |
| std::move(specs), nullptr /*returns_async*/, nullptr /*access_checker*/); |
| } |
| |
| SpecVector StringAndIntSpec() { |
| SpecVector specs; |
| specs.push_back(ArgumentSpecBuilder(ArgumentType::STRING, "string").Build()); |
| specs.push_back(ArgumentSpecBuilder(ArgumentType::INTEGER, "int").Build()); |
| return specs; |
| } |
| |
| std::unique_ptr<APISignature> StringAndInt() { |
| return std::make_unique<APISignature>(StringAndIntSpec(), |
| nullptr /*returns_async*/, |
| nullptr /*access_checker*/); |
| } |
| |
| SpecVector StringOptionalIntAndBoolSpec() { |
| SpecVector specs; |
| specs.push_back(ArgumentSpecBuilder(ArgumentType::STRING, "string").Build()); |
| specs.push_back( |
| ArgumentSpecBuilder(ArgumentType::INTEGER, "int").MakeOptional().Build()); |
| specs.push_back(ArgumentSpecBuilder(ArgumentType::BOOLEAN, "bool").Build()); |
| return specs; |
| } |
| |
| std::unique_ptr<APISignature> StringOptionalIntAndBool() { |
| return std::make_unique<APISignature>(StringOptionalIntAndBoolSpec(), |
| nullptr /*returns_async*/, |
| nullptr /*access_checker*/); |
| } |
| |
| SpecVector StringAndOptionalIntSpec() { |
| SpecVector specs; |
| specs.push_back(ArgumentSpecBuilder(ArgumentType::STRING, "string").Build()); |
| specs.push_back( |
| ArgumentSpecBuilder(ArgumentType::INTEGER, "int").MakeOptional().Build()); |
| return specs; |
| } |
| |
| std::unique_ptr<APISignature> OneObject() { |
| SpecVector specs; |
| specs.push_back( |
| ArgumentSpecBuilder(ArgumentType::OBJECT, "obj") |
| .AddProperty("prop1", |
| ArgumentSpecBuilder(ArgumentType::STRING).Build()) |
| .AddProperty( |
| "prop2", |
| ArgumentSpecBuilder(ArgumentType::STRING).MakeOptional().Build()) |
| .Build()); |
| return std::make_unique<APISignature>( |
| std::move(specs), nullptr /*returns_async*/, nullptr /*access_checker*/); |
| } |
| |
| std::unique_ptr<APISignature> NoArgs() { |
| return std::make_unique<APISignature>(SpecVector(), nullptr /*returns_async*/, |
| nullptr /*access_checker*/); |
| } |
| |
| std::unique_ptr<APISignature> IntAndCallback() { |
| SpecVector specs; |
| specs.push_back(ArgumentSpecBuilder(ArgumentType::INTEGER, "int").Build()); |
| return std::make_unique<APISignature>(std::move(specs), |
| ReturnsAsyncBuilder().Build(), nullptr); |
| } |
| |
| std::unique_ptr<APISignature> IntAndOptionalCallback() { |
| SpecVector specs; |
| specs.push_back(ArgumentSpecBuilder(ArgumentType::INTEGER, "int").Build()); |
| return std::make_unique<APISignature>( |
| std::move(specs), ReturnsAsyncBuilder().MakeOptional().Build(), nullptr); |
| } |
| |
| std::unique_ptr<APISignature> OptionalIntAndCallback() { |
| SpecVector specs; |
| specs.push_back( |
| ArgumentSpecBuilder(ArgumentType::INTEGER, "int").MakeOptional().Build()); |
| return std::make_unique<APISignature>(std::move(specs), |
| ReturnsAsyncBuilder().Build(), nullptr); |
| } |
| |
| std::unique_ptr<APISignature> OptionalCallback() { |
| return std::make_unique<APISignature>( |
| SpecVector(), ReturnsAsyncBuilder().MakeOptional().Build(), nullptr); |
| } |
| |
| std::unique_ptr<APISignature> IntAnyOptionalObjectOptionalCallback() { |
| SpecVector specs; |
| specs.push_back(ArgumentSpecBuilder(ArgumentType::INTEGER, "int").Build()); |
| specs.push_back(ArgumentSpecBuilder(ArgumentType::ANY, "any").Build()); |
| specs.push_back( |
| ArgumentSpecBuilder(ArgumentType::OBJECT, "obj") |
| .AddProperty( |
| "prop", |
| ArgumentSpecBuilder(ArgumentType::INTEGER).MakeOptional().Build()) |
| .MakeOptional() |
| .Build()); |
| return std::make_unique<APISignature>( |
| std::move(specs), ReturnsAsyncBuilder().MakeOptional().Build(), nullptr); |
| } |
| |
| std::unique_ptr<APISignature> RefObj() { |
| SpecVector specs; |
| specs.push_back( |
| ArgumentSpecBuilder(ArgumentType::REF, "obj").SetRef("refObj").Build()); |
| return std::make_unique<APISignature>( |
| std::move(specs), nullptr /*returns_async*/, nullptr /*access_checker*/); |
| } |
| |
| std::unique_ptr<APISignature> RefEnum() { |
| SpecVector specs; |
| specs.push_back( |
| ArgumentSpecBuilder(ArgumentType::REF, "enum").SetRef("refEnum").Build()); |
| return std::make_unique<APISignature>( |
| std::move(specs), nullptr /*returns_async*/, nullptr /*access_checker*/); |
| } |
| |
| std::unique_ptr<APISignature> OptionalObjectAndOptionalCallback() { |
| SpecVector specs; |
| specs.push_back( |
| ArgumentSpecBuilder(ArgumentType::OBJECT, "obj") |
| .AddProperty( |
| "prop1", |
| ArgumentSpecBuilder(ArgumentType::INTEGER).MakeOptional().Build()) |
| .MakeOptional() |
| .Build()); |
| return std::make_unique<APISignature>( |
| std::move(specs), ReturnsAsyncBuilder().MakeOptional().Build(), |
| nullptr /*access_checker*/); |
| } |
| |
| std::unique_ptr<APISignature> OptionalIntAndNumber() { |
| SpecVector specs; |
| specs.push_back( |
| ArgumentSpecBuilder(ArgumentType::INTEGER, "int").MakeOptional().Build()); |
| specs.push_back(ArgumentSpecBuilder(ArgumentType::DOUBLE, "num").Build()); |
| return std::make_unique<APISignature>( |
| std::move(specs), nullptr /*returns_async*/, nullptr /*access_checker*/); |
| } |
| |
| std::unique_ptr<APISignature> OptionalIntAndInt() { |
| SpecVector specs; |
| specs.push_back( |
| ArgumentSpecBuilder(ArgumentType::INTEGER, "int").MakeOptional().Build()); |
| specs.push_back(ArgumentSpecBuilder(ArgumentType::INTEGER, "int2").Build()); |
| return std::make_unique<APISignature>( |
| std::move(specs), nullptr /*returns_async*/, nullptr /*access_checker*/); |
| } |
| |
| v8::LocalVector<v8::Value> StringToV8Vector(v8::Local<v8::Context> context, |
| const char* args) { |
| v8::Isolate* isolate = v8::Isolate::GetCurrent(); |
| v8::Local<v8::Value> v8_args = V8ValueFromScriptSource(context, args); |
| EXPECT_FALSE(v8_args.IsEmpty()); |
| EXPECT_TRUE(v8_args->IsArray()); |
| v8::LocalVector<v8::Value> vector_args(isolate); |
| EXPECT_TRUE(gin::ConvertFromV8(isolate, v8_args, &vector_args)); |
| return vector_args; |
| } |
| |
| } // namespace |
| |
| class APISignatureTest : public APIBindingTest { |
| public: |
| APISignatureTest() |
| : type_refs_(APITypeReferenceMap::InitializeTypeCallback()) {} |
| |
| APISignatureTest(const APISignatureTest&) = delete; |
| APISignatureTest& operator=(const APISignatureTest&) = delete; |
| |
| ~APISignatureTest() override = default; |
| |
| void SetUp() override { |
| APIBindingTest::SetUp(); |
| |
| std::unique_ptr<ArgumentSpec> ref_obj_spec = |
| ArgumentSpecBuilder(ArgumentType::OBJECT) |
| .AddProperty("prop1", |
| ArgumentSpecBuilder(ArgumentType::STRING).Build()) |
| .AddProperty("prop2", ArgumentSpecBuilder(ArgumentType::INTEGER) |
| .MakeOptional() |
| .Build()) |
| .Build(); |
| type_refs_.AddSpec("refObj", std::move(ref_obj_spec)); |
| |
| type_refs_.AddSpec("refEnum", ArgumentSpecBuilder(ArgumentType::STRING) |
| .SetEnums({"alpha", "beta"}) |
| .Build()); |
| } |
| |
| void ExpectPass(const APISignature& signature, |
| std::string_view arg_values, |
| std::string_view expected_parsed_args, |
| binding::AsyncResponseType expected_response_type) { |
| RunTest(signature, arg_values, expected_parsed_args, expected_response_type, |
| true, std::string()); |
| } |
| |
| void ExpectFailure(const APISignature& signature, |
| std::string_view arg_values, |
| const std::string& expected_error) { |
| RunTest(signature, arg_values, std::string_view(), |
| binding::AsyncResponseType::kNone, false, expected_error); |
| } |
| |
| void ExpectResponsePass(const APISignature& signature, |
| std::string_view arg_values) { |
| RunResponseTest(signature, arg_values, std::nullopt); |
| } |
| |
| void ExpectResponseFailure(const APISignature& signature, |
| std::string_view arg_values, |
| const std::string& expected_error) { |
| RunResponseTest(signature, arg_values, expected_error); |
| } |
| |
| const APITypeReferenceMap& type_refs() const { return type_refs_; } |
| |
| private: |
| void RunTest(const APISignature& signature, |
| std::string_view arg_values, |
| std::string_view expected_parsed_args, |
| binding::AsyncResponseType expected_response_type, |
| bool should_succeed, |
| const std::string& expected_error) { |
| SCOPED_TRACE(arg_values); |
| v8::Local<v8::Context> context = MainContext(); |
| v8::Local<v8::Value> v8_args = V8ValueFromScriptSource(context, arg_values); |
| ASSERT_FALSE(v8_args.IsEmpty()); |
| ASSERT_TRUE(v8_args->IsArray()); |
| v8::LocalVector<v8::Value> vector_args(isolate()); |
| ASSERT_TRUE(gin::ConvertFromV8(isolate(), v8_args, &vector_args)); |
| |
| APISignature::JSONParseResult parse_result = |
| signature.ParseArgumentsToJSON(context, vector_args, type_refs_); |
| ASSERT_EQ(should_succeed, !!parse_result.arguments_list); |
| ASSERT_NE(should_succeed, parse_result.error.has_value()); |
| EXPECT_EQ(expected_response_type, parse_result.async_type); |
| EXPECT_EQ(expected_response_type == binding::AsyncResponseType::kCallback, |
| !parse_result.callback.IsEmpty()); |
| if (should_succeed) { |
| EXPECT_EQ(ReplaceSingleQuotes(expected_parsed_args), |
| ValueToString(*parse_result.arguments_list)); |
| } else { |
| EXPECT_EQ(expected_error, *parse_result.error); |
| } |
| } |
| |
| void RunResponseTest(const APISignature& signature, |
| std::string_view arg_values, |
| std::optional<std::string> expected_error) { |
| SCOPED_TRACE(arg_values); |
| v8::Local<v8::Context> context = MainContext(); |
| v8::Local<v8::Value> v8_args = V8ValueFromScriptSource(context, arg_values); |
| ASSERT_FALSE(v8_args.IsEmpty()); |
| ASSERT_TRUE(v8_args->IsArray()); |
| v8::LocalVector<v8::Value> vector_args(isolate()); |
| ASSERT_TRUE(gin::ConvertFromV8(isolate(), v8_args, &vector_args)); |
| |
| std::string error; |
| bool should_succeed = !expected_error; |
| bool success = |
| signature.ValidateResponse(context, vector_args, type_refs_, &error); |
| EXPECT_EQ(should_succeed, success) << error; |
| ASSERT_EQ(should_succeed, error.empty()); |
| if (!should_succeed) |
| EXPECT_EQ(*expected_error, error); |
| } |
| |
| APITypeReferenceMap type_refs_; |
| }; |
| |
| TEST_F(APISignatureTest, BasicSignatureParsing) { |
| v8::HandleScope handle_scope(isolate()); |
| |
| { |
| SCOPED_TRACE("OneString"); |
| auto signature = OneString(); |
| ExpectPass(*signature, "['foo']", "['foo']", |
| binding::AsyncResponseType::kNone); |
| ExpectPass(*signature, "['']", "['']", binding::AsyncResponseType::kNone); |
| ExpectFailure(*signature, "[1]", NoMatchingSignature()); |
| ExpectFailure(*signature, "[]", NoMatchingSignature()); |
| ExpectFailure(*signature, "[{}]", NoMatchingSignature()); |
| ExpectFailure(*signature, "['foo', 'bar']", NoMatchingSignature()); |
| } |
| |
| { |
| SCOPED_TRACE("StringAndInt"); |
| auto signature = StringAndInt(); |
| ExpectPass(*signature, "['foo', 42]", "['foo',42]", |
| binding::AsyncResponseType::kNone); |
| ExpectPass(*signature, "['foo', -1]", "['foo',-1]", |
| binding::AsyncResponseType::kNone); |
| ExpectFailure(*signature, "[1]", NoMatchingSignature()); |
| ExpectFailure(*signature, "['foo'];", NoMatchingSignature()); |
| ExpectFailure(*signature, "[1, 'foo']", NoMatchingSignature()); |
| ExpectFailure(*signature, "['foo', 'foo']", NoMatchingSignature()); |
| ExpectFailure(*signature, "['foo', '1']", NoMatchingSignature()); |
| ExpectFailure(*signature, "['foo', 2.3]", NoMatchingSignature()); |
| } |
| |
| { |
| SCOPED_TRACE("StringOptionalIntAndBool"); |
| auto signature = StringOptionalIntAndBool(); |
| ExpectPass(*signature, "['foo', 42, true]", "['foo',42,true]", |
| binding::AsyncResponseType::kNone); |
| ExpectPass(*signature, "['foo', true]", "['foo',null,true]", |
| binding::AsyncResponseType::kNone); |
| ExpectFailure(*signature, "['foo', 'bar', true]", NoMatchingSignature()); |
| } |
| |
| { |
| SCOPED_TRACE("OneObject"); |
| auto signature = OneObject(); |
| ExpectPass(*signature, "[{prop1: 'foo'}]", "[{'prop1':'foo'}]", |
| binding::AsyncResponseType::kNone); |
| ExpectFailure(*signature, |
| "[{ get prop1() { throw new Error('Badness'); } }]", |
| ArgumentError("obj", api_errors::ScriptThrewError())); |
| } |
| |
| { |
| SCOPED_TRACE("NoArgs"); |
| auto signature = NoArgs(); |
| ExpectPass(*signature, "[]", "[]", binding::AsyncResponseType::kNone); |
| ExpectFailure(*signature, "[0]", NoMatchingSignature()); |
| ExpectFailure(*signature, "['']", NoMatchingSignature()); |
| ExpectFailure(*signature, "[null]", NoMatchingSignature()); |
| ExpectFailure(*signature, "[undefined]", NoMatchingSignature()); |
| } |
| |
| { |
| SCOPED_TRACE("IntAndCallback"); |
| auto signature = IntAndCallback(); |
| ExpectPass(*signature, "[1, function() {}]", "[1]", |
| binding::AsyncResponseType::kCallback); |
| ExpectFailure(*signature, "[function() {}]", NoMatchingSignature()); |
| ExpectFailure(*signature, "[1]", NoMatchingSignature()); |
| } |
| |
| { |
| SCOPED_TRACE("OptionalIntAndCallback"); |
| auto signature = OptionalIntAndCallback(); |
| ExpectPass(*signature, "[1, function() {}]", "[1]", |
| binding::AsyncResponseType::kCallback); |
| ExpectPass(*signature, "[function() {}]", "[null]", |
| binding::AsyncResponseType::kCallback); |
| ExpectFailure(*signature, "[1]", NoMatchingSignature()); |
| } |
| |
| { |
| SCOPED_TRACE("OptionalCallback"); |
| auto signature = OptionalCallback(); |
| ExpectPass(*signature, "[function() {}]", "[]", |
| binding::AsyncResponseType::kCallback); |
| ExpectPass(*signature, "[]", "[]", binding::AsyncResponseType::kNone); |
| ExpectPass(*signature, "[undefined]", "[]", |
| binding::AsyncResponseType::kNone); |
| ExpectFailure(*signature, "[0]", NoMatchingSignature()); |
| } |
| |
| { |
| SCOPED_TRACE("IntAnyOptionalObjectOptionalCallback"); |
| auto signature = IntAnyOptionalObjectOptionalCallback(); |
| ExpectPass(*signature, "[4, {foo: 'bar'}, function() {}]", |
| "[4,{'foo':'bar'},null]", binding::AsyncResponseType::kCallback); |
| ExpectPass(*signature, "[4, {foo: 'bar'}]", "[4,{'foo':'bar'},null]", |
| binding::AsyncResponseType::kNone); |
| ExpectPass(*signature, "[4, {foo: 'bar'}, {}]", "[4,{'foo':'bar'},{}]", |
| binding::AsyncResponseType::kNone); |
| ExpectFailure(*signature, "[4, function() {}]", |
| ArgumentError("any", api_errors::UnserializableValue())); |
| ExpectFailure(*signature, "[4]", NoMatchingSignature()); |
| } |
| |
| { |
| SCOPED_TRACE("OptionalObjectAndCOptionalallback"); |
| auto signature = OptionalObjectAndOptionalCallback(); |
| ExpectPass(*signature, "[{prop1: 1}]", "[{'prop1':1}]", |
| binding::AsyncResponseType::kNone); |
| ExpectPass(*signature, "[]", "[null]", binding::AsyncResponseType::kNone); |
| ExpectPass(*signature, "[null]", "[null]", |
| binding::AsyncResponseType::kNone); |
| ExpectFailure(*signature, "[{prop1: 'str'}]", |
| ArgumentError("obj", api_errors::PropertyError( |
| "prop1", InvalidType(kTypeInteger, |
| kTypeString)))); |
| ExpectFailure(*signature, "[{prop1: 'str'}, function() {}]", |
| ArgumentError("obj", api_errors::PropertyError( |
| "prop1", InvalidType(kTypeInteger, |
| kTypeString)))); |
| } |
| |
| { |
| SCOPED_TRACE("OptionalIntAndNumber"); |
| auto signature = OptionalIntAndNumber(); |
| ExpectPass(*signature, "[1.0, 1.0]", "[1,1.0]", |
| binding::AsyncResponseType::kNone); |
| ExpectPass(*signature, "[1, 1]", "[1,1.0]", |
| binding::AsyncResponseType::kNone); |
| ExpectPass(*signature, "[1.0]", "[null,1.0]", |
| binding::AsyncResponseType::kNone); |
| ExpectPass(*signature, "[1]", "[null,1.0]", |
| binding::AsyncResponseType::kNone); |
| ExpectFailure(*signature, "[1.0, null]", NoMatchingSignature()); |
| ExpectFailure(*signature, "[1, null]", NoMatchingSignature()); |
| } |
| |
| { |
| SCOPED_TRACE("OptionalIntAndInt"); |
| auto signature = OptionalIntAndInt(); |
| ExpectPass(*signature, "[1.0, 1.0]", "[1,1]", |
| binding::AsyncResponseType::kNone); |
| ExpectPass(*signature, "[1, 1]", "[1,1]", |
| binding::AsyncResponseType::kNone); |
| ExpectPass(*signature, "[1.0]", "[null,1]", |
| binding::AsyncResponseType::kNone); |
| ExpectPass(*signature, "[1]", "[null,1]", |
| binding::AsyncResponseType::kNone); |
| ExpectFailure(*signature, "[1.0, null]", NoMatchingSignature()); |
| ExpectFailure(*signature, "[1, null]", NoMatchingSignature()); |
| } |
| } |
| |
| TEST_F(APISignatureTest, TypeRefsTest) { |
| v8::HandleScope handle_scope(isolate()); |
| |
| { |
| auto signature = RefObj(); |
| ExpectPass(*signature, "[{prop1: 'foo'}]", "[{'prop1':'foo'}]", |
| binding::AsyncResponseType::kNone); |
| ExpectPass(*signature, "[{prop1: 'foo', prop2: 2}]", |
| "[{'prop1':'foo','prop2':2}]", |
| binding::AsyncResponseType::kNone); |
| ExpectFailure(*signature, "[{prop1: 'foo', prop2: 'a'}]", |
| ArgumentError("obj", api_errors::PropertyError( |
| "prop2", InvalidType(kTypeInteger, |
| kTypeString)))); |
| } |
| |
| { |
| auto signature = RefEnum(); |
| ExpectPass(*signature, "['alpha']", "['alpha']", |
| binding::AsyncResponseType::kNone); |
| ExpectPass(*signature, "['beta']", "['beta']", |
| binding::AsyncResponseType::kNone); |
| ExpectFailure( |
| *signature, "['gamma']", |
| ArgumentError("enum", api_errors::InvalidEnumValue({"alpha", "beta"}))); |
| } |
| } |
| |
| TEST_F(APISignatureTest, ExpectedSignature) { |
| EXPECT_EQ("string string", OneString()->GetExpectedSignature()); |
| EXPECT_EQ("string string, integer int", |
| StringAndInt()->GetExpectedSignature()); |
| EXPECT_EQ("string string, optional integer int, boolean bool", |
| StringOptionalIntAndBool()->GetExpectedSignature()); |
| EXPECT_EQ("object obj", OneObject()->GetExpectedSignature()); |
| EXPECT_EQ("", NoArgs()->GetExpectedSignature()); |
| EXPECT_EQ("integer int, function callback", |
| IntAndCallback()->GetExpectedSignature()); |
| EXPECT_EQ("optional integer int, function callback", |
| OptionalIntAndCallback()->GetExpectedSignature()); |
| EXPECT_EQ("optional function callback", |
| OptionalCallback()->GetExpectedSignature()); |
| EXPECT_EQ( |
| "integer int, any any, optional object obj, optional function callback", |
| IntAnyOptionalObjectOptionalCallback()->GetExpectedSignature()); |
| EXPECT_EQ("refObj obj", RefObj()->GetExpectedSignature()); |
| EXPECT_EQ("refEnum enum", RefEnum()->GetExpectedSignature()); |
| } |
| |
| TEST_F(APISignatureTest, ParseIgnoringSchema) { |
| v8::HandleScope handle_scope(isolate()); |
| v8::Local<v8::Context> context = MainContext(); |
| |
| { |
| // Test with providing an optional callback. |
| auto signature = IntAndOptionalCallback(); |
| v8::LocalVector<v8::Value> v8_args = |
| StringToV8Vector(context, "[1, function() {}]"); |
| APISignature::JSONParseResult parse_result = |
| signature->ConvertArgumentsIgnoringSchema(context, v8_args); |
| EXPECT_FALSE(parse_result.error); |
| ASSERT_TRUE(parse_result.arguments_list); |
| EXPECT_EQ("[1]", ValueToString(*parse_result.arguments_list)); |
| EXPECT_FALSE(parse_result.callback.IsEmpty()); |
| EXPECT_EQ(binding::AsyncResponseType::kCallback, parse_result.async_type); |
| } |
| |
| { |
| // Test with omitting the optional callback. |
| auto signature = IntAndOptionalCallback(); |
| v8::LocalVector<v8::Value> v8_args = StringToV8Vector(context, "[1, null]"); |
| APISignature::JSONParseResult parse_result = |
| signature->ConvertArgumentsIgnoringSchema(context, v8_args); |
| EXPECT_FALSE(parse_result.error); |
| ASSERT_TRUE(parse_result.arguments_list); |
| EXPECT_EQ("[1]", ValueToString(*parse_result.arguments_list)); |
| EXPECT_TRUE(parse_result.callback.IsEmpty()); |
| EXPECT_EQ(binding::AsyncResponseType::kNone, parse_result.async_type); |
| } |
| |
| { |
| // Test with providing something completely different than the spec, which |
| // is (unfortunately) allowed and used. |
| auto signature = OneString(); |
| v8::LocalVector<v8::Value> v8_args = |
| StringToV8Vector(context, "[{not: 'a string'}]"); |
| APISignature::JSONParseResult parse_result = |
| signature->ConvertArgumentsIgnoringSchema(context, v8_args); |
| EXPECT_FALSE(parse_result.error); |
| ASSERT_TRUE(parse_result.arguments_list); |
| EXPECT_EQ(R"([{"not":"a string"}])", |
| ValueToString(*parse_result.arguments_list)); |
| EXPECT_TRUE(parse_result.callback.IsEmpty()); |
| EXPECT_EQ(binding::AsyncResponseType::kNone, parse_result.async_type); |
| } |
| |
| { |
| auto signature = OneObject(); |
| v8::LocalVector<v8::Value> v8_args = StringToV8Vector( |
| context, "[{prop1: 'foo', other: 'bar', nullProp: null}]"); |
| APISignature::JSONParseResult parse_result = |
| signature->ConvertArgumentsIgnoringSchema(context, v8_args); |
| EXPECT_FALSE(parse_result.error); |
| ASSERT_TRUE(parse_result.arguments_list); |
| EXPECT_EQ(R"([{"other":"bar","prop1":"foo"}])", |
| ValueToString(*parse_result.arguments_list)); |
| EXPECT_TRUE(parse_result.callback.IsEmpty()); |
| EXPECT_EQ(binding::AsyncResponseType::kNone, parse_result.async_type); |
| } |
| |
| { |
| // Unserializable arguments are inserted as "null" in the argument list in |
| // order to match existing JS bindings behavior. |
| // See https://crbug.com/924045. |
| auto signature = OneString(); |
| v8::LocalVector<v8::Value> v8_args = |
| StringToV8Vector(context, "[1, undefined, 1/0]"); |
| APISignature::JSONParseResult parse_result = |
| signature->ConvertArgumentsIgnoringSchema(context, v8_args); |
| EXPECT_FALSE(parse_result.error); |
| ASSERT_TRUE(parse_result.arguments_list); |
| EXPECT_EQ("[1,null,null]", ValueToString(*parse_result.arguments_list)); |
| EXPECT_TRUE(parse_result.callback.IsEmpty()); |
| EXPECT_EQ(binding::AsyncResponseType::kNone, parse_result.async_type); |
| } |
| } |
| |
| TEST_F(APISignatureTest, ParseIgnoringSchemaWithPromises) { |
| v8::HandleScope handle_scope(isolate()); |
| v8::Local<v8::Context> context = MainContext(); |
| bool context_allows_promises = true; |
| auto promises_available = base::BindRepeating( |
| [](bool* flag, v8::Local<v8::Context> context) { return *flag; }, |
| &context_allows_promises); |
| auto api_available = |
| base::BindRepeating([](v8::Local<v8::Context> context, |
| const std::string& name) { return true; }); |
| BindingAccessChecker access_checker(api_available, promises_available); |
| |
| SpecVector specs; |
| specs.push_back(ArgumentSpecBuilder(ArgumentType::INTEGER, "int").Build()); |
| auto int_and_optional_callback = std::make_unique<APISignature>( |
| std::move(specs), |
| ReturnsAsyncBuilder().MakeOptional().AddPromiseSupport().Build(), |
| &access_checker); |
| |
| { |
| // Test with providing an optional callback. |
| v8::LocalVector<v8::Value> v8_args = |
| StringToV8Vector(context, "[1, function() {}]"); |
| APISignature::JSONParseResult parse_result = |
| int_and_optional_callback->ConvertArgumentsIgnoringSchema(context, |
| v8_args); |
| EXPECT_FALSE(parse_result.error); |
| ASSERT_TRUE(parse_result.arguments_list); |
| EXPECT_EQ("[1]", ValueToString(*parse_result.arguments_list)); |
| EXPECT_FALSE(parse_result.callback.IsEmpty()); |
| EXPECT_TRUE(parse_result.callback->IsFunction()); |
| EXPECT_EQ(binding::AsyncResponseType::kCallback, parse_result.async_type); |
| } |
| |
| { |
| // Test with omitting the optional callback. |
| v8::LocalVector<v8::Value> v8_args = StringToV8Vector(context, "[1, null]"); |
| APISignature::JSONParseResult parse_result = |
| int_and_optional_callback->ConvertArgumentsIgnoringSchema(context, |
| v8_args); |
| EXPECT_FALSE(parse_result.error); |
| ASSERT_TRUE(parse_result.arguments_list); |
| EXPECT_EQ("[1]", ValueToString(*parse_result.arguments_list)); |
| EXPECT_TRUE(parse_result.callback.IsEmpty()); |
| EXPECT_EQ(binding::AsyncResponseType::kPromise, parse_result.async_type); |
| } |
| |
| { |
| // Test with providing something completely different than the spec, which |
| // is (unfortunately) allowed and used. |
| v8::LocalVector<v8::Value> v8_args = |
| StringToV8Vector(context, "[{not: 'an int'}, null]"); |
| APISignature::JSONParseResult parse_result = |
| int_and_optional_callback->ConvertArgumentsIgnoringSchema(context, |
| v8_args); |
| EXPECT_FALSE(parse_result.error); |
| ASSERT_TRUE(parse_result.arguments_list); |
| EXPECT_EQ(R"([{"not":"an int"}])", |
| ValueToString(*parse_result.arguments_list)); |
| EXPECT_TRUE(parse_result.callback.IsEmpty()); |
| EXPECT_EQ(binding::AsyncResponseType::kPromise, parse_result.async_type); |
| } |
| |
| { |
| // If promises are not available and the optional callback is omitted, we |
| // should not get a promise response type. |
| context_allows_promises = false; |
| v8::LocalVector<v8::Value> v8_args = StringToV8Vector(context, "[1, null]"); |
| APISignature::JSONParseResult parse_result = |
| int_and_optional_callback->ConvertArgumentsIgnoringSchema(context, |
| v8_args); |
| EXPECT_FALSE(parse_result.error); |
| ASSERT_TRUE(parse_result.arguments_list); |
| EXPECT_EQ("[1]", ValueToString(*parse_result.arguments_list)); |
| EXPECT_TRUE(parse_result.callback.IsEmpty()); |
| EXPECT_EQ(binding::AsyncResponseType::kNone, parse_result.async_type); |
| } |
| } |
| |
| TEST_F(APISignatureTest, ParseArgumentsToV8) { |
| v8::HandleScope handle_scope(isolate()); |
| v8::Local<v8::Context> context = MainContext(); |
| |
| // Test that parsing a signature returns values that are free of tricky |
| // getters. This is more thoroughly tested in the ArgumentSpec conversion |
| // unittests, but verify that it applies to signature parsing. |
| auto signature = OneObject(); |
| constexpr char kTrickyArgs[] = R"( |
| [{ |
| get prop1() { |
| if (this.got) |
| return 'bar'; |
| this.got = true; |
| return 'foo'; |
| }, |
| prop2: 'baz' |
| }])"; |
| v8::LocalVector<v8::Value> args = StringToV8Vector(context, kTrickyArgs); |
| |
| APISignature::V8ParseResult parse_result = |
| signature->ParseArgumentsToV8(context, args, type_refs()); |
| ASSERT_TRUE(parse_result.arguments); |
| |
| ASSERT_EQ(1u, parse_result.arguments->size()); |
| ASSERT_TRUE((*parse_result.arguments)[0]->IsObject()); |
| gin::Dictionary dict(isolate(), |
| (*parse_result.arguments)[0].As<v8::Object>()); |
| |
| std::string prop1; |
| ASSERT_TRUE(dict.Get("prop1", &prop1)); |
| EXPECT_EQ("foo", prop1); |
| |
| std::string prop2; |
| ASSERT_TRUE(dict.Get("prop2", &prop2)); |
| EXPECT_EQ("baz", prop2); |
| } |
| |
| // Tests that unspecified optional callback is filled with NullCallback in |
| // APISignature. |
| // |
| // Regression test for https://crbug.com/1218569. |
| TEST_F(APISignatureTest, ParseArgumentsToV8WithUnspecifiedOptionalCallback) { |
| v8::HandleScope handle_scope(isolate()); |
| v8::Local<v8::Context> context = MainContext(); |
| |
| bool context_allows_promises = true; |
| auto promises_available = base::BindRepeating( |
| [](bool* flag, v8::Local<v8::Context> context) { return *flag; }, |
| &context_allows_promises); |
| auto api_available = |
| base::BindRepeating([](v8::Local<v8::Context> context, |
| const std::string& name) { return true; }); |
| BindingAccessChecker access_checker(api_available, promises_available); |
| |
| SpecVector specs; |
| specs.push_back(ArgumentSpecBuilder(ArgumentType::INTEGER, "int").Build()); |
| auto signature = std::make_unique<APISignature>( |
| std::move(specs), |
| ReturnsAsyncBuilder().MakeOptional().AddPromiseSupport().Build(), |
| &access_checker); |
| |
| v8::LocalVector<v8::Value> args = StringToV8Vector(context, R"([1337])"); |
| |
| APISignature::V8ParseResult parse_result = |
| signature->ParseArgumentsToV8(context, args, type_refs()); |
| ASSERT_TRUE(parse_result.arguments); |
| |
| ASSERT_EQ(2u, parse_result.arguments->size()); |
| int int_value = -1; |
| gin::ConvertFromV8(v8::Isolate::GetCurrent(), (*parse_result.arguments)[0], |
| &int_value); |
| EXPECT_EQ(1337, int_value); |
| ASSERT_FALSE((*parse_result.arguments)[1].IsEmpty()); |
| EXPECT_TRUE((*parse_result.arguments)[1]->IsNull()); |
| } |
| |
| // Tests response validation, which is stricter than typical validation. |
| TEST_F(APISignatureTest, ValidateResponse) { |
| v8::HandleScope handle_scope(isolate()); |
| |
| { |
| auto signature = std::make_unique<APISignature>( |
| SpecVector(), ReturnsAsyncBuilder(StringAndIntSpec()).Build(), nullptr); |
| ExpectResponsePass(*signature, "['hello', 42]"); |
| ExpectResponseFailure( |
| *signature, "['hello', 'goodbye']", |
| ArgumentError("int", InvalidType(kTypeInteger, kTypeString))); |
| } |
| |
| { |
| auto signature = std::make_unique<APISignature>( |
| SpecVector(), |
| ReturnsAsyncBuilder(StringOptionalIntAndBoolSpec()).Build(), nullptr); |
| ExpectResponsePass(*signature, "['hello', 42, true]"); |
| ExpectResponsePass(*signature, "['hello', null, true]"); |
| // Responses are not allowed to omit optional inner parameters. |
| ExpectResponseFailure( |
| *signature, "['hello', true]", |
| ArgumentError("int", InvalidType(kTypeInteger, kTypeBoolean))); |
| } |
| |
| { |
| auto signature = std::make_unique<APISignature>( |
| SpecVector(), ReturnsAsyncBuilder(StringAndOptionalIntSpec()).Build(), |
| nullptr); |
| // Responses *are* allowed to omit optional trailing parameters (which will |
| // then be `undefined` to the caller). |
| ExpectResponsePass(*signature, "['hello']"); |
| |
| ExpectResponseFailure( |
| *signature, "['hello', true]", |
| ArgumentError("int", InvalidType(kTypeInteger, kTypeBoolean))); |
| } |
| } |
| |
| // Tests signature parsing when promise-based responses are supported. |
| TEST_F(APISignatureTest, PromisesSupport) { |
| v8::HandleScope handle_scope(isolate()); |
| auto api_available = |
| base::BindRepeating([](v8::Local<v8::Context> context, |
| const std::string& name) { return true; }); |
| // Set up a boolean we can flip to simulate if a context supports promises. |
| // For clarity, this should be explicitly set before each testcase below. |
| bool context_allows_promises = true; |
| auto promises_available = base::BindRepeating( |
| [](bool* flag, v8::Local<v8::Context> context) { return *flag; }, |
| &context_allows_promises); |
| BindingAccessChecker access_checker(api_available, promises_available); |
| |
| { |
| // Test a signature with a required callback. |
| context_allows_promises = true; |
| |
| auto required_callback_signature = std::make_unique<APISignature>( |
| SpecVector(), ReturnsAsyncBuilder().Build(), &access_checker); |
| // By default, APIs don't support promises, and passing in no arguments |
| // should fail. |
| ExpectFailure(*required_callback_signature, "[]", NoMatchingSignature()); |
| } |
| |
| { |
| // If we allow promises on the API, parsing the arguments should succeed |
| // (with a promise-based response type) if the context supports promises. |
| context_allows_promises = true; |
| |
| auto required_callback_signature = std::make_unique<APISignature>( |
| SpecVector(), ReturnsAsyncBuilder().AddPromiseSupport().Build(), |
| &access_checker); |
| ExpectPass(*required_callback_signature, "[]", "[]", |
| binding::AsyncResponseType::kPromise); |
| |
| // Ensure that the promise support allowing the final argument to be |
| // optional doesn't mean we can ignore it entirely if it doesn't match the |
| // signature. See: http://crbug.com/1350315 |
| ExpectFailure(*required_callback_signature, "['foo']", |
| NoMatchingSignature()); |
| |
| // If the context doesn't support promises, parsing should fail if the |
| // required callback is left off. |
| context_allows_promises = false; |
| ExpectFailure(*required_callback_signature, "[]", NoMatchingSignature()); |
| } |
| |
| { |
| // Next, try an optional callback. |
| context_allows_promises = true; |
| |
| auto optional_callback_signature = std::make_unique<APISignature>( |
| SpecVector(), ReturnsAsyncBuilder().MakeOptional().Build(), |
| &access_checker); |
| // Even if promises aren't supported, parsing should succeed, because the |
| // callback is optional. |
| ExpectPass(*optional_callback_signature, "[]", "[]", |
| binding::AsyncResponseType::kNone); |
| } |
| |
| { |
| // If we allow promises on the API, parsing the arguments should succeed, |
| // with a promise-based response type. |
| context_allows_promises = true; |
| |
| auto optional_callback_signature = std::make_unique<APISignature>( |
| SpecVector(), |
| ReturnsAsyncBuilder().MakeOptional().AddPromiseSupport().Build(), |
| &access_checker); |
| ExpectPass(*optional_callback_signature, "[]", "[]", |
| binding::AsyncResponseType::kPromise); |
| // If the context doesn't support promises, the call should still pass, but |
| // there shouldn't be a promise response type. |
| context_allows_promises = false; |
| ExpectPass(*optional_callback_signature, "[]", "[]", |
| binding::AsyncResponseType::kNone); |
| } |
| } |
| |
| } // namespace extensions |
