@sentry/wizard 3.38.0 → 3.40.0

package/e2e-tests/test-applications/flutter-test-app/windows/runner/win32_window.cpp

@@ -0,0 +1,288 @@
+#include "win32_window.h"
+
+#include <dwmapi.h>
+#include <flutter_windows.h>
+
+#include "resource.h"
+
+namespace {
+
+/// Window attribute that enables dark mode window decorations.
+///
+/// Redefined in case the developer's machine has a Windows SDK older than
+/// version 10.0.22000.0.
+/// See: https://docs.microsoft.com/windows/win32/api/dwmapi/ne-dwmapi-dwmwindowattribute
+#ifndef DWMWA_USE_IMMERSIVE_DARK_MODE
+#define DWMWA_USE_IMMERSIVE_DARK_MODE 20
+#endif
+
+constexpr const wchar_t kWindowClassName[] = L"FLUTTER_RUNNER_WIN32_WINDOW";
+
+/// Registry key for app theme preference.
+///
+/// A value of 0 indicates apps should use dark mode. A non-zero or missing
+/// value indicates apps should use light mode.
+constexpr const wchar_t kGetPreferredBrightnessRegKey[] =
+  L"Software\\Microsoft\\Windows\\CurrentVersion\\Themes\\Personalize";
+constexpr const wchar_t kGetPreferredBrightnessRegValue[] = L"AppsUseLightTheme";
+
+// The number of Win32Window objects that currently exist.
+static int g_active_window_count = 0;
+
+using EnableNonClientDpiScaling = BOOL __stdcall(HWND hwnd);
+
+// Scale helper to convert logical scaler values to physical using passed in
+// scale factor
+int Scale(int source, double scale_factor) {
+  return static_cast<int>(source * scale_factor);
+}
+
+// Dynamically loads the |EnableNonClientDpiScaling| from the User32 module.
+// This API is only needed for PerMonitor V1 awareness mode.
+void EnableFullDpiSupportIfAvailable(HWND hwnd) {
+  HMODULE user32_module = LoadLibraryA("User32.dll");
+  if (!user32_module) {
+    return;
+  }
+  auto enable_non_client_dpi_scaling =
+      reinterpret_cast<EnableNonClientDpiScaling*>(
+          GetProcAddress(user32_module, "EnableNonClientDpiScaling"));
+  if (enable_non_client_dpi_scaling != nullptr) {
+    enable_non_client_dpi_scaling(hwnd);
+  }
+  FreeLibrary(user32_module);
+}
+
+}  // namespace
+
+// Manages the Win32Window's window class registration.
+class WindowClassRegistrar {
+ public:
+  ~WindowClassRegistrar() = default;
+
+  // Returns the singleton registrar instance.
+  static WindowClassRegistrar* GetInstance() {
+    if (!instance_) {
+      instance_ = new WindowClassRegistrar();
+    }
+    return instance_;
+  }
+
+  // Returns the name of the window class, registering the class if it hasn't
+  // previously been registered.
+  const wchar_t* GetWindowClass();
+
+  // Unregisters the window class. Should only be called if there are no
+  // instances of the window.
+  void UnregisterWindowClass();
+
+ private:
+  WindowClassRegistrar() = default;
+
+  static WindowClassRegistrar* instance_;
+
+  bool class_registered_ = false;
+};
+
+WindowClassRegistrar* WindowClassRegistrar::instance_ = nullptr;
+
+const wchar_t* WindowClassRegistrar::GetWindowClass() {
+  if (!class_registered_) {
+    WNDCLASS window_class{};
+    window_class.hCursor = LoadCursor(nullptr, IDC_ARROW);
+    window_class.lpszClassName = kWindowClassName;
+    window_class.style = CS_HREDRAW | CS_VREDRAW;
+    window_class.cbClsExtra = 0;
+    window_class.cbWndExtra = 0;
+    window_class.hInstance = GetModuleHandle(nullptr);
+    window_class.hIcon =
+        LoadIcon(window_class.hInstance, MAKEINTRESOURCE(IDI_APP_ICON));
+    window_class.hbrBackground = 0;
+    window_class.lpszMenuName = nullptr;
+    window_class.lpfnWndProc = Win32Window::WndProc;
+    RegisterClass(&window_class);
+    class_registered_ = true;
+  }
+  return kWindowClassName;
+}
+
+void WindowClassRegistrar::UnregisterWindowClass() {
+  UnregisterClass(kWindowClassName, nullptr);
+  class_registered_ = false;
+}
+
+Win32Window::Win32Window() {
+  ++g_active_window_count;
+}
+
+Win32Window::~Win32Window() {
+  --g_active_window_count;
+  Destroy();
+}
+
+bool Win32Window::Create(const std::wstring& title,
+                         const Point& origin,
+                         const Size& size) {
+  Destroy();
+
+  const wchar_t* window_class =
+      WindowClassRegistrar::GetInstance()->GetWindowClass();
+
+  const POINT target_point = {static_cast<LONG>(origin.x),
+                              static_cast<LONG>(origin.y)};
+  HMONITOR monitor = MonitorFromPoint(target_point, MONITOR_DEFAULTTONEAREST);
+  UINT dpi = FlutterDesktopGetDpiForMonitor(monitor);
+  double scale_factor = dpi / 96.0;
+
+  HWND window = CreateWindow(
+      window_class, title.c_str(), WS_OVERLAPPEDWINDOW,
+      Scale(origin.x, scale_factor), Scale(origin.y, scale_factor),
+      Scale(size.width, scale_factor), Scale(size.height, scale_factor),
+      nullptr, nullptr, GetModuleHandle(nullptr), this);
+
+  if (!window) {
+    return false;
+  }
+
+  UpdateTheme(window);
+
+  return OnCreate();
+}
+
+bool Win32Window::Show() {
+  return ShowWindow(window_handle_, SW_SHOWNORMAL);
+}
+
+// static
+LRESULT CALLBACK Win32Window::WndProc(HWND const window,
+                                      UINT const message,
+                                      WPARAM const wparam,
+                                      LPARAM const lparam) noexcept {
+  if (message == WM_NCCREATE) {
+    auto window_struct = reinterpret_cast<CREATESTRUCT*>(lparam);
+    SetWindowLongPtr(window, GWLP_USERDATA,
+                     reinterpret_cast<LONG_PTR>(window_struct->lpCreateParams));
+
+    auto that = static_cast<Win32Window*>(window_struct->lpCreateParams);
+    EnableFullDpiSupportIfAvailable(window);
+    that->window_handle_ = window;
+  } else if (Win32Window* that = GetThisFromHandle(window)) {
+    return that->MessageHandler(window, message, wparam, lparam);
+  }
+
+  return DefWindowProc(window, message, wparam, lparam);
+}
+
+LRESULT
+Win32Window::MessageHandler(HWND hwnd,
+                            UINT const message,
+                            WPARAM const wparam,
+                            LPARAM const lparam) noexcept {
+  switch (message) {
+    case WM_DESTROY:
+      window_handle_ = nullptr;
+      Destroy();
+      if (quit_on_close_) {
+        PostQuitMessage(0);
+      }
+      return 0;
+
+    case WM_DPICHANGED: {
+      auto newRectSize = reinterpret_cast<RECT*>(lparam);
+      LONG newWidth = newRectSize->right - newRectSize->left;
+      LONG newHeight = newRectSize->bottom - newRectSize->top;
+
+      SetWindowPos(hwnd, nullptr, newRectSize->left, newRectSize->top, newWidth,
+                   newHeight, SWP_NOZORDER | SWP_NOACTIVATE);
+
+      return 0;
+    }
+    case WM_SIZE: {
+      RECT rect = GetClientArea();
+      if (child_content_ != nullptr) {
+        // Size and position the child window.
+        MoveWindow(child_content_, rect.left, rect.top, rect.right - rect.left,
+                   rect.bottom - rect.top, TRUE);
+      }
+      return 0;
+    }
+
+    case WM_ACTIVATE:
+      if (child_content_ != nullptr) {
+        SetFocus(child_content_);
+      }
+      return 0;
+
+    case WM_DWMCOLORIZATIONCOLORCHANGED:
+      UpdateTheme(hwnd);
+      return 0;
+  }
+
+  return DefWindowProc(window_handle_, message, wparam, lparam);
+}
+
+void Win32Window::Destroy() {
+  OnDestroy();
+
+  if (window_handle_) {
+    DestroyWindow(window_handle_);
+    window_handle_ = nullptr;
+  }
+  if (g_active_window_count == 0) {
+    WindowClassRegistrar::GetInstance()->UnregisterWindowClass();
+  }
+}
+
+Win32Window* Win32Window::GetThisFromHandle(HWND const window) noexcept {
+  return reinterpret_cast<Win32Window*>(
+      GetWindowLongPtr(window, GWLP_USERDATA));
+}
+
+void Win32Window::SetChildContent(HWND content) {
+  child_content_ = content;
+  SetParent(content, window_handle_);
+  RECT frame = GetClientArea();
+
+  MoveWindow(content, frame.left, frame.top, frame.right - frame.left,
+             frame.bottom - frame.top, true);
+
+  SetFocus(child_content_);
+}
+
+RECT Win32Window::GetClientArea() {
+  RECT frame;
+  GetClientRect(window_handle_, &frame);
+  return frame;
+}
+
+HWND Win32Window::GetHandle() {
+  return window_handle_;
+}
+
+void Win32Window::SetQuitOnClose(bool quit_on_close) {
+  quit_on_close_ = quit_on_close;
+}
+
+bool Win32Window::OnCreate() {
+  // No-op; provided for subclasses.
+  return true;
+}
+
+void Win32Window::OnDestroy() {
+  // No-op; provided for subclasses.
+}
+
+void Win32Window::UpdateTheme(HWND const window) {
+  DWORD light_mode;
+  DWORD light_mode_size = sizeof(light_mode);
+  LSTATUS result = RegGetValue(HKEY_CURRENT_USER, kGetPreferredBrightnessRegKey,
+                               kGetPreferredBrightnessRegValue,
+                               RRF_RT_REG_DWORD, nullptr, &light_mode,
+                               &light_mode_size);
+
+  if (result == ERROR_SUCCESS) {
+    BOOL enable_dark_mode = light_mode == 0;
+    DwmSetWindowAttribute(window, DWMWA_USE_IMMERSIVE_DARK_MODE,
+                          &enable_dark_mode, sizeof(enable_dark_mode));
+  }
+}

package/e2e-tests/test-applications/flutter-test-app/windows/runner/win32_window.h

@@ -0,0 +1,102 @@
+#ifndef RUNNER_WIN32_WINDOW_H_
+#define RUNNER_WIN32_WINDOW_H_
+
+#include <windows.h>
+
+#include <functional>
+#include <memory>
+#include <string>
+
+// A class abstraction for a high DPI-aware Win32 Window. Intended to be
+// inherited from by classes that wish to specialize with custom
+// rendering and input handling
+class Win32Window {
+ public:
+  struct Point {
+    unsigned int x;
+    unsigned int y;
+    Point(unsigned int x, unsigned int y) : x(x), y(y) {}
+  };
+
+  struct Size {
+    unsigned int width;
+    unsigned int height;
+    Size(unsigned int width, unsigned int height)
+        : width(width), height(height) {}
+  };
+
+  Win32Window();
+  virtual ~Win32Window();
+
+  // Creates a win32 window with |title| that is positioned and sized using
+  // |origin| and |size|. New windows are created on the default monitor. Window
+  // sizes are specified to the OS in physical pixels, hence to ensure a
+  // consistent size this function will scale the inputted width and height as
+  // as appropriate for the default monitor. The window is invisible until
+  // |Show| is called. Returns true if the window was created successfully.
+  bool Create(const std::wstring& title, const Point& origin, const Size& size);
+
+  // Show the current window. Returns true if the window was successfully shown.
+  bool Show();
+
+  // Release OS resources associated with window.
+  void Destroy();
+
+  // Inserts |content| into the window tree.
+  void SetChildContent(HWND content);
+
+  // Returns the backing Window handle to enable clients to set icon and other
+  // window properties. Returns nullptr if the window has been destroyed.
+  HWND GetHandle();
+
+  // If true, closing this window will quit the application.
+  void SetQuitOnClose(bool quit_on_close);
+
+  // Return a RECT representing the bounds of the current client area.
+  RECT GetClientArea();
+
+ protected:
+  // Processes and route salient window messages for mouse handling,
+  // size change and DPI. Delegates handling of these to member overloads that
+  // inheriting classes can handle.
+  virtual LRESULT MessageHandler(HWND window,
+                                 UINT const message,
+                                 WPARAM const wparam,
+                                 LPARAM const lparam) noexcept;
+
+  // Called when CreateAndShow is called, allowing subclass window-related
+  // setup. Subclasses should return false if setup fails.
+  virtual bool OnCreate();
+
+  // Called when Destroy is called.
+  virtual void OnDestroy();
+
+ private:
+  friend class WindowClassRegistrar;
+
+  // OS callback called by message pump. Handles the WM_NCCREATE message which
+  // is passed when the non-client area is being created and enables automatic
+  // non-client DPI scaling so that the non-client area automatically
+  // responds to changes in DPI. All other messages are handled by
+  // MessageHandler.
+  static LRESULT CALLBACK WndProc(HWND const window,
+                                  UINT const message,
+                                  WPARAM const wparam,
+                                  LPARAM const lparam) noexcept;
+
+  // Retrieves a class instance pointer for |window|
+  static Win32Window* GetThisFromHandle(HWND const window) noexcept;
+
+  // Update the window frame's theme to match the system theme.
+  static void UpdateTheme(HWND const window);
+
+  bool quit_on_close_ = false;
+
+  // window handle for top level window.
+  HWND window_handle_ = nullptr;
+
+  // window handle for hosted content.
+  HWND child_content_ = nullptr;
+};
+
+#endif  // RUNNER_WIN32_WINDOW_H_

package/e2e-tests/test-applications/nextjs-test-app/package.json

@@ -11,7 +11,7 @@
   "dependencies": {
     "react": "^18",
     "react-dom": "^18",
-    "next": "14.2.14"
+    "next": "14.2.21"
   },
   "devDependencies": {
     "typescript": "^5",

package/e2e-tests/tests/flutter.test.ts

@@ -0,0 +1,127 @@
+/* eslint-disable jest/expect-expect */
+import { Integration } from '../../lib/Constants';
+import {
+  // checkEnvBuildPlugin,
+  cleanupGit,
+  KEYS,
+  revertLocalChanges,
+} from '../utils';
+import { startWizardInstance } from '../utils';
+import {
+  checkFileContents,
+  // checkFileExists,
+  checkSentryProperties,
+  checkIfFlutterBuilds,
+} from '../utils';
+import * as path from 'path';
+import * as fs from 'fs';
+
+describe('Flutter', () => {
+  const integration = Integration.flutter;
+  const projectDir = path.resolve(
+    __dirname,
+    '../test-applications/flutter-test-app',
+  );
+
+  describe('with apple platforms', () => {
+    beforeAll(async () => {
+      const wizardInstance = startWizardInstance(integration, projectDir);
+  
+      const tracingOptionPrompted = await wizardInstance.waitForOutput(
+        // "Do you want to enable Tracing", sometimes doesn't work as `Tracing` can be printed in bold.
+        'to track the performance of your application?',
+      );
+  
+      const profilingOptionPrompted = tracingOptionPrompted &&
+        (await wizardInstance.sendStdinAndWaitForOutput(
+          [KEYS.ENTER],
+          // "Do you want to enable Profiling", sometimes doesn't work as `Profiling` can be printed in bold.
+          'to analyze CPU usage and optimize performance-critical code on iOS & macOS?',
+        ));
+  
+      profilingOptionPrompted &&
+        (await wizardInstance.sendStdinAndWaitForOutput(
+          [KEYS.ENTER],
+          'Successfully installed the Sentry Flutter SDK!',
+        ));
+  
+      wizardInstance.kill();
+    });
+  
+    afterAll(() => {
+      revertLocalChanges(projectDir);
+      cleanupGit(projectDir);
+    });
+  
+    test('pubspec.yaml is updated.', () => {
+      checkFileContents(`${projectDir}/pubspec.yaml`, `sentry_flutter:`); // dependencies
+      checkFileContents(`${projectDir}/pubspec.yaml`, `sentry_dart_plugin:`); // dev_dependencies
+      checkFileContents(`${projectDir}/pubspec.yaml`, `sentry:`); // gradle plugin options
+    });
+  
+    test('sentry.properties exists and has auth token', () => {
+      checkSentryProperties(projectDir);
+    });
+  
+    test('.gitignore has sentry.properties', () => {
+      checkFileContents(`${projectDir}/.gitignore`, `sentry.properties`);
+    });
+    
+    test('lib/main.dart calls sentry init', () => {
+      checkFileContents(`${projectDir}/lib/main.dart`, `import 'package:sentry_flutter/sentry_flutter.dart';`);
+      checkFileContents(`${projectDir}/lib/main.dart`, `await SentryFlutter.init(`);
+    });
+  
+    test('lib/main.dart enables tracing and profiling', () => {
+      checkFileContents(`${projectDir}/lib/main.dart`, `options.tracesSampleRate = 1.0;`);
+      checkFileContents(`${projectDir}/lib/main.dart`, `options.profilesSampleRate = 1.0;`);
+    });
+  
+    test('builds correctly', async () => {
+      await checkIfFlutterBuilds(projectDir, '✓ Built build/web');
+    });
+  });
+
+  describe('without apple platforms', () => {
+    beforeAll(async () => {
+      
+      const wizardInstance = startWizardInstance(integration, projectDir);
+  
+      if (fs.existsSync(`${projectDir}/ios`)) {
+        fs.renameSync(`${projectDir}/ios`, `${projectDir}/_ios`);
+      }
+      if (fs.existsSync(`${projectDir}/macos`)) {
+        fs.renameSync(`${projectDir}/macos`, `${projectDir}/_macos`);
+      }
+
+      const continueOnUncommitedFilesPromted = await wizardInstance.waitForOutput(
+        'Do you want to continue anyway?'
+      )
+
+      const tracingOptionPrompted = continueOnUncommitedFilesPromted &&
+        (await wizardInstance.sendStdinAndWaitForOutput(
+        [KEYS.ENTER],
+        // "Do you want to enable Tracing", sometimes doesn't work as `Tracing` can be printed in bold.
+        'to track the performance of your application?',
+        ));
+  
+      tracingOptionPrompted &&
+        (await wizardInstance.sendStdinAndWaitForOutput(
+          [KEYS.ENTER],
+          'Successfully installed the Sentry Flutter SDK!',
+        ));
+  
+      wizardInstance.kill();
+    });
+  
+    afterAll(() => {
+      revertLocalChanges(projectDir);
+      cleanupGit(projectDir);
+    });
+
+    test('lib/main.dart does not add profiling with missing ios and macos folder', () => {
+      const fileContent = fs.readFileSync(`${projectDir}/lib/main.dart`, 'utf-8');
+      expect(fileContent).not.toContain(`options.profilesSampleRate = 1.0;`);
+    });
+  });
+});

package/e2e-tests/tests/nextjs.test.ts

@@ -152,7 +152,7 @@ export const onRequestError = Sentry.captureRequestError;`,
   });
 
   test('builds correctly', async () => {
-    await checkIfBuilds(projectDir, 'server-rendered on demand');
+    await checkIfBuilds(projectDir);
   });
 
   test('runs on prod mode correctly', async () => {

package/e2e-tests/tests/nuxt-3.test.ts

@@ -180,7 +180,7 @@ function testNuxtProjectConfigs(projectDir: string) {
 
 function testNuxtProjectBuildsAndRuns(projectDir: string) {
   test('builds successfully', async () => {
-    await checkIfBuilds(projectDir, 'preview this build');
+    await checkIfBuilds(projectDir);
   });
 
   test('runs on prod mode correctly', async () => {

package/e2e-tests/tests/nuxt-4.test.ts

@@ -179,7 +179,7 @@ function testNuxtProjectConfigs(projectDir: string) {
 
 function testNuxtProjectBuildsAndRuns(projectDir: string) {
   test('builds successfully', async () => {
-    await checkIfBuilds(projectDir, 'preview this build');
+    await checkIfBuilds(projectDir);
   });
 
   test('runs on prod mode correctly', async () => {

package/e2e-tests/tests/remix.test.ts

@@ -61,24 +61,27 @@ app.all(
 app.listen(0, () => console.log('Express server listening'));
 `;
 
-
-async function runWizardOnRemixProject(projectDir: string, integration: Integration, fileModificationFn?: (projectDir: string, integration: Integration) => unknown) {
+async function runWizardOnRemixProject(
+  projectDir: string,
+  integration: Integration,
+  fileModificationFn?: (
+    projectDir: string,
+    integration: Integration,
+  ) => unknown,
+) {
   const wizardInstance = startWizardInstance(integration, projectDir);
   let packageManagerPrompted = false;
 
   if (fileModificationFn) {
     fileModificationFn(projectDir, integration);
 
-    await wizardInstance.waitForOutput(
-      'Do you want to continue anyway?',
-    );
+    await wizardInstance.waitForOutput('Do you want to continue anyway?');
 
     packageManagerPrompted = await wizardInstance.sendStdinAndWaitForOutput(
       [KEYS.ENTER],
       'Please select your package manager.',
     );
   } else {
-
     packageManagerPrompted = await wizardInstance.waitForOutput(
       'Please select your package manager.',
     );
@@ -119,12 +122,16 @@ async function runWizardOnRemixProject(projectDir: string, integration: Integrat
   );
 
   wizardInstance.kill();
-};
+}
 
-function checkRemixProject(projectDir: string, integration: Integration, options?: {
-  devModeExpectedOutput?: string;
-  prodModeExpectedOutput?: string;
-}) {
+function checkRemixProject(
+  projectDir: string,
+  integration: Integration,
+  options?: {
+    devModeExpectedOutput?: string;
+    prodModeExpectedOutput?: string;
+  },
+) {
   test('package.json is updated correctly', () => {
     checkPackageJson(projectDir, integration);
   });
@@ -195,15 +202,21 @@ function checkRemixProject(projectDir: string, integration: Integration, options
   });
 
   test('builds successfully', async () => {
-    await checkIfBuilds(projectDir, 'built');
+    await checkIfBuilds(projectDir);
   });
 
   test('runs on dev mode correctly', async () => {
-    await checkIfRunsOnDevMode(projectDir, options?.devModeExpectedOutput || 'to expose');
+    await checkIfRunsOnDevMode(
+      projectDir,
+      options?.devModeExpectedOutput || 'to expose',
+    );
   });
 
   test('runs on prod mode correctly', async () => {
-    await checkIfRunsOnProdMode(projectDir, options?.prodModeExpectedOutput || '[remix-serve]');
+    await checkIfRunsOnProdMode(
+      projectDir,
+      options?.prodModeExpectedOutput || '[remix-serve]',
+    );
   });
 }
 
@@ -236,13 +249,11 @@ describe('Remix', () => {
 
     beforeAll(async () => {
       await runWizardOnRemixProject(projectDir, integration, (projectDir) => {
-        createFile(
-          `${projectDir}/server.mjs`,
-          SERVER_TEMPLATE,
-        );
+        createFile(`${projectDir}/server.mjs`, SERVER_TEMPLATE);
 
         modifyFile(`${projectDir}/package.json`, {
-          '"start": "remix-serve ./build/server/index.js"': '"start": "node ./server.mjs"',
+          '"start": "remix-serve ./build/server/index.js"':
+            '"start": "node ./server.mjs"',
           '"dev": "remix vite:dev"': '"dev": "node ./server.mjs"',
         });
       });