module_system_test.h 5.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153
  1. // Copyright 2014 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #ifndef EXTENSIONS_RENDERER_MODULE_SYSTEM_TEST_H_
  5. #define EXTENSIONS_RENDERER_MODULE_SYSTEM_TEST_H_
  6. #include <set>
  7. #include "base/memory/ref_counted.h"
  8. #include "base/test/task_environment.h"
  9. #include "extensions/renderer/module_system.h"
  10. #include "extensions/renderer/script_context.h"
  11. #include "extensions/renderer/script_context_set.h"
  12. #include "extensions/renderer/test_extensions_renderer_client.h"
  13. #include "gin/public/context_holder.h"
  14. #include "gin/public/isolate_holder.h"
  15. #include "testing/gtest/include/gtest/gtest.h"
  16. #include "v8/include/v8-forward.h"
  17. namespace extensions {
  18. class Extension;
  19. class NativeExtensionBindingsSystem;
  20. class StringSourceMap;
  21. class ModuleSystemTestEnvironment {
  22. public:
  23. class AssertNatives;
  24. ModuleSystemTestEnvironment(v8::Isolate* isolate,
  25. ScriptContextSet* context_set,
  26. scoped_refptr<const Extension> extension);
  27. ModuleSystemTestEnvironment(const ModuleSystemTestEnvironment&) = delete;
  28. ModuleSystemTestEnvironment& operator=(const ModuleSystemTestEnvironment&) =
  29. delete;
  30. ~ModuleSystemTestEnvironment();
  31. // Register a named JS module in the module system.
  32. void RegisterModule(const std::string& name, const std::string& code);
  33. // Register a named JS module with source retrieved from a ResourceBundle.
  34. void RegisterModule(const std::string& name,
  35. int resource_id,
  36. bool gzipped = false);
  37. // Register a named JS module in the module system and tell the module system
  38. // to use it to handle any requireNative() calls for native modules with that
  39. // name.
  40. void OverrideNativeHandler(const std::string& name, const std::string& code);
  41. // Registers |file_name| from chrome/test/data/extensions as a module name
  42. // |module_name|.
  43. void RegisterTestFile(const std::string& module_name,
  44. const std::string& file_name);
  45. // Create an empty object in the global scope with name |name|.
  46. v8::Local<v8::Object> CreateGlobal(const std::string& name);
  47. // Registers a native field in the ModuleSystem.
  48. void SetLazyField(v8::Local<v8::Object> object,
  49. const std::string& field,
  50. const std::string& module_name,
  51. const std::string& module_field);
  52. void ShutdownGin();
  53. void ShutdownModuleSystem();
  54. ModuleSystem* module_system() { return context_->module_system(); }
  55. ScriptContext* context() { return context_; }
  56. v8::Isolate* isolate() { return isolate_; }
  57. StringSourceMap* source_map() { return source_map_.get(); }
  58. AssertNatives* assert_natives() { return assert_natives_; }
  59. private:
  60. v8::Isolate* isolate_;
  61. std::unique_ptr<gin::ContextHolder> context_holder_;
  62. v8::HandleScope handle_scope_;
  63. scoped_refptr<const Extension> extension_;
  64. ScriptContextSet* context_set_;
  65. ScriptContext* context_;
  66. AssertNatives* assert_natives_;
  67. std::unique_ptr<StringSourceMap> source_map_;
  68. std::unique_ptr<NativeExtensionBindingsSystem> bindings_system_;
  69. };
  70. // Test fixture for testing JS that makes use of the module system.
  71. //
  72. // Typically tests will look like:
  73. //
  74. // TEST_F(MyModuleSystemTest, TestStuff) {
  75. // ModuleSystem::NativesEnabledScope natives_enabled(module_system_.get());
  76. // RegisterModule("test", "requireNative('assert').AssertTrue(true);");
  77. // module_system_->Require("test");
  78. // }
  79. //
  80. // By default a test will fail if no method in the native module 'assert' is
  81. // called. This behaviour can be overridden by calling ExpectNoAssertionsMade().
  82. class ModuleSystemTest : public testing::Test {
  83. public:
  84. ModuleSystemTest();
  85. ModuleSystemTest(const ModuleSystemTest&) = delete;
  86. ModuleSystemTest& operator=(const ModuleSystemTest&) = delete;
  87. ~ModuleSystemTest() override;
  88. void SetUp() override;
  89. void TearDown() override;
  90. protected:
  91. ModuleSystemTestEnvironment* env() { return env_.get(); }
  92. // Create the extension used with the ModuleSystemTestEnvironment. Virtual so
  93. // that subclasses can return extensions with different features.
  94. virtual scoped_refptr<const Extension> CreateExtension();
  95. std::unique_ptr<ModuleSystemTestEnvironment> CreateEnvironment();
  96. // Make the test fail if any asserts are called. By default a test will fail
  97. // if no asserts are called.
  98. void ExpectNoAssertionsMade();
  99. // Runs promises that have been resolved. Resolved promises will not run
  100. // until this is called.
  101. void RunResolvedPromises();
  102. private:
  103. base::test::TaskEnvironment task_environment_;
  104. gin::IsolateHolder isolate_holder_;
  105. v8::Isolate* isolate_;
  106. std::set<std::string> extension_ids_;
  107. ScriptContextSet context_set_;
  108. TestExtensionsRendererClient renderer_client_;
  109. scoped_refptr<const Extension> extension_;
  110. std::unique_ptr<ModuleSystemTestEnvironment> env_;
  111. bool should_assertions_be_made_;
  112. };
  113. } // namespace extensions
  114. #endif // EXTENSIONS_RENDERER_MODULE_SYSTEM_TEST_H_