pumuki 6.3.172 → 6.3.173

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

@@ -6,14 +6,12 @@ import {
   findSwiftOpenClosedSwitchMatch,
   findSwiftConcreteDependencyDipMatch,
   findSwiftPresentationSrpMatch,
-  findSwiftXCTestSrpMatch,
   hasSwiftAnyViewUsage,
   hasSwiftCallbackStyleSignature,
   hasSwiftCornerRadiusUsage,
   hasSwiftDispatchGroupUsage,
   hasSwiftDispatchQueueUsage,
   hasSwiftDispatchSemaphoreUsage,
-  hasSwiftExplicitColorStaticMemberUsage,
   hasSwiftForEachIndicesUsage,
   hasSwiftForceCastUsage,
   hasSwiftFontWeightBoldUsage,
@@ -21,7 +19,6 @@ import {
   hasSwiftForceTryUsage,
   hasSwiftForceUnwrap,
   hasSwiftGeometryReaderUsage,
-  hasSwiftInlineFilteringInForEachUsage,
   hasSwiftLegacyOnChangeUsage,
   hasSwiftLegacyExpectationDescriptionUsage,
   hasSwiftLegacySwiftUiObservableWrapperUsage,
@@ -40,7 +37,6 @@ import {
   hasSwiftOperationQueueUsage,
   hasSwiftContainsUserFilterUsage,
   hasSwiftPassedValueStateWrapperUsage,
-  hasSwiftStateWrapperWithoutPrivateUsage,
   hasSwiftPreconcurrencyUsage,
   hasSwiftSheetIsPresentedUsage,
   hasSwiftScrollViewShowsIndicatorsUsage,
@@ -245,9 +241,7 @@ MainActor.assumeIsolated { reload() }
   assert.equal(hasSwiftNonisolatedUnsafeUsage(source), true);
   assert.equal(hasSwiftAssumeIsolatedUsage(source), true);
   assert.equal(hasSwiftForEachIndicesUsage(source), true);
-  assert.equal(hasSwiftInlineFilteringInForEachUsage('ForEach(items.filter { $0.isActive }) { item in Text(item.title) }'), true);
   assert.equal(hasSwiftContainsUserFilterUsage(source), true);
-  assert.equal(hasSwiftExplicitColorStaticMemberUsage('Text("A").foregroundStyle(Color.blue)'), true);
   assert.equal(hasSwiftGeometryReaderUsage(source), true);
   assert.equal(hasSwiftFontWeightBoldUsage(source), true);
   assert.equal(hasSwiftObservableObjectUsage(source), true);
@@ -293,9 +287,7 @@ let t = "MainActor.assumeIsolated { reload() }"
   assert.equal(hasSwiftNonisolatedUnsafeUsage(source), false);
   assert.equal(hasSwiftAssumeIsolatedUsage(source), false);
   assert.equal(hasSwiftForEachIndicesUsage(source), false);
-  assert.equal(hasSwiftInlineFilteringInForEachUsage(source), false);
   assert.equal(hasSwiftContainsUserFilterUsage(source), false);
-  assert.equal(hasSwiftExplicitColorStaticMemberUsage('Text("A").foregroundStyle(.blue)'), false);
   assert.equal(hasSwiftGeometryReaderUsage(source), false);
   assert.equal(hasSwiftFontWeightBoldUsage(source), false);
   assert.equal(hasSwiftTaskDetachedUsage(source), false);
@@ -382,34 +374,11 @@ final class SyncTests: XCTestCase {
     }
   }
 }
-`;
-  const brownfieldCompatibleUnitTest = `
-import XCTest
-
-final class LoginModelTests: XCTestCase {
-  func test_submit_validCredentials_storesSession() async throws {
-    let (sut, repository) = makeSUT()
-    try await sut.submit()
-    XCTAssertEqual(repository.receivedRequests.count, 1)
-  }
-
-  private func makeSUT(
-    file: StaticString = #filePath,
-    line: UInt = #line
-  ) -> (LoginModel, AuthRepositorySpy) {
-    let repository = AuthRepositorySpy()
-    let sut = LoginModel(repository: repository)
-    trackForMemoryLeaks(sut, testCase: self, file: file, line: line)
-    trackForMemoryLeaks(repository, testCase: self, file: file, line: line)
-    return (sut, repository)
-  }
-}
 `;
 
-  assert.equal(hasSwiftLegacyXCTestImportUsage(unitTest), false);
+  assert.equal(hasSwiftLegacyXCTestImportUsage(unitTest), true);
   assert.equal(hasSwiftLegacyXCTestImportUsage(uiTest), false);
   assert.equal(hasSwiftLegacyXCTestImportUsage(performanceTest), false);
-  assert.equal(hasSwiftLegacyXCTestImportUsage(brownfieldCompatibleUnitTest), false);
 });
 
 test('hasSwiftLegacySwiftUiObservableWrapperUsage detecta @StateObject/@ObservedObject legacy', () => {
@@ -456,24 +425,6 @@ struct DetailView: View {
   assert.equal(hasSwiftPassedValueStateWrapperUsage(validOwnership), false);
 });
 
-test('hasSwiftStateWrapperWithoutPrivateUsage detecta @State y @StateObject sin private en SwiftUI Views', () => {
-  const positive = `
-struct DetailView: View {
-  @State var filter: String = ""
-  @StateObject var viewModel = DetailViewModel()
-}
-`;
-  const negative = `
-struct DetailView: View {
-  @State private var filter: String = ""
-  @StateObject private var viewModel = DetailViewModel()
-}
-`;
-
-  assert.equal(hasSwiftStateWrapperWithoutPrivateUsage(positive), true);
-  assert.equal(hasSwiftStateWrapperWithoutPrivateUsage(negative), false);
-});
-
 test('hasSwiftModernizableXCTestSuiteUsage detecta suites legacy y excluye mixed/UI', () => {
   const legacySuite = `
 import XCTest
@@ -507,33 +458,10 @@ final class LoginUITests: XCTestCase {
   }
 }
 `;
-  const brownfieldCompatibleSuite = `
-import XCTest
-
-final class LoginModelTests: XCTestCase {
-  func test_submit_validCredentials_storesSession() async throws {
-    let (sut, repository) = makeSUT()
-    try await sut.submit()
-    XCTAssertEqual(repository.receivedRequests.count, 1)
-  }
 
-  private func makeSUT(
-    file: StaticString = #filePath,
-    line: UInt = #line
-  ) -> (LoginModel, AuthRepositorySpy) {
-    let repository = AuthRepositorySpy()
-    let sut = LoginModel(repository: repository)
-    trackForMemoryLeaks(sut, testCase: self, file: file, line: line)
-    trackForMemoryLeaks(repository, testCase: self, file: file, line: line)
-    return (sut, repository)
-  }
-}
-`;
-
-  assert.equal(hasSwiftModernizableXCTestSuiteUsage(legacySuite), false);
+  assert.equal(hasSwiftModernizableXCTestSuiteUsage(legacySuite), true);
   assert.equal(hasSwiftModernizableXCTestSuiteUsage(mixedSuite), false);
   assert.equal(hasSwiftModernizableXCTestSuiteUsage(uiSuite), false);
-  assert.equal(hasSwiftModernizableXCTestSuiteUsage(brownfieldCompatibleSuite), false);
 });
 
 test('hasSwiftMixedTestingFrameworksUsage detecta mezcla XCTestCase y Testing/@Test', () => {
@@ -564,34 +492,11 @@ import Testing
 struct LoginModernTests {
   @Test func login() async {}
 }
-`;
-  const mixedWithReexportedTesting = `
-import XCTest
-
-final class LoginTests: XCTestCase {
-  func testLegacyLogin() {}
-}
-
-struct LoginModernTests {
-  @Test func login() async {}
-}
-`;
-  const ignoredCommentsAndStrings = `
-import XCTest
-
-final class LoginTests: XCTestCase {
-  func testLegacyLogin() {
-    let text = "@Test func login() async {}"
-    // @Suite
-  }
-}
 `;
 
   assert.equal(hasSwiftMixedTestingFrameworksUsage(mixedSuite), true);
-  assert.equal(hasSwiftMixedTestingFrameworksUsage(mixedWithReexportedTesting), true);
   assert.equal(hasSwiftMixedTestingFrameworksUsage(legacyOnly), false);
   assert.equal(hasSwiftMixedTestingFrameworksUsage(modernOnly), false);
-  assert.equal(hasSwiftMixedTestingFrameworksUsage(ignoredCommentsAndStrings), false);
 });
 
 test('hasSwiftXCTestAssertionUsage detecta XCTAssert y XCTFail reales', () => {
@@ -608,87 +513,6 @@ let text = "XCTAssertEqual(value, expected)"
   assert.equal(hasSwiftXCTestAssertionUsage(ignored), false);
 });
 
-test('hasSwiftXCTestAssertionUsage excluye XCTest compatible con UI automation', () => {
-  const uiSource = `
-import XCTest
-
-final class BuyerCommerceUISmokeTests: XCTestCase {
-  func test_buyer_flow() {
-    let app = XCUIApplication()
-    app.launch()
-    XCTAssertTrue(app.buttons["Comprar"].exists)
-  }
-}
-`;
-
-  assert.equal(hasSwiftXCTestAssertionUsage(uiSource), false);
-  assert.equal(hasSwiftXCTUnwrapUsage(`${uiSource}\nlet value = try XCTUnwrap(optional)`), false);
-});
-
-test('detectores Swift Testing excluyen XCTest brownfield y dejan la calidad a su guard dedicado', () => {
-  const compatibleSource = `
-import XCTest
-
-final class LoginModelTests: XCTestCase {
-  func test_submit_validCredentials_storesSession() async throws {
-    let (sut, repository) = makeSUT()
-    try await sut.submit()
-    XCTAssertEqual(repository.receivedRequests.count, 1)
-    let session = try XCTUnwrap(repository.savedSession)
-    XCTAssertEqual(session.userId, "buyer-1")
-  }
-
-  private func makeSUT(
-    file: StaticString = #filePath,
-    line: UInt = #line
-  ) -> (LoginModel, AuthRepositorySpy) {
-    let repository = AuthRepositorySpy()
-    let sut = LoginModel(repository: repository)
-    trackForMemoryLeaks(sut, testCase: self, file: file, line: line)
-    trackForMemoryLeaks(repository, testCase: self, file: file, line: line)
-    return (sut, repository)
-  }
-}
-`;
-  const missingQualityContract = `
-import XCTest
-
-final class LoginModelTests: XCTestCase {
-  func test_submit_validCredentials_storesSession() async throws {
-    XCTAssertEqual(repository.receivedRequests.count, 1)
-  }
-}
-`;
-
-  assert.equal(hasSwiftXCTestAssertionUsage(compatibleSource), false);
-  assert.equal(hasSwiftXCTUnwrapUsage(compatibleSource), false);
-  assert.equal(hasSwiftLegacyXCTestImportUsage(compatibleSource), false);
-  assert.equal(hasSwiftModernizableXCTestSuiteUsage(compatibleSource), false);
-  assert.equal(hasSwiftXCTestAssertionUsage(missingQualityContract), false);
-  assert.equal(hasSwiftLegacyXCTestImportUsage(missingQualityContract), false);
-  assert.equal(hasSwiftModernizableXCTestSuiteUsage(missingQualityContract), false);
-});
-
-test('detectores Swift Testing excluyen helpers y factories XCTest brownfield sin XCTestCase', () => {
-  const helperSource = `
-import XCTest
-
-final class AuthTestFactories {
-  static func makeToken() -> String {
-    "token"
-  }
-}
-
-func trackForMemoryLeaks(_ instance: AnyObject, file: StaticString = #filePath, line: UInt = #line) {
-  addTeardownBlock { _ = instance }
-}
-  `;
-
-  assert.equal(hasSwiftLegacyXCTestImportUsage(helperSource), false);
-  assert.equal(hasSwiftModernizableXCTestSuiteUsage(helperSource), false);
-  assert.equal(hasSwiftXCTestAssertionUsage(helperSource), false);
-});
-
 test('hasSwiftXCTUnwrapUsage detecta XCTUnwrap real y evita strings', () => {
   const source = `
 let value = try XCTUnwrap(optionalValue)
@@ -702,84 +526,51 @@ let text = "XCTUnwrap(optionalValue)"
 });
 
 test('hasSwiftWaitForExpectationsUsage detecta waits legacy y excluye await fulfillment', () => {
-  const legacyAsyncWait = `
-func testLegacyAsync() async {
+  const legacyWait = `
 let expectation = expectation(description: "Done")
 wait(for: [expectation], timeout: 1)
 waitForExpectations(timeout: 1)
-}
-`;
-  const legacySyncWait = `
-func testLegacySync() {
-let expectation = expectation(description: "Done")
-wait(for: [expectation], timeout: 1)
-}
 `;
   const modernWait = `
-func testModernAsync() async {
 let expectation = expectation(description: "Done")
 await fulfillment(of: [expectation], timeout: 1)
-}
 `;
 
-  assert.equal(hasSwiftWaitForExpectationsUsage(legacyAsyncWait), true);
-  assert.equal(hasSwiftWaitForExpectationsUsage(legacySyncWait), false);
+  assert.equal(hasSwiftWaitForExpectationsUsage(legacyWait), true);
   assert.equal(hasSwiftWaitForExpectationsUsage(modernWait), false);
 });
 
-test('hasSwiftLegacyExpectationDescriptionUsage detecta expectation(description:) en tests async sin flujo moderno', () => {
-  const legacyAsyncExpectation = `
-func testLegacyAsync() async {
-let expectation = expectation(description: "Done")
-doWork { expectation.fulfill() }
-}
-`;
-  const legacySyncExpectation = `
-func testLegacySync() {
+test('hasSwiftLegacyExpectationDescriptionUsage detecta expectation(description:) sin flujo moderno', () => {
+  const legacyExpectation = `
 let expectation = expectation(description: "Done")
 doWork { expectation.fulfill() }
-}
+waitForExpectations(timeout: 1)
 `;
-  const modernAsyncExpectation = `
-func testModernAsync() async {
+  const modernExpectation = `
 let expectation = expectation(description: "Done")
 doWork { expectation.fulfill() }
 await fulfillment(of: [expectation], timeout: 1)
-}
 `;
-  const confirmationFlow = `
-func testConfirmation() async {
+  const confirmationOnly = `
 await confirmation("Done") { confirm in
   await doWork { confirm() }
 }
-}
-`;
-  const commentedExpectation = `
-func testModernAsync() async {
-// let expectation = expectation(description: "Done")
-await confirmation("Done") { confirm in confirm() }
-}
 `;
 
-  assert.equal(hasSwiftLegacyExpectationDescriptionUsage(legacyAsyncExpectation), true);
-  assert.equal(hasSwiftLegacyExpectationDescriptionUsage(legacySyncExpectation), false);
-  assert.equal(hasSwiftLegacyExpectationDescriptionUsage(modernAsyncExpectation), false);
-  assert.equal(hasSwiftLegacyExpectationDescriptionUsage(confirmationFlow), false);
-  assert.equal(hasSwiftLegacyExpectationDescriptionUsage(commentedExpectation), false);
+  assert.equal(hasSwiftLegacyExpectationDescriptionUsage(legacyExpectation), true);
+  assert.equal(hasSwiftLegacyExpectationDescriptionUsage(modernExpectation), false);
+  assert.equal(hasSwiftLegacyExpectationDescriptionUsage(confirmationOnly), false);
 });
 
 test('hasSwiftNSManagedObjectBoundaryUsage detecta boundaries con NSManagedObject y excluye IDs o subclases', () => {
   const source = `
 func persist(_ entity: NSManagedObject) {}
 var selectedEntity: NSManagedObject?
-let cachedEntities: Result<[NSManagedObject], Error>
 `;
   const ignored = `
 final class TodoEntity: NSManagedObject {}
 var selectedID: NSManagedObjectID?
 let context: NSManagedObjectContext
-let text = "var selectedEntity: NSManagedObject?"
-// func persist(_ entity: NSManagedObject) {}
 `;
 
   assert.equal(hasSwiftNSManagedObjectBoundaryUsage(source), true);
@@ -791,17 +582,11 @@ test('hasSwiftNSManagedObjectAsyncBoundaryUsage detecta async APIs con NSManaged
 func fetchEntity() async throws -> NSManagedObject {
   fatalError()
 }
-func fetchEntities() async throws -> Result<[NSManagedObject], Error> {
-  fatalError()
-}
 `;
   const ignored = `
 func fetchEntityID() async throws -> NSManagedObjectID {
   fatalError()
 }
-func fetchContext() async throws -> NSManagedObjectContext {
-  fatalError()
-}
 `;
 
   assert.equal(hasSwiftNSManagedObjectAsyncBoundaryUsage(source), true);
@@ -981,69 +766,6 @@ final class PumukiOcpIosCanaryUseCase {
   assert.match(match.expected_fix, /estrategia|protocolo|registry/i);
 });
 
-test('findSwiftOpenClosedSwitchMatch detecta switch sobre outcome en Coordinator iOS', () => {
-  const source = `public final class LaunchFlowCoordinator {
-  public func bootstrap() async {
-    let outcome = await appConfigurationUseCase.execute()
-    switch outcome {
-    case .mandatoryUpdate:
-      route = .updateRequired
-    case .maintenance:
-      route = .maintenance
-    case .proceed:
-      route = .home
-    }
-  }
-}
-`;
-
-  const match = findSwiftOpenClosedSwitchMatch(source);
-
-  assert.ok(match);
-  assert.equal(match.primary_node.name, 'LaunchFlowCoordinator');
-  assert.deepEqual(match.related_nodes, [
-    { kind: 'member', name: 'discriminator switch: outcome', lines: [4] },
-    { kind: 'member', name: 'case .mandatoryUpdate', lines: [5] },
-    { kind: 'member', name: 'case .maintenance', lines: [7] },
-    { kind: 'member', name: 'case .proceed', lines: [9] },
-  ]);
-  assert.match(match.why, /OCP/);
-});
-
-test('findSwiftXCTestSrpMatch detecta XCTestCase con responsabilidades mezcladas', () => {
-  const source = `import XCTest
-
-final class LaunchFlowCoordinatorConfigTests: XCTestCase {
-  func test_bootstrap_whenMandatoryUpdate_routesToUpdateRequired() async {}
-  func test_bootstrap_whenSessionIsValid_routesHome() async {}
-  func test_completeOnboarding_marksProgressAndRoutesToLogin() async {}
-}
-`;
-
-  const match = findSwiftXCTestSrpMatch(source);
-
-  assert.ok(match);
-  assert.equal(match.primary_node.name, 'LaunchFlowCoordinatorConfigTests');
-  assert.deepEqual(match.related_nodes, [
-    { kind: 'member', name: 'session routing tests', lines: [5] },
-    { kind: 'member', name: 'onboarding progress tests', lines: [6] },
-  ]);
-  assert.match(match.why, /XCTestCase|SRP/);
-});
-
-test('findSwiftXCTestSrpMatch permite XCTestCase enfocado en una responsabilidad', () => {
-  const source = `import XCTest
-
-final class LaunchFlowCoordinatorNonBlockingConfigTests: XCTestCase {
-  func test_bootstrap_whenConfigFetchFailsWithCache_usesCachedConfigAndContinues() async {}
-  func test_bootstrap_whenOptionalUpdate_allowsAccessAndContinues() async {}
-  func test_bootstrap_whenProceed_continuesToSessionValidation() async {}
-}
-`;
-
-  assert.equal(findSwiftXCTestSrpMatch(source), undefined);
-});
-
 test('findSwiftInterfaceSegregationMatch devuelve payload semantico para ISP-iOS en application', () => {
   const source = `
 protocol PumukiIspIosCanarySessionManaging {