PaymentResponse tests

third_party/WebKit/Source/modules/payments/PaymentResponseTest.cpp

 // Copyright 2016 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 "modules/payments/PaymentResponse.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptState.h"
+#include "bindings/core/v8/ScriptValue.h"
 #include "core/testing/DummyPageHolder.h"
 #include "modules/payments/PaymentCompleter.h"
-#include "modules/payments/PaymentDetailsTestHelper.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "wtf/OwnPtr.h"
 #include <utility>
 
 namespace blink {
-namespace {

[Marijn Kruisselbrink, 2016/05/02 18:04:58]

Any particular reason you got rid of the anonymous namespace?

I would at least keep MockPaymentCompleter in an anonymous namespace (for the
tests themselves there isn't much reason to keep the anonymous namespace, since
those names should be unique anyway, but I'd keep helpers such as
MockPaymentCompleter properly isolated).

[please use gerrit instead, 2016/05/02 18:17:24]

`git cl format` kept trying to indent anonymous namespace code +4. Since you
feel that the anonymous namespace provides positive value in tests, I am
bringing it back.

[Marijn Kruisselbrink, 2016/05/02 18:53:48]

Ah, yeah, git cl format on blink code never seems to work quite well...
Hopefully it won't be long until the more unified coding style. (and I don't
really care if the actual tests are in an anonymous namespace, but helpers suck
as MockPaymentCompleter, that could conceivably exist in multiple test files
definitely should be in an anonymous namespace to prevent hard to detect bugs).

 
 class MockPaymentCompleter : public GarbageCollectedFinalized<MockPaymentCompleter>, public PaymentCompleter {
     USING_GARBAGE_COLLECTED_MIXIN(MockPaymentCompleter);
     WTF_MAKE_NONCOPYABLE(MockPaymentCompleter);
 
 public:
     MockPaymentCompleter()
     {
         ON_CALL(*this, complete(testing::_, testing::_))
             .WillByDefault(testing::ReturnPointee(&m_dummyPromise));
     }
 
     ~MockPaymentCompleter() override {}
 
     MOCK_METHOD2(complete, ScriptPromise(ScriptState*, bool success));
 
     DEFINE_INLINE_TRACE() {}
 
 private:
     ScriptPromise m_dummyPromise;
 };
 
 class PaymentResponseTest : public testing::Test {
 public:
     PaymentResponseTest()
         : m_page(DummyPageHolder::create())
     {
-        m_page->document().setSecurityOrigin(SecurityOrigin::create(KURL(KURL(), "https://www.example.com/")));
     }
 
     ~PaymentResponseTest() override {}
 
     ScriptState* getScriptState() { return ScriptState::forMainWorld(m_page->document().frame()); }
     ExceptionState& getExceptionState() { return m_exceptionState; }
 
 private:
     OwnPtr<DummyPageHolder> m_page;
     NonThrowableExceptionState m_exceptionState;
 };
 
 TEST_F(PaymentResponseTest, DataCopiedOver)
 {
+    ScriptState::Scope scope(getScriptState());
     mojom::blink::PaymentResponsePtr input = mojom::blink::PaymentResponse::New();
     input->method_name = "foo";
     input->stringified_details = "{\"transactionId\": 123}";
     MockPaymentCompleter* completeCallback = new MockPaymentCompleter;
 
     PaymentResponse output(std::move(input), completeCallback);
 
-    // TODO(rouslan): Verify that output.details() contains parsed input->stringified_details.
-    EXPECT_FALSE(getExceptionState().hadException());
+    ASSERT_FALSE(getExceptionState().hadException());

[Marijn Kruisselbrink, 2016/05/02 18:04:58]

This assert seems a bit unnecessary? At this point nothing has accessed
m_exceptionState yet, so all this is testing is the constructor of
NonThrowableExceptionState?

[please use gerrit instead, 2016/05/02 18:17:24]

Removed. Not sure why it was here.

     EXPECT_EQ("foo", output.methodName());
+
+    ScriptValue details = output.details(getScriptState(), getExceptionState());
+
+    ASSERT_FALSE(getExceptionState().hadException());
+    ASSERT_TRUE(details.v8Value()->IsObject());
+
+    ScriptValue transactionId(getScriptState(), details.v8Value().As<v8::Object>()->Get(v8String(getScriptState()->isolate(), "transactionId")));
+
+    ASSERT_TRUE(transactionId.v8Value()->IsNumber());
+    EXPECT_EQ(123, transactionId.v8Value().As<v8::Number>()->Value());
 }
 
-TEST_F(PaymentResponseTest, CompleteCalled)
+TEST_F(PaymentResponseTest, CompleteCalledWithSuccess)
 {
     mojom::blink::PaymentResponsePtr input = mojom::blink::PaymentResponse::New();
     input->method_name = "foo";
     input->stringified_details = "{\"transactionId\": 123}";
     MockPaymentCompleter* completeCallback = new MockPaymentCompleter;
     PaymentResponse output(std::move(input), completeCallback);
 
     EXPECT_FALSE(getExceptionState().hadException());
     EXPECT_CALL(*completeCallback, complete(getScriptState(), true));
 
     output.complete(getScriptState(), true);
 }
 
-} // namespace
+TEST_F(PaymentResponseTest, CompleteCalledWithFailure)
+{
+    mojom::blink::PaymentResponsePtr input = mojom::blink::PaymentResponse::New();
+    input->method_name = "foo";
+    input->stringified_details = "{\"transactionId\": 123}";
+    MockPaymentCompleter* completeCallback = new MockPaymentCompleter;
+    PaymentResponse output(std::move(input), completeCallback);
+
+    EXPECT_FALSE(getExceptionState().hadException());
+    EXPECT_CALL(*completeCallback, complete(getScriptState(), false));
+
+    output.complete(getScriptState(), false);
+}
+
 } // namespace blink