@sentry/wizard 3.39.0 → 3.41.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/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/utils/index.ts

@@ -348,6 +348,18 @@ export function checkEnvBuildPlugin(projectDir: string) {
 }
 
 /**
+ * Check if the sentry.properties contains the auth token
+ * @param projectDir
+ */
+export function checkSentryProperties(projectDir: string) {
+  checkFileContents(
+    `${projectDir}/sentry.properties`,
+    `auth_token=${TEST_ARGS.AUTH_TOKEN}`,
+  );
+}
+
+/**
+ * Check if the project builds
  * Check if the project builds and ends with status code 0.
  * @param projectDir
  */
@@ -363,6 +375,27 @@ export async function checkIfBuilds(projectDir: string) {
   ).resolves.toBe(true);
 }
 
+/**
+ * Check if the flutter project builds
+ * @param projectDir
+ */
+export async function checkIfFlutterBuilds(
+  projectDir: string,
+  expectedOutput: string,
+  debug = false,
+) {
+  const testEnv = new WizardTestEnv('flutter', ['build', 'web'], {
+    cwd: projectDir,
+    debug: debug,
+  });
+
+  await expect(
+    testEnv.waitForOutput(expectedOutput, {
+      timeout: 120_000,
+    }),
+  ).resolves.toBe(true);
+}
+
 /**
  * Check if the project runs on dev mode
  * @param projectDir

package/lib/Constants.ts

@@ -1,6 +1,7 @@
 /** Key value should be the same here */
 export enum Integration {
   reactNative = 'reactNative',
+  flutter = 'flutter',
   ios = 'ios',
   android = 'android',
   cordova = 'cordova',
@@ -41,6 +42,8 @@ export function getIntegrationDescription(type: string): string {
       return 'Android';
     case Integration.reactNative:
       return 'React Native';
+    case Integration.flutter:
+      return 'Flutter';
     case Integration.cordova:
       return 'Cordova';
     case Integration.electron:
@@ -66,6 +69,8 @@ export function mapIntegrationToPlatform(type: string): string | undefined {
       return 'android';
     case Integration.reactNative:
       return 'react-native';
+    case Integration.flutter:
+      return 'flutter';
     case Integration.cordova:
       return 'cordova';
     case Integration.electron:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/wizard",
-  "version": "3.39.0",
+  "version": "3.41.0",
   "homepage": "https://github.com/getsentry/sentry-wizard",
   "repository": "https://github.com/getsentry/sentry-wizard",
   "description": "Sentry wizard helping you to configure your project",
@@ -123,5 +123,6 @@
   "volta": {
     "node": "14.18.3",
     "yarn": "1.22.19"
-  }
+  },
+  "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
 }

package/src/apple/apple-wizard.ts

@@ -17,7 +17,6 @@ import { traceStep, withTelemetry } from '../telemetry';
 import * as cocoapod from './cocoapod';
 import * as fastlane from './fastlane';
 
-const xcode = require('xcode');
 /* eslint-enable @typescript-eslint/no-unused-vars */
 
 import {
@@ -109,7 +108,7 @@ async function runAppleWizardWithTelementry(
   const availableTargets = xcProject.getAllTargets();
 
   if (availableTargets.length == 0) {
-    clack.log.error(`No suttable target found in ${xcodeProjFile}`);
+    clack.log.error(`No suitable target found in ${xcodeProjFile}`);
     Sentry.setTag('No-Target', true);
     await abort();
     return;
@@ -161,7 +160,7 @@ async function runAppleWizardWithTelementry(
 
   Sentry.setTag('package-manager', hasCocoa ? 'cocoapods' : 'SPM');
   traceStep('Update Xcode project', () => {
-    xcProject.updateXcodeProject(project, target, apiKey, !hasCocoa, true);
+    xcProject.updateXcodeProject(project, target, !hasCocoa, true);
   });
 
   const codeAdded = traceStep('Add code snippet', () => {

package/src/apple/code-tools.ts

@@ -1,15 +1,15 @@
+import * as Sentry from '@sentry/node';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as templates from './templates';
-import * as Sentry from '@sentry/node';
 // @ts-ignore - clack is ESM and TS complains about that. It works though
-import clack from '@clack/prompts';
+import * as clack from '@clack/prompts';
 
 const swiftAppLaunchRegex =
-  /(func\s+application\s*\(_\sapplication:[^,]+,\s*didFinishLaunchingWithOptions[^,]+:[^)]+\)\s+->\s+Bool\s+{)|func\s+applicationDidFinishLaunching\(_\s+aNotification:\s+Notification\)\s+{/im;
+  /(func\s+application\s*\(\s*_\s+application:\s*[^,]+,\s*didFinishLaunchingWithOptions[^,]+:\s*[^)]+\s*\)\s+->\s+Bool\s+{)|func\s+applicationDidFinishLaunching\s*\(\s*_\s+aNotification:\s+Notification\s*\)\s*{/im;
 const objcAppLaunchRegex =
-  /-\s*\(BOOL\)\s*application:\s*\(UIApplication\s*\*\)\s*application\s+didFinishLaunchingWithOptions:\s*\(NSDictionary\s*\*\)\s*launchOptions\s*{/im;
-const swiftUIRegex = /@main\s+struct[^:]+:\s*App\s*{/im;
+  /-\s*\(\s*BOOL\s*\)\s*application:\s*\(\s*UIApplication\s*\*\s*\)\s*application\s+didFinishLaunchingWithOptions:\s*\(\s*NSDictionary\s*\*\s*\)\s*launchOptions\s*{/im;
+const swiftUIRegex = /@main\s+struct[^:]+:\s*(SwiftUI\.)?App\s*{/im;
 
 function isAppDelegateFile(filePath: string): boolean {
   const appLaunchRegex = filePath.toLowerCase().endsWith('.swift')
@@ -43,7 +43,7 @@ function findAppDidFinishLaunchingWithOptions(
         return filePath;
       }
     } else if (
-      !filePath.startsWith('.') &&
+      !path.basename(filePath).startsWith('.') &&
       !filePath.endsWith('.xcodeproj') &&
       !filePath.endsWith('.xcassets') &&
       fs.existsSync(filePath) &&
@@ -97,6 +97,7 @@ export function addCodeSnippetToProject(
   if (!match) {
     const swiftUIMatch = swiftUIRegex.exec(fileContent);
     if (!swiftUIMatch) {
+      // This branch is not reached, because we already checked for SwiftUI in isAppDelegateFile
       return false;
     }
     //Is SwiftUI with no init
@@ -130,3 +131,17 @@ export function addCodeSnippetToProject(
   clack.log.step('Added Sentry initialization code snippet to ' + appDelegate);
   return true;
 }
+
+/**
+ * Exported for testing purposes, but should not be used in other modules.
+ */
+export let exportForTesting: {
+  isAppDelegateFile: typeof isAppDelegateFile;
+  findAppDidFinishLaunchingWithOptions: typeof findAppDidFinishLaunchingWithOptions;
+};
+if (process.env.NODE_ENV === 'test') {
+  exportForTesting = {
+    isAppDelegateFile,
+    findAppDidFinishLaunchingWithOptions,
+  };
+}