// Copyright 2014 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 "extensions/renderer/module_system.h"

#include <stdint.h>

#include <memory>
#include <utility>

#include "extensions/renderer/module_system_test.h"
#include "gin/modules/module_registry.h"

namespace extensions {

class CounterNatives : public ObjectBackedNativeHandler {
 public:
  explicit CounterNatives(ScriptContext* context)
      : ObjectBackedNativeHandler(context), counter_(0) {
    RouteFunction("Get",
                  base::Bind(&CounterNatives::Get, base::Unretained(this)));
    RouteFunction(
        "Increment",
        base::Bind(&CounterNatives::Increment, base::Unretained(this)));
  }

  void Get(const v8::FunctionCallbackInfo<v8::Value>& args) {
    args.GetReturnValue().Set(static_cast<int32_t>(counter_));
  }

  void Increment(const v8::FunctionCallbackInfo<v8::Value>& args) {
    counter_++;
  }

 private:
  int counter_;
};

class TestExceptionHandler : public ModuleSystem::ExceptionHandler {
 public:
  TestExceptionHandler()
      : ModuleSystem::ExceptionHandler(nullptr), handled_exception_(false) {}

  void HandleUncaughtException(const v8::TryCatch& try_catch) override {
    handled_exception_ = true;
  }

  bool handled_exception() const { return handled_exception_; }

 private:
  bool handled_exception_;
};

TEST_F(ModuleSystemTest, TestExceptionHandling) {
  ModuleSystem::NativesEnabledScope natives_enabled_scope(
      env()->module_system());
  TestExceptionHandler* handler = new TestExceptionHandler;
  std::unique_ptr<ModuleSystem::ExceptionHandler> scoped_handler(handler);
  ASSERT_FALSE(handler->handled_exception());
  env()->module_system()->SetExceptionHandlerForTest(std::move(scoped_handler));

  env()->RegisterModule("test", "throw 'hi';");
  env()->module_system()->Require("test");
  ASSERT_TRUE(handler->handled_exception());

  ExpectNoAssertionsMade();
}

TEST_F(ModuleSystemTest, TestRequire) {
  ModuleSystem::NativesEnabledScope natives_enabled_scope(
      env()->module_system());
  env()->RegisterModule("add",
                        "exports.$set('Add',"
                                     "function(x, y) { return x + y; });");
  env()->RegisterModule("test",
                        "var Add = require('add').Add;"
                        "requireNative('assert').AssertTrue(Add(3, 5) == 8);");
  env()->module_system()->Require("test");
}

TEST_F(ModuleSystemTest, TestNestedRequire) {
  ModuleSystem::NativesEnabledScope natives_enabled_scope(
      env()->module_system());
  env()->RegisterModule("add",
                        "exports.$set('Add',"
                                     "function(x, y) { return x + y; });");
  env()->RegisterModule("double",
                        "var Add = require('add').Add;"
                        "exports.$set('Double',"
                                     "function(x) { return Add(x, x); });");
  env()->RegisterModule("test",
                        "var Double = require('double').Double;"
                        "requireNative('assert').AssertTrue(Double(3) == 6);");
  env()->module_system()->Require("test");
}

TEST_F(ModuleSystemTest, TestModuleInsulation) {
  ModuleSystem::NativesEnabledScope natives_enabled_scope(
      env()->module_system());
  env()->RegisterModule("x",
                        "var x = 10;"
                        "exports.$set('X', function() { return x; });");
  env()->RegisterModule("y",
                        "var x = 15;"
                        "require('x');"
                        "exports.$set('Y', function() { return x; });");
  env()->RegisterModule("test",
                        "var Y = require('y').Y;"
                        "var X = require('x').X;"
                        "var assert = requireNative('assert');"
                        "assert.AssertTrue(!this.hasOwnProperty('x'));"
                        "assert.AssertTrue(Y() == 15);"
                        "assert.AssertTrue(X() == 10);");
  env()->module_system()->Require("test");
}

TEST_F(ModuleSystemTest, TestNativesAreDisabledOutsideANativesEnabledScope) {
  env()->RegisterModule("test",
                        "var assert;"
                        "try {"
                        "  assert = requireNative('assert');"
                        "} catch (e) {"
                        "  var caught = true;"
                        "}"
                        "if (assert) {"
                        "  assert.AssertTrue(true);"
                        "}");
  env()->module_system()->Require("test");
  ExpectNoAssertionsMade();
}

TEST_F(ModuleSystemTest, TestNativesAreEnabledWithinANativesEnabledScope) {
  env()->RegisterModule("test",
                        "var assert = requireNative('assert');"
                        "assert.AssertTrue(true);");

  {
    ModuleSystem::NativesEnabledScope natives_enabled(env()->module_system());
    {
      ModuleSystem::NativesEnabledScope natives_enabled_inner(
          env()->module_system());
    }
    env()->module_system()->Require("test");
  }
}

TEST_F(ModuleSystemTest, TestLazyField) {
  ModuleSystem::NativesEnabledScope natives_enabled_scope(
      env()->module_system());
  env()->RegisterModule("lazy", "exports.$set('x', 5);");

  v8::Local<v8::Object> object = env()->CreateGlobal("object");

  env()->module_system()->SetLazyField(object, "blah", "lazy", "x");

  env()->RegisterModule("test",
                        "var assert = requireNative('assert');"
                        "assert.AssertTrue(object.blah == 5);");
  env()->module_system()->Require("test");
}

TEST_F(ModuleSystemTest, TestLazyFieldYieldingObject) {
  ModuleSystem::NativesEnabledScope natives_enabled_scope(
      env()->module_system());
  env()->RegisterModule(
      "lazy",
      "var object = {};"
      "object.__defineGetter__('z', function() { return 1; });"
      "object.x = 5;"
      "object.y = function() { return 10; };"
      "exports.$set('object', object);");

  v8::Local<v8::Object> object = env()->CreateGlobal("object");

  env()->module_system()->SetLazyField(object, "thing", "lazy", "object");

  env()->RegisterModule("test",
                        "var assert = requireNative('assert');"
                        "assert.AssertTrue(object.thing.x == 5);"
                        "assert.AssertTrue(object.thing.y() == 10);"
                        "assert.AssertTrue(object.thing.z == 1);");
  env()->module_system()->Require("test");
}

TEST_F(ModuleSystemTest, TestLazyFieldIsOnlyEvaledOnce) {
  ModuleSystem::NativesEnabledScope natives_enabled_scope(
      env()->module_system());
  env()->module_system()->RegisterNativeHandler(
      "counter",
      std::unique_ptr<NativeHandler>(new CounterNatives(env()->context())));
  env()->RegisterModule("lazy",
                        "requireNative('counter').Increment();"
                        "exports.$set('x', 5);");

  v8::Local<v8::Object> object = env()->CreateGlobal("object");

  env()->module_system()->SetLazyField(object, "x", "lazy", "x");

  env()->RegisterModule("test",
                        "var assert = requireNative('assert');"
                        "var counter = requireNative('counter');"
                        "assert.AssertTrue(counter.Get() == 0);"
                        "object.x;"
                        "assert.AssertTrue(counter.Get() == 1);"
                        "object.x;"
                        "assert.AssertTrue(counter.Get() == 1);");
  env()->module_system()->Require("test");
}

TEST_F(ModuleSystemTest, TestRequireNativesAfterLazyEvaluation) {
  ModuleSystem::NativesEnabledScope natives_enabled_scope(
      env()->module_system());
  env()->RegisterModule("lazy", "exports.$set('x', 5);");
  v8::Local<v8::Object> object = env()->CreateGlobal("object");

  env()->module_system()->SetLazyField(object, "x", "lazy", "x");
  env()->RegisterModule("test",
                        "object.x;"
                        "requireNative('assert').AssertTrue(true);");
  env()->module_system()->Require("test");
}

TEST_F(ModuleSystemTest, TestTransitiveRequire) {
  ModuleSystem::NativesEnabledScope natives_enabled_scope(
      env()->module_system());
  env()->RegisterModule("dependency", "exports.$set('x', 5);");
  env()->RegisterModule("lazy",
                        "exports.$set('output', require('dependency'));");

  v8::Local<v8::Object> object = env()->CreateGlobal("object");

  env()->module_system()->SetLazyField(object, "thing", "lazy", "output");

  env()->RegisterModule("test",
                        "var assert = requireNative('assert');"
                        "assert.AssertTrue(object.thing.x == 5);");
  env()->module_system()->Require("test");
}

TEST_F(ModuleSystemTest, TestModulesOnlyGetEvaledOnce) {
  ModuleSystem::NativesEnabledScope natives_enabled_scope(
      env()->module_system());
  env()->module_system()->RegisterNativeHandler(
      "counter",
      std::unique_ptr<NativeHandler>(new CounterNatives(env()->context())));

  env()->RegisterModule("incrementsWhenEvaled",
                        "requireNative('counter').Increment();");
  env()->RegisterModule("test",
                        "var assert = requireNative('assert');"
                        "var counter = requireNative('counter');"
                        "assert.AssertTrue(counter.Get() == 0);"
                        "require('incrementsWhenEvaled');"
                        "assert.AssertTrue(counter.Get() == 1);"
                        "require('incrementsWhenEvaled');"
                        "assert.AssertTrue(counter.Get() == 1);");

  env()->module_system()->Require("test");
}

TEST_F(ModuleSystemTest, TestOverrideNativeHandler) {
  ModuleSystem::NativesEnabledScope natives_enabled_scope(
      env()->module_system());
  env()->OverrideNativeHandler("assert",
                               "exports.$set('AssertTrue', function() {});");
  env()->RegisterModule("test", "requireNative('assert').AssertTrue(true);");
  ExpectNoAssertionsMade();
  env()->module_system()->Require("test");
}

TEST_F(ModuleSystemTest, TestOverrideNonExistentNativeHandler) {
  ModuleSystem::NativesEnabledScope natives_enabled_scope(
      env()->module_system());
  env()->OverrideNativeHandler("thing", "exports.$set('x', 5);");
  env()->RegisterModule("test",
                        "var assert = requireNative('assert');"
                        "assert.AssertTrue(requireNative('thing').x == 5);");
  env()->module_system()->Require("test");
}

TEST_F(ModuleSystemTest, TestRequireAsync) {
  ModuleSystem::NativesEnabledScope natives_enabled_scope(
      env()->module_system());
  env()->RegisterModule("add",
                        "define('add', [], function() {"
                        "  return { Add: function(x, y) { return x + y; } };"
                        "});");
  env()->RegisterModule("math",
                        "define('math', ['add'], function(add) {"
                        "  return { Add: add.Add };"
                        "});");
  env()->RegisterModule(
      "test",
      "requireAsync('math').then(function(math) {"
      "  requireNative('assert').AssertTrue(math.Add(3, 5) == 8);"
      "});");
  env()->module_system()->Require("test");
  RunResolvedPromises();
}

TEST_F(ModuleSystemTest, TestRequireAsyncInParallel) {
  ModuleSystem::NativesEnabledScope natives_enabled_scope(
      env()->module_system());
  env()->RegisterModule("add",
                        "define('add', [], function() {"
                        "  return { Add: function(x, y) { return x + y; } };"
                        "});");
  env()->RegisterModule(
      "subtract",
      "define('subtract', [], function() {"
      "  return { Subtract: function(x, y) { return x - y; } };"
      "});");
  env()->RegisterModule(
      "math",
      "exports.$set('AddAndSubtract', function(x, y, z) {"
      "  return Promise.all([requireAsync('add'),"
      "                      requireAsync('subtract')"
      "  ]).then(function(modules) {"
      "    return modules[1].Subtract(modules[0].Add(x, y), z);"
      "  });"
      "});");
  env()->RegisterModule("test",
                        "var AddAndSubtract = require('math').AddAndSubtract;"
                        "AddAndSubtract(3, 5, 2).then(function(result) {"
                        "  requireNative('assert').AssertTrue(result == 6);"
                        "});");
  env()->module_system()->Require("test");
  RunResolvedPromises();
}

TEST_F(ModuleSystemTest, TestNestedRequireAsyncs) {
  ModuleSystem::NativesEnabledScope natives_enabled_scope(
      env()->module_system());
  env()->RegisterModule("first",
                        "define('first', [], function() {"
                        "  return { next: 'second' };"
                        "});");
  env()->RegisterModule("second",
                        "define('second', [], function() {"
                        "  return { next: '' };"
                        "});");
  env()->RegisterModule(
      "test",
      "requireAsync('first').then(function(module) {"
      "  return requireAsync(module.next)"
      "}).then(function(module) {"
      "  requireNative('assert').AssertTrue(module.next === '');"
      "});");
  env()->module_system()->Require("test");
  RunResolvedPromises();
}

TEST_F(ModuleSystemTest, TestRequireFromAMDModule) {
  ModuleSystem::NativesEnabledScope natives_enabled_scope(
      env()->module_system());
  env()->RegisterModule(
      "add", "exports.$set('Add', function(x, y) { return x + y; });");
  env()->RegisterModule("math",
                        "define('math', [], function() {"
                        "  var add = require('add');"
                        "  return { Add: add.Add };"
                        "});");
  env()->RegisterModule(
      "test",
      "requireAsync('math').then(function(math) {"
      "  requireNative('assert').AssertTrue(math.Add(3, 5) == 8);"
      "});");
  env()->module_system()->Require("test");
  RunResolvedPromises();
}

TEST_F(ModuleSystemTest, TestRequireAsyncFromAMDModule) {
  ModuleSystem::NativesEnabledScope natives_enabled_scope(
      env()->module_system());
  env()->RegisterModule("add",
                        "define('add', [], function() {"
                        "  return { Add: function(x, y) { return x + y; } };"
                        "});");
  env()->RegisterModule("math",
                        "define('math', [], function() {"
                        "  function Add(x, y) {"
                        "    return requireAsync('add').then(function(add) {"
                        "      return add.Add(x, y);"
                        "    });"
                        "  }"
                        "  return { Add: Add };"
                        "});");
  env()->RegisterModule("test",
                        "requireAsync('math').then(function(math) {"
                        "  return math.Add(3, 6);"
                        "}).then(function(result) {"
                        "  requireNative('assert').AssertTrue(result == 9);"
                        "});");
  env()->module_system()->Require("test");
  RunResolvedPromises();
}

TEST_F(ModuleSystemTest, TestRequireAsyncFromAnotherContext) {
  ModuleSystem::NativesEnabledScope natives_enabled_scope(
      env()->module_system());
  env()->RegisterModule(
      "test",
      "requireAsync('natives').then(function(natives) {"
      "  natives.requireAsync('ping').then(function(ping) {"
      "    return ping();"
      "  }).then(function(result) {"
      "    requireNative('assert').AssertTrue(result == 'pong');"
      "  });"
      "});");
  std::unique_ptr<ModuleSystemTestEnvironment> other_env = CreateEnvironment();
  other_env->RegisterModule("ping",
                            "define('ping', ['natives'], function(natives) {"
                            "  return function() {"
                            "    return 'pong';"
                            "  }"
                            "});");
  gin::ModuleRegistry::From(env()->context()->v8_context())
      ->AddBuiltinModule(
          env()->isolate(), "natives",
          other_env->module_system()->NewInstance());
  gin::ModuleRegistry::From(other_env->context()->v8_context())
      ->AddBuiltinModule(
          env()->isolate(), "natives",
          env()->module_system()->NewInstance());
  env()->module_system()->Require("test");
  RunResolvedPromises();
}

TEST_F(ModuleSystemTest, TestRequireAsyncBetweenContexts) {
  ModuleSystem::NativesEnabledScope natives_enabled_scope(
      env()->module_system());
  env()->RegisterModule("pong",
                        "define('pong', [], function() {"
                        "  return function() { return 'done'; };"
                        "});");
  env()->RegisterModule(
      "test",
      "requireAsync('natives').then(function(natives) {"
      "  natives.requireAsync('ping').then(function(ping) {"
      "    return ping();"
      "  }).then(function(pong) {"
      "    return pong();"
      "  }).then(function(result) {"
      "    requireNative('assert').AssertTrue(result == 'done');"
      "  });"
      "});");
  std::unique_ptr<ModuleSystemTestEnvironment> other_env = CreateEnvironment();
  other_env->RegisterModule("ping",
                            "define('ping', ['natives'], function(natives) {"
                            "  return function() {"
                            "    return natives.requireAsync('pong');"
                            "  }"
                            "});");
  gin::ModuleRegistry::From(env()->context()->v8_context())
      ->AddBuiltinModule(
          env()->isolate(), "natives",
          other_env->module_system()->NewInstance());
  gin::ModuleRegistry::From(other_env->context()->v8_context())
      ->AddBuiltinModule(
          env()->isolate(), "natives",
          env()->module_system()->NewInstance());
  env()->module_system()->Require("test");
  RunResolvedPromises();
}

TEST_F(ModuleSystemTest, TestRequireAsyncFromContextWithNoModuleRegistry) {
  ModuleSystem::NativesEnabledScope natives_enabled_scope(
      env()->module_system());
  env()->RegisterModule("test",
                        "requireAsync('natives').then(function(natives) {"
                        "  var AssertTrue = requireNative('assert').AssertTrue;"
                        "  natives.requireAsync('foo').then(function() {"
                        "    AssertTrue(false);"
                        "  }).catch(function(error) {"
                        "    AssertTrue(error.message == "
                        "               'Extension view no longer exists');"
                        "  });"
                        "});");
  std::unique_ptr<ModuleSystemTestEnvironment> other_env = CreateEnvironment();
  gin::ModuleRegistry::From(env()->context()->v8_context())
      ->AddBuiltinModule(
          env()->isolate(), "natives",
          other_env->module_system()->NewInstance());
  other_env->ShutdownGin();
  env()->module_system()->Require("test");
  RunResolvedPromises();
}

TEST_F(ModuleSystemTest, TestRequireAsyncFromContextWithNoModuleSystem) {
  ModuleSystem::NativesEnabledScope natives_enabled_scope(
      env()->module_system());
  env()->RegisterModule("test",
                        "requireAsync('natives').then(function(natives) {"
                        "  requireNative('assert').AssertTrue("
                        "      natives.requireAsync('foo') === undefined);"
                        "});");
  std::unique_ptr<ModuleSystemTestEnvironment> other_env = CreateEnvironment();
  gin::ModuleRegistry::From(env()->context()->v8_context())
      ->AddBuiltinModule(
          env()->isolate(), "natives",
          other_env->module_system()->NewInstance());
  other_env->ShutdownModuleSystem();
  env()->module_system()->Require("test");
  RunResolvedPromises();
}

TEST_F(ModuleSystemTest, TestPrivatesIsPrivate) {
  ModuleSystem::NativesEnabledScope natives_enabled_scope(
      env()->module_system());
  env()->RegisterModule(
      "test",
      "var v = privates({});"
      "requireNative('assert').AssertFalse(v instanceof Object);");
  env()->module_system()->Require("test");
}

}  // namespace extensions