Maybe fix intermittent failures in offline autoopen tests

Realm/ObjectServerTests/RLMSyncTestCase.mm

@@ -555,7 +555,7 @@ - (RLMApp *)app {
  if (!_app) {
  _app = [RLMApp appWithId:self.appId configuration:self.defaultAppConfiguration rootDirectory:self.clientDataRoot];
  RLMSyncManager *syncManager = self.app.syncManager;
- syncManager.logLevel = RLMSyncLogLevelTrace;
+ syncManager.logLevel = RLMSyncLogLevelOff;
  syncManager.userAgent = self.name;
  }
  return _app;
@@ -682,7 +682,7 @@ - (RLMApp *)flexibleSyncApp {
  configuration:self.defaultAppConfiguration
  rootDirectory:self.clientDataRoot];
  RLMSyncManager *syncManager = self.flexibleSyncApp.syncManager;
- syncManager.logLevel = RLMSyncLogLevelTrace;
+ syncManager.logLevel = RLMSyncLogLevelOff;
  syncManager.userAgent = self.name;
  }
  return _flexibleSyncApp;

Realm/ObjectServerTests/SwiftSyncTestCase.swift

@@ -181,16 +181,19 @@ open class SwiftSyncTestCase: RLMSyncTestCase {
 
  public static let bigObjectCount = 2
  public func populateRealm<T: BSON>(user: User? = nil, partitionValue: T) throws {
- let user = try (user ?? logInUser(for: basicCredentials()))
- let config = user.configuration(testName: partitionValue)
+ try autoreleasepool {
+ let user = try (user ?? logInUser(for: basicCredentials()))
+ let config = user.configuration(testName: partitionValue)
 
- let realm = try openRealm(configuration: config)
- try realm.write {
- for _ in 0..<SwiftSyncTestCase.bigObjectCount {
- realm.add(SwiftHugeSyncObject.create())
+ let realm = try openRealm(configuration: config)
+ try realm.write {
+ for _ in 0..<SwiftSyncTestCase.bigObjectCount {
+ realm.add(SwiftHugeSyncObject.create())
+ }
  }
+ waitForUploads(for: realm)
+ realm.syncSession?.suspend()
  }
- waitForUploads(for: realm)
  }
 
  // MARK: - Flexible Sync Use Cases

Realm/ObjectServerTests/SwiftUIServerTests.swift

@@ -338,22 +338,19 @@ class SwiftUIServerTests: SwiftSyncTestCase {
 
  // In case of no internet connection AutoOpen should return an opened Realm, offline-first approach
  func testAutoOpenOpenRealmWithoutInternetConnection() throws {
+ try autoreleasepool {
+ let user = try logInUser(for: basicCredentials(app: self.app), app: self.app)
+ try populateRealm(user: user, partitionValue: #function)
+ }
+ resetAppCache()
+
  let proxy = TimeoutProxyServer(port: 5678, targetPort: 9090)
  try proxy.start()
- let appId = try RealmServer.shared.createApp()
  let appConfig = AppConfiguration(baseURL: "http://localhost:5678",
  transport: AsyncOpenConnectionTimeoutTransport(),
  localAppName: nil,
  localAppVersion: nil)
-
- try autoreleasepool {
- let app = App(id: appId, configuration: appConfig)
- let user = try logInUser(for: basicCredentials(app: app), app: app)
- try populateRealm(user: user, partitionValue: #function)
- }
- App.resetAppCache()
-
- let app = App(id: appId, configuration: appConfig)
+ let app = App(id: appId, configuration: appConfig, rootDirectory: nil)
  let user = try logInUser(for: basicCredentials(app: app), app: app)
  proxy.dropConnections = true
  let ex = expectation(description: "download-realm-auto-open-no-connection")
@@ -364,19 +361,13 @@ class SwiftUIServerTests: SwiftSyncTestCase {
  }
  }
 
+ // Clear cache to avoid leaking our app which connects to the proxy
+ App.resetAppCache()
  proxy.stop()
  }
 
  // In case of no internet connection AutoOpen should return an opened Realm, offline-first approach
  func testAutoOpenOpenForFlexibleSyncConfigWithoutInternetConnection() throws {
- let proxy = TimeoutProxyServer(port: 5678, targetPort: 9090)
- try proxy.start()
-
- let appConfig = AppConfiguration(baseURL: "http://localhost:5678",
- transport: AsyncOpenConnectionTimeoutTransport(),
- localAppName: nil,
- localAppVersion: nil)
-
  try autoreleasepool {
  try populateFlexibleSyncData { realm in
  for i in 1...10 {
@@ -388,8 +379,14 @@ class SwiftUIServerTests: SwiftSyncTestCase {
  }
  }
  }
- App.resetAppCache()
+ resetAppCache()
 
+ let proxy = TimeoutProxyServer(port: 5678, targetPort: 9090)
+ try proxy.start()
+ let appConfig = AppConfiguration(baseURL: "http://localhost:5678",
+ transport: AsyncOpenConnectionTimeoutTransport(),
+ localAppName: nil,
+ localAppVersion: nil)
  let app = App(id: flexibleSyncAppId, configuration: appConfig)
 
  let user = try logInUser(for: basicCredentials(app: app), app: app)
@@ -413,6 +410,7 @@ class SwiftUIServerTests: SwiftSyncTestCase {
  waitForExpectations(timeout: 10.0)
  autoOpen.cancel()
 
+ App.resetAppCache()
  proxy.stop()
  }
 

Realm/ObjectServerTests/TimeoutProxyServer.swift

@@ -99,10 +99,12 @@ public class TimeoutProxyServer: NSObject, @unchecked Sendable {
 private func copyData(from: NWConnection, to: NWConnection) {
  from.receive(minimumIncompleteLength: 1, maximumLength: 8192) { (data, context, isComplete, error) in
  if let error = error {
- if case .posix(.ECANCELED) = error {
+ switch error {
+ case .posix(.ECANCELED), .posix(.ECONNRESET):
  return
+ default:
+ fatalError("\(error)")
  }
- fatalError("\(error)")
  }
 
  guard let data = data else {

Realm/RLMApp.mm

@@ -314,6 +314,19 @@ + (instancetype)appWithId:(NSString *)appId
  return app;
 }
 
++ (instancetype)uncachedAppWithId:(NSString *)appId
+ configuration:(RLMAppConfiguration *)configuration
+ rootDirectory:(NSURL *)rootDirectory {
+ REALM_ASSERT(appId.length);
+
+ [configuration setAppId:appId];
+ auto app = RLMTranslateError([&] {
+ return app::App::get_uncached_app(configuration.config,
+ [RLMSyncManager configurationWithRootDirectory:rootDirectory appId:appId]);
+ });
+ return [[RLMApp alloc] initWithApp:app];
+}
+
 + (instancetype)appWithId:(NSString *)appId configuration:(RLMAppConfiguration *)configuration {
  return [self appWithId:appId configuration:configuration rootDirectory:nil];
 }

Realm/RLMApp_Private.h

@@ -45,6 +45,10 @@ typedef void(^RLMAppNotificationBlock)(RLMApp *);
  configuration:(nullable RLMAppConfiguration *)configuration
  rootDirectory:(nullable NSURL *)rootDirectory;
 
++ (instancetype)uncachedAppWithId:(NSString *)appId
+ configuration:(RLMAppConfiguration *)configuration
+ rootDirectory:(nullable NSURL *)rootDirectory;
+
 + (void)resetAppCache;
 @end
 

Realm/RLMApp_Private.hpp

@@ -25,23 +25,13 @@
 RLM_HEADER_AUDIT_BEGIN(nullability, sendability)
 
 @interface RLMAppConfiguration ()
-
 - (realm::app::App::Config&)config;
-
 - (instancetype)initWithConfig:(const realm::app::App::Config&)config;
-
 @end
 
 @interface RLMApp ()
-
 - (std::shared_ptr<realm::app::App>)_realmApp;
-
-+ (instancetype)appWithId:(NSString *)appId
- configuration:(nullable RLMAppConfiguration *)configuration
- rootDirectory:(nullable NSURL *)rootDirectory;
-
 - (instancetype)initWithApp:(std::shared_ptr<realm::app::App>)app;
-
 @end
 
 NSError * makeError(realm::app::AppError const& appError);