pumuki 6.3.307 → 6.3.309

package/core/facts/detectors/text/ios.test.ts

@@ -12,6 +12,7 @@ import {
   collectSwiftMakeSUTWithoutMemoryTrackingLines,
   collectSwiftMixedTestingFrameworkLines,
   collectSwiftQuickNimbleLines,
+  collectSwiftThirdPartyUiTestFrameworkLines,
   collectSwiftWaitForExpectationsLines,
   collectSwiftXCTestAssertionLines,
   collectSwiftXCTUnwrapLines,
@@ -20,6 +21,7 @@ import {
   collectSwiftCallbackStyleSignatureLines,
   collectSwiftDispatchGroupLines,
   collectSwiftDispatchSemaphoreLines,
+  collectSwiftDummyAwaitLines,
   hasSwiftAnyViewUsage,
   hasSwiftAnyTypeErasureUsage,
   hasSwiftAsyncWithoutAwaitUsage,
@@ -29,7 +31,9 @@ import {
   hasSwiftDispatchGroupUsage,
   collectSwiftDispatchQueueLines,
   hasSwiftDispatchQueueUsage,
+  hasSwiftDummyAwaitUsage,
   hasSwiftDispatchSemaphoreUsage,
+  collectSwiftLongAsyncOperationWithoutCancellationCheckLines,
   hasSwiftAdHocLoggingUsage,
   hasSwiftAlamofireUsage,
   collectSwiftComposableArchitectureUsageLines,
@@ -40,8 +44,30 @@ import {
   hasSwiftPackageBranchDependencyUsage,
   collectSwiftPackageToolsVersionBelow62Lines,
   hasSwiftPackageToolsVersionBelow62Usage,
+  collectSwiftPackageDefaultIsolationNotMainActorLines,
+  hasSwiftPackageDefaultIsolationNotMainActorUsage,
+  collectSwiftPackageStrictConcurrencyBelowCompleteLines,
+  hasSwiftPackageStrictConcurrencyBelowCompleteUsage,
+  collectSwiftCrossFeatureImportLines,
+  hasSwiftCrossFeatureImportUsage,
+  collectSwiftExcessivePublicApiLines,
+  hasSwiftExcessivePublicApiUsage,
+  collectSwiftLayerDirectionViolationLines,
+  hasSwiftLayerDirectionViolationUsage,
   collectSwiftStrictConcurrencyBelowCompleteLines,
   hasSwiftStrictConcurrencyBelowCompleteUsage,
+  collectSwiftDefaultActorIsolationNotMainActorLines,
+  hasSwiftDefaultActorIsolationNotMainActorUsage,
+  collectSwiftUpcomingFeatureDisabledLines,
+  hasSwiftUpcomingFeatureDisabledUsage,
+  collectSwiftUiStateWithoutMainActorLines,
+  hasSwiftUiStateWithoutMainActorUsage,
+  collectSwiftSharedMutableStateWithoutActorLines,
+  hasSwiftSharedMutableStateWithoutActorUsage,
+  collectSwiftMainActorRunPatchLines,
+  hasSwiftMainActorRunPatchUsage,
+  collectSwiftNavigationPathWithoutRestorationLines,
+  hasSwiftNavigationPathWithoutRestorationUsage,
   hasSwiftForEachIndicesUsage,
   hasSwiftForEachSelfIdentityUsage,
   collectSwiftForceCastLines,
@@ -70,6 +96,8 @@ import {
   collectSwiftAnimationWithoutReduceMotionLines,
   collectSwiftUiInlineActionLogicLines,
   collectSwiftOnTapGestureWithoutButtonTraitLines,
+  collectSwiftGlassInteractiveOnStaticElementLines,
+  collectSwiftGlassEffectIDWithoutNamespaceLines,
   collectSwiftForEachIndicesLines,
   collectSwiftForEachSelfIdentityLines,
   collectSwiftInlineForEachTransformLines,
@@ -86,6 +114,7 @@ import {
   collectSwiftEnvironmentObjectLines,
   hasSwiftEnvironmentObjectUsage,
   hasSwiftLowContrastStaticColorPairUsage,
+  hasSwiftLongAsyncOperationWithoutCancellationCheckUsage,
   hasSwiftMainThreadBlockingSleepUsage,
   hasSwiftDirectSUTInstantiationWithoutMakeSUTUsage,
   hasSwiftMakeSUTWithoutMemoryTrackingUsage,
@@ -125,6 +154,8 @@ import {
   collectSwiftOnAppearTaskLines,
   hasSwiftOnTapGestureUsage,
   hasSwiftOnTapGestureWithoutButtonTraitUsage,
+  hasSwiftGlassInteractiveOnStaticElementUsage,
+  hasSwiftGlassEffectIDWithoutNamespaceUsage,
   hasSwiftOperationQueueUsage,
   hasSwiftContainsUserFilterUsage,
   hasSwiftCustomSingletonUsage,
@@ -132,8 +163,11 @@ import {
   hasSwiftPhysicalTextAlignmentUsage,
   hasSwiftPreconcurrencyUsage,
   hasSwiftProductionCommentUsage,
+  collectSwiftThreadCentricDebuggingLines,
+  hasSwiftThreadCentricDebuggingUsage,
   hasSwiftProductionTestDoubleUsage,
   hasSwiftQuickNimbleUsage,
+  hasSwiftThirdPartyUiTestFrameworkUsage,
   hasSwiftTestDoubleWithoutProtocolConformanceUsage,
   hasSwiftSheetIsPresentedUsage,
   hasSwiftScrollViewShowsIndicatorsUsage,
@@ -164,6 +198,8 @@ import {
   hasSwiftManualMemoryManagementUsage,
   collectSwiftNonPascalCaseTypeDeclarationLines,
   hasSwiftNonPascalCaseTypeDeclarationUsage,
+  collectSwiftEndpointEnumLines,
+  hasSwiftEndpointEnumUsage,
   collectSwiftCellCreationWithoutReuseLines,
   hasSwiftCellCreationWithoutReuseUsage,
   hasSwiftWaitForExpectationsUsage,
@@ -256,6 +292,46 @@ let ignored = "[unowned self]"
   assert.equal(hasSwiftUnownedSelfCaptureUsage(safe), false);
 });
 
+test('hasSwiftLongAsyncOperationWithoutCancellationCheckUsage detecta bucles async sin cancelacion cooperativa', () => {
+  const source = `
+final class SyncService {
+  func syncAll(items: [Item]) async throws {
+    for item in items {
+      try await upload(item)
+    }
+  }
+
+  func poll() async {
+    while true {
+      await refresh()
+    }
+  }
+}
+`;
+  const safe = `
+final class SyncService {
+  func syncAll(items: [Item]) async throws {
+    for item in items {
+      if Task.isCancelled { return }
+      try await upload(item)
+    }
+  }
+
+  func poll() async throws {
+    while isRunning {
+      try Task.checkCancellation()
+      await refresh()
+    }
+  }
+}
+`;
+
+  assert.equal(hasSwiftLongAsyncOperationWithoutCancellationCheckUsage(source), true);
+  assert.deepEqual(collectSwiftLongAsyncOperationWithoutCancellationCheckLines(source), [4, 10]);
+  assert.equal(hasSwiftLongAsyncOperationWithoutCancellationCheckUsage(safe), false);
+  assert.deepEqual(collectSwiftLongAsyncOperationWithoutCancellationCheckLines(safe), []);
+});
+
 test('hasSwiftManualMemoryManagementUsage detecta bypass manual de ARC', () => {
   const source = `
 final class LegacyBridge {
@@ -307,6 +383,36 @@ let sample = "struct user_profile {}"
   assert.deepEqual(collectSwiftNonPascalCaseTypeDeclarationLines(safe), []);
 });
 
+test('hasSwiftEndpointEnumUsage detecta endpoints iOS como enum central no OCP', () => {
+  const source = `
+enum APIEndpoint {
+  case login
+}
+
+enum OrdersEndpoint: String {
+  case list = "/orders"
+}
+`;
+  const safe = `
+struct APIEndpoint: Sendable {
+  let path: String
+  let method: HTTPMethod
+
+  static func login() -> APIEndpoint {
+    APIEndpoint(path: "/login", method: .post)
+  }
+}
+
+let sample = "enum APIEndpoint { case login }"
+// enum OrdersEndpoint { case list }
+`;
+
+  assert.equal(hasSwiftEndpointEnumUsage(source), true);
+  assert.deepEqual(collectSwiftEndpointEnumLines(source), [2, 6]);
+  assert.equal(hasSwiftEndpointEnumUsage(safe), false);
+  assert.deepEqual(collectSwiftEndpointEnumLines(safe), []);
+});
+
 test('hasSwiftCellCreationWithoutReuseUsage detecta celdas UIKit sin reutilizacion', () => {
   const source = `
 final class OrdersDataSource: NSObject, UITableViewDataSource {
@@ -596,6 +702,350 @@ buildSettings = {
   assert.deepEqual(collectSwiftStrictConcurrencyBelowCompleteLines(safe), []);
 });
 
+test('detectores SwiftPM de concurrencia detectan aislamiento y strict concurrency inseguros', () => {
+  const source = `
+let package = Package(
+  name: "App",
+  swiftSettings: [
+    .defaultIsolation(nonisolated),
+    .enableExperimentalFeature("StrictConcurrency=targeted"),
+    .enableUpcomingFeature("StrictConcurrency=minimal")
+  ]
+)
+`;
+  const safe = `
+let package = Package(
+  name: "App",
+  swiftSettings: [
+    .defaultIsolation(MainActor.self),
+    .enableUpcomingFeature("NonisolatedNonsendingByDefault")
+  ]
+)
+let sample = ".defaultIsolation(nonisolated)"
+// .enableExperimentalFeature("StrictConcurrency=targeted")
+`;
+
+  assert.equal(hasSwiftPackageDefaultIsolationNotMainActorUsage(source), true);
+  assert.deepEqual(collectSwiftPackageDefaultIsolationNotMainActorLines(source), [5]);
+  assert.equal(hasSwiftPackageStrictConcurrencyBelowCompleteUsage(source), true);
+  assert.deepEqual(collectSwiftPackageStrictConcurrencyBelowCompleteLines(source), [6, 7]);
+  assert.equal(hasSwiftPackageDefaultIsolationNotMainActorUsage(safe), false);
+  assert.deepEqual(collectSwiftPackageDefaultIsolationNotMainActorLines(safe), []);
+  assert.equal(hasSwiftPackageStrictConcurrencyBelowCompleteUsage(safe), false);
+  assert.deepEqual(collectSwiftPackageStrictConcurrencyBelowCompleteLines(safe), []);
+});
+
+test('hasSwiftCrossFeatureImportUsage detecta imports entre bounded contexts iOS', () => {
+  const source = `
+import SwiftUI
+import SharedKernel
+import Orders
+import BuyerCommerce
+`;
+  const path = 'apps/ios/Presentation/Features/BuyerCommerce/LoginView.swift';
+  const safe = `
+import SwiftUI
+import SharedKernel
+import BuyerCommerce
+// import Orders
+let sample = "import Orders"
+`;
+
+  assert.equal(hasSwiftCrossFeatureImportUsage(source, path), true);
+  assert.deepEqual(collectSwiftCrossFeatureImportLines(source, path), [4]);
+  assert.equal(hasSwiftCrossFeatureImportUsage(safe, path), false);
+  assert.deepEqual(collectSwiftCrossFeatureImportLines(safe, path), []);
+  assert.equal(hasSwiftCrossFeatureImportUsage(source, 'apps/ios/Presentation/LoginView.swift'), false);
+});
+
+test('hasSwiftLayerDirectionViolationUsage detecta imports prohibidos por capa Clean Architecture', () => {
+  const domainSource = `
+import Foundation
+import SwiftUI
+import CoreData
+import CheckoutApplication
+import Combine
+`;
+  const applicationSource = `
+import Foundation
+import UIKit
+import Alamofire
+import AuthInfrastructure
+`;
+  const presentationSource = `
+import SwiftUI
+import CoreData
+import DesignSystem
+import AuthInfrastructure
+`;
+  const safeDomain = `
+import Foundation
+import SharedKernel
+`;
+
+  assert.equal(
+    hasSwiftLayerDirectionViolationUsage(
+      domainSource,
+      'apps/ios/Features/Orders/Domain/Entities/Order.swift'
+    ),
+    true
+  );
+  assert.deepEqual(
+    collectSwiftLayerDirectionViolationLines(
+      domainSource,
+      'apps/ios/Features/Orders/Domain/Entities/Order.swift'
+    ),
+    [3, 4, 5, 6]
+  );
+  assert.deepEqual(
+    collectSwiftLayerDirectionViolationLines(
+      applicationSource,
+      'apps/ios/Features/Orders/Application/UseCases/LoadOrders.swift'
+    ),
+    [3, 4, 5]
+  );
+  assert.deepEqual(
+    collectSwiftLayerDirectionViolationLines(
+      presentationSource,
+      'apps/ios/Features/Orders/Presentation/OrdersView.swift'
+    ),
+    [3, 5]
+  );
+  assert.equal(
+    hasSwiftLayerDirectionViolationUsage(
+      safeDomain,
+      'apps/ios/Features/Orders/Domain/Entities/Order.swift'
+    ),
+    false
+  );
+});
+
+test('hasSwiftExcessivePublicApiUsage detecta public/open excesivo en app iOS', () => {
+  const appSource = `
+import SwiftUI
+
+public final class BuyerShellViewModel {
+  public var selectedTab: Tab = .home
+  public init() {}
+  public func openCheckout() {}
+}
+`;
+  const minimalPublicSource = `
+public struct CheckoutRoute {}
+internal struct CheckoutState {}
+private struct CheckoutReducer {}
+`;
+  const packageSource = `
+public struct PublicSDKSurface {}
+public func makeClient() {}
+public let version = "1"
+`;
+
+  assert.equal(
+    hasSwiftExcessivePublicApiUsage(
+      appSource,
+      'apps/ios/Presentation/Features/BuyerCommerce/BuyerShellViewModel.swift'
+    ),
+    true
+  );
+  assert.deepEqual(
+    collectSwiftExcessivePublicApiLines(
+      appSource,
+      'apps/ios/Presentation/Features/BuyerCommerce/BuyerShellViewModel.swift'
+    ),
+    [4, 5, 6, 7]
+  );
+  assert.equal(
+    hasSwiftExcessivePublicApiUsage(
+      minimalPublicSource,
+      'apps/ios/Presentation/Features/BuyerCommerce/CheckoutRoute.swift'
+    ),
+    false
+  );
+  assert.deepEqual(
+    collectSwiftExcessivePublicApiLines(
+      packageSource,
+      'apps/ios/Sources/PublicSDK/PublicSDK.swift'
+    ),
+    []
+  );
+});
+
+test('hasSwiftDefaultActorIsolationNotMainActorUsage detecta aislamiento por defecto distinto de MainActor', () => {
+  const source = `
+buildSettings = {
+  SWIFT_DEFAULT_ACTOR_ISOLATION = nonisolated;
+  OTHER_SWIFT_FLAGS = "$(inherited)";
+  SWIFT_DEFAULT_ACTOR_ISOLATION = SomeCustomActor;
+};
+`;
+  const safe = `
+buildSettings = {
+  SWIFT_DEFAULT_ACTOR_ISOLATION = MainActor;
+  SWIFT_DEFAULT_ACTOR_ISOLATION = MainActor.self;
+  let sample = "SWIFT_DEFAULT_ACTOR_ISOLATION = nonisolated;"
+  // SWIFT_DEFAULT_ACTOR_ISOLATION = SomeCustomActor;
+};
+`;
+
+  assert.equal(hasSwiftDefaultActorIsolationNotMainActorUsage(source), true);
+  assert.deepEqual(collectSwiftDefaultActorIsolationNotMainActorLines(source), [3, 5]);
+  assert.equal(hasSwiftDefaultActorIsolationNotMainActorUsage(safe), false);
+  assert.deepEqual(collectSwiftDefaultActorIsolationNotMainActorLines(safe), []);
+});
+
+test('hasSwiftUpcomingFeatureDisabledUsage detecta upcoming features Swift desactivadas', () => {
+  const source = `
+buildSettings = {
+  SWIFT_UPCOMING_FEATURE_CONCISE_MAGIC_FILE = NO;
+  SWIFT_UPCOMING_FEATURE_FORWARD_TRAILING_CLOSURES = 0;
+  SWIFT_ENABLE_EXPERIMENTAL_FEATURES = ;
+};
+`;
+  const safe = `
+buildSettings = {
+  SWIFT_UPCOMING_FEATURE_CONCISE_MAGIC_FILE = YES;
+  SWIFT_UPCOMING_FEATURE_FORWARD_TRAILING_CLOSURES = true;
+  SWIFT_ENABLE_EXPERIMENTAL_FEATURES = StrictConcurrency;
+  let sample = "SWIFT_UPCOMING_FEATURE_CONCISE_MAGIC_FILE = NO;"
+  // SWIFT_ENABLE_EXPERIMENTAL_FEATURES = ;
+};
+`;
+
+  assert.equal(hasSwiftUpcomingFeatureDisabledUsage(source), true);
+  assert.deepEqual(collectSwiftUpcomingFeatureDisabledLines(source), [3, 4, 5]);
+  assert.equal(hasSwiftUpcomingFeatureDisabledUsage(safe), false);
+  assert.deepEqual(collectSwiftUpcomingFeatureDisabledLines(safe), []);
+});
+
+test('hasSwiftUiStateWithoutMainActorUsage detecta estado UI observable sin MainActor', () => {
+  const source = `
+final class BuyerAuthViewModel: ObservableObject {
+  @Published var title = "Login"
+}
+struct BuyerSessionStore {
+  var token: String?
+}
+`;
+  const safe = `
+@MainActor
+@Observable
+final class BuyerAuthViewModel {
+  var title = "Login"
+}
+final class BackgroundStore {
+  let cache = NSCache<NSString, NSString>()
+}
+let sample = "final class FakeViewModel: ObservableObject"
+// final class CommentedViewModel: ObservableObject {}
+`;
+
+  assert.equal(hasSwiftUiStateWithoutMainActorUsage(source), true);
+  assert.deepEqual(collectSwiftUiStateWithoutMainActorLines(source), [2]);
+  assert.equal(hasSwiftUiStateWithoutMainActorUsage(safe), false);
+  assert.deepEqual(collectSwiftUiStateWithoutMainActorLines(safe), []);
+});
+
+test('hasSwiftSharedMutableStateWithoutActorUsage detecta estado compartido mutable sin actor', () => {
+  const source = `
+final class UserSessionManager {
+  private var token: String?
+
+  func update(token: String) {
+    self.token = token
+  }
+}
+`;
+  const safe = `
+actor UserSessionManager {
+  private var token: String?
+
+  func update(token: String) {
+    self.token = token
+  }
+}
+@MainActor
+final class BuyerSessionStore {
+  private var route: String?
+  func update(route: String) { self.route = route }
+}
+final class ValueFormatter {
+  func title() -> String { "OK" }
+}
+let sample = "final class TokenCache { var token: String? }"
+// final class CommentedCache { var value = "" }
+`;
+
+  assert.equal(hasSwiftSharedMutableStateWithoutActorUsage(source), true);
+  assert.deepEqual(collectSwiftSharedMutableStateWithoutActorLines(source), [2]);
+  assert.equal(hasSwiftSharedMutableStateWithoutActorUsage(safe), false);
+  assert.deepEqual(collectSwiftSharedMutableStateWithoutActorLines(safe), []);
+});
+
+test('hasSwiftMainActorRunPatchUsage detecta MainActor.run como parche en owners no aislados', () => {
+  const source = `
+final class BuyerAuthViewModel {
+  func load() async {
+    await MainActor.run {
+      self.title = "Ready"
+    }
+  }
+}
+`;
+  const safe = `
+@MainActor
+final class BuyerAuthViewModel {
+  func load() async {
+    await MainActor.run { self.title = "Ready" }
+  }
+}
+actor BuyerSessionManager {
+  func load() async {
+    await MainActor.run { print("bridge") }
+  }
+}
+func bridgeToUi() async {
+  await MainActor.run { print("approved explicit boundary") }
+}
+let sample = "MainActor.run { value = 1 }"
+// await MainActor.run { value = 2 }
+`;
+
+  assert.equal(hasSwiftMainActorRunPatchUsage(source), true);
+  assert.deepEqual(collectSwiftMainActorRunPatchLines(source), [4]);
+  assert.equal(hasSwiftMainActorRunPatchUsage(safe), false);
+  assert.deepEqual(collectSwiftMainActorRunPatchLines(safe), []);
+});
+
+test('hasSwiftNavigationPathWithoutRestorationUsage detecta NavigationPath sin restauracion', () => {
+  const source = `
+struct ShellView: View {
+  @State private var path = NavigationPath()
+
+  var body: some View {
+    NavigationStack(path: $path) { EmptyView() }
+  }
+}
+`;
+  const safe = `
+struct ShellView: View {
+  @SceneStorage("navigation.path") private var encodedPath = Data()
+  @State private var path = NavigationPath()
+
+  func restoreNavigationPath() {
+    _ = path.codable
+  }
+}
+let sample = "NavigationPath()"
+// let ignored = NavigationPath()
+`;
+
+  assert.equal(hasSwiftNavigationPathWithoutRestorationUsage(source), true);
+  assert.deepEqual(collectSwiftNavigationPathWithoutRestorationLines(source), [3]);
+  assert.equal(hasSwiftNavigationPathWithoutRestorationUsage(safe), false);
+  assert.deepEqual(collectSwiftNavigationPathWithoutRestorationLines(safe), []);
+});
+
 test('hasSwiftNonLazyScrollForEachUsage detecta ScrollView con stack no lazy y preserva LazyVStack', () => {
   const source = `
 struct FeedView: View {
@@ -1733,6 +2183,30 @@ func wait() async throws {
   assert.equal(hasSwiftMainThreadBlockingSleepUsage(ignored), false);
 });
 
+test('detector iOS de concurrencia detecta depuracion centrada en hilos', () => {
+  const source = `
+func traceCurrentExecution() {
+  print(Thread.current)
+  if Thread.isMainThread { recordMainThread() }
+  let pthread = pthread_self()
+  let mach = pthread_mach_thread_np(pthread)
+}
+`;
+  const ignored = `
+@MainActor
+func updateUI() {
+  let description = "Thread.current"
+  // Thread.isMainThread
+  Task { await reload() }
+}
+`;
+
+  assert.equal(hasSwiftThreadCentricDebuggingUsage(source), true);
+  assert.deepEqual(collectSwiftThreadCentricDebuggingLines(source), [3, 4, 5, 6]);
+  assert.equal(hasSwiftThreadCentricDebuggingUsage(ignored), false);
+  assert.deepEqual(collectSwiftThreadCentricDebuggingLines(ignored), []);
+});
+
 test('detector iOS de concurrencia detecta async privado sin await y evita boundaries publicos', () => {
   const source = `
 final class ProfileLoader {
@@ -1761,6 +2235,33 @@ final class ProfileLoader: RemoteLoader {
   assert.equal(hasSwiftAsyncWithoutAwaitUsage(ignored), false);
 });
 
+test('detector iOS de concurrencia detecta dummy awaits usados como workaround', () => {
+  const source = `
+final class Loader {
+  func load() async {
+    await Task.yield()
+    try? await Task.sleep(nanoseconds: 0)
+    try? await Task.sleep(for: .zero)
+    try? await Task.sleep(for: .seconds(0))
+  }
+}
+`;
+  const ignored = `
+final class Loader {
+  func load() async throws {
+    try await Task.sleep(for: .seconds(1))
+    let message = "await Task.yield()"
+    // await Task.yield()
+  }
+}
+`;
+
+  assert.equal(hasSwiftDummyAwaitUsage(source), true);
+  assert.deepEqual(collectSwiftDummyAwaitLines(source), [4, 5, 6, 7]);
+  assert.equal(hasSwiftDummyAwaitUsage(ignored), false);
+  assert.deepEqual(collectSwiftDummyAwaitLines(ignored), []);
+});
+
 test('detector iOS de accesibilidad detecta botones icon-only sin label explicita', () => {
   const source = `
 struct ToolbarView: View {
@@ -2005,6 +2506,81 @@ struct RowView: View {
   assert.deepEqual(collectSwiftOnTapGestureWithoutButtonTraitLines(safe), []);
 });
 
+test('hasSwiftGlassInteractiveOnStaticElementUsage detecta Liquid Glass interactivo en contenido estatico', () => {
+  const source = `
+struct CardView: View {
+  var body: some View {
+    Text("Estado")
+      .padding()
+      .glassEffect(.regular.interactive(), in: .rect(cornerRadius: 16))
+  }
+}
+`;
+  const safe = `
+struct CardView: View {
+  var body: some View {
+    Button("Continuar") { submit() }
+      .glassEffect(.regular.interactive(), in: .capsule)
+
+    Text("Mas informacion")
+      .onTapGesture { showDetails() }
+      .glassEffect(.regular.interactive(), in: .rect(cornerRadius: 16))
+
+    Text("decorativo")
+      .glassEffect(.regular, in: .rect(cornerRadius: 16))
+
+    let sample = ".glassEffect(.regular.interactive())"
+    // .glassEffect(.regular.interactive())
+  }
+}
+`;
+
+  assert.equal(hasSwiftGlassInteractiveOnStaticElementUsage(source), true);
+  assert.deepEqual(collectSwiftGlassInteractiveOnStaticElementLines(source), [6]);
+  assert.equal(hasSwiftGlassInteractiveOnStaticElementUsage(safe), false);
+  assert.deepEqual(collectSwiftGlassInteractiveOnStaticElementLines(safe), []);
+});
+
+test('hasSwiftGlassEffectIDWithoutNamespaceUsage detecta glassEffectID sin Namespace real', () => {
+  const source = `
+struct CardView: View {
+  var body: some View {
+    Text("Card")
+      .glassEffect()
+      .glassEffectID("card", in: animation)
+  }
+}
+`;
+  const safe = `
+struct CardView: View {
+  @Namespace private var animation
+
+  var body: some View {
+    Text("Card")
+      .glassEffect()
+      .glassEffectID("card", in: animation)
+  }
+}
+
+struct ChildCard: View {
+  let animation: Namespace.ID
+
+  var body: some View {
+    Text("Card")
+      .glassEffectID("card", in: animation)
+  }
+}
+
+let sample = ".glassEffectID(\\"card\\", in: animation)"
+// .glassEffectID("card", in: animation)
+`;
+
+  assert.equal(hasSwiftGlassEffectIDWithoutNamespaceUsage(source), true);
+  assert.deepEqual(collectSwiftGlassEffectIDWithoutNamespaceLines(source), [6]);
+  assert.equal(hasSwiftGlassEffectIDWithoutNamespaceUsage(safe), false);
+  assert.deepEqual(collectSwiftGlassEffectIDWithoutNamespaceLines(safe), []);
+});
+
 test('detectores legacy ignoran strings y comentarios', () => {
   const source = `
 // Task.detached { }
@@ -2779,6 +3355,51 @@ struct LoginTests {
   assert.deepEqual(collectSwiftQuickNimbleLines(swiftTesting), []);
 });
 
+test('hasSwiftThirdPartyUiTestFrameworkUsage detecta frameworks UI test no nativos', () => {
+  const kifSuite = `
+import XCTest
+import KIF
+
+final class CheckoutUITests: XCTestCase {
+  func testCheckout() {
+    tester().tapView(withAccessibilityLabel: "Pay")
+  }
+}
+`;
+  const earlGreySuite = `
+import XCTest
+import EarlGrey
+
+final class LoginUITests: XCTestCase {
+  func testLogin() {
+    EarlGrey.selectElement(with: grey_accessibilityID("login")).perform(grey_tap())
+  }
+}
+`;
+  const nativeXcuiTest = `
+import XCTest
+
+final class LoginUITests: XCTestCase {
+  func testLogin() {
+    let app = XCUIApplication()
+    app.buttons["login"].tap()
+  }
+}
+`;
+  const ignored = `
+let text = "import KIF"
+// EarlGrey.selectElement(with: grey_accessibilityID("login"))
+`;
+
+  assert.equal(hasSwiftThirdPartyUiTestFrameworkUsage(kifSuite), true);
+  assert.deepEqual(collectSwiftThirdPartyUiTestFrameworkLines(kifSuite), [3, 7]);
+  assert.equal(hasSwiftThirdPartyUiTestFrameworkUsage(earlGreySuite), true);
+  assert.deepEqual(collectSwiftThirdPartyUiTestFrameworkLines(earlGreySuite), [3, 7]);
+  assert.equal(hasSwiftThirdPartyUiTestFrameworkUsage(nativeXcuiTest), false);
+  assert.deepEqual(collectSwiftThirdPartyUiTestFrameworkLines(nativeXcuiTest), []);
+  assert.equal(hasSwiftThirdPartyUiTestFrameworkUsage(ignored), false);
+});
+
 test('hasSwiftXCTestAssertionUsage detecta XCTAssert y XCTFail reales', () => {
   const source = `
 XCTAssertEqual(value, expected)