appium-mac2-driver 4.1.1 → 4.3.0

package/WebDriverAgentMac/WebDriverAgentLib/Routing/AMTCPSocket.m

@@ -0,0 +1,235 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * See the NOTICE file distributed with this work for additional
+ * information regarding copyright ownership.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "AMTCPSocket.h"
+
+@interface AMTCPSocket ()
+@property (readonly, nonatomic) dispatch_queue_t socketQueue;
+@property (nullable, nonatomic) nw_listener_t listener;
+@property (readonly, nonatomic) NSMutableArray<nw_connection_t> *connectedClients;
+@end
+
+
+@implementation AMTCPSocket
+
+- (instancetype)initWithPort:(uint16_t)port
+{
+  if ((self = [super init])) {
+    _socketQueue = dispatch_queue_create("socketQueue", NULL);
+    _connectedClients = [[NSMutableArray alloc] initWithCapacity:1];
+    _port = port;
+    _delegate = nil;
+  }
+  return self;
+}
+
+- (BOOL)startWithError:(NSError **)error
+{
+  nw_parameters_t parameters = nw_parameters_create_secure_tcp(NW_PARAMETERS_DISABLE_PROTOCOL,
+                                                                NW_PARAMETERS_DEFAULT_CONFIGURATION);
+  NSString *portString = [NSString stringWithFormat:@"%u", (unsigned int)self.port];
+  const char * _Nonnull portCString = (const char * _Nonnull)portString.UTF8String;
+
+  nw_listener_t listener;
+  if (nil != self.interface) {
+    const char * _Nonnull interfaceCString = (const char * _Nonnull)((NSString * _Nonnull)self.interface).UTF8String;
+    nw_endpoint_t localEndpoint = nw_endpoint_create_host(interfaceCString, portCString);
+    nw_parameters_set_local_endpoint(parameters, localEndpoint);
+    // The port is already encoded in localEndpoint above - do not also pass it to
+    // nw_listener_create_with_port, which would be ambiguous.
+    listener = nw_listener_create(parameters);
+  } else {
+    listener = nw_listener_create_with_port(portCString, parameters);
+  }
+  if (nil == listener) {
+    if (error) {
+      *error = [NSError errorWithDomain:@"AMTCPSocket"
+                                    code:1
+                                userInfo:@{NSLocalizedDescriptionKey: @"Failed to create the TCP listener"}];
+    }
+    return NO;
+  }
+  self.listener = listener;
+
+  __weak typeof(self) weakSelf = self;
+  nw_listener_set_queue(listener, self.socketQueue);
+  nw_listener_set_new_connection_handler(listener, ^(nw_connection_t connection) {
+    [weakSelf acceptConnection:connection];
+  });
+
+  dispatch_semaphore_t startupSemaphore = dispatch_semaphore_create(0);
+  __block NSError *startupError = nil;
+  nw_listener_set_state_changed_handler(listener, ^(nw_listener_state_t state, nw_error_t nwError) {
+    if (nw_listener_state_ready == state) {
+      __strong typeof(weakSelf) strongSelf = weakSelf;
+      if (strongSelf) {
+        strongSelf->_port = nw_listener_get_port(listener);
+      }
+      dispatch_semaphore_signal(startupSemaphore);
+    } else if (nw_listener_state_failed == state || nw_listener_state_cancelled == state) {
+      // NSLocalizedDescriptionKey must be a string, not the underlying NSError itself, or
+      // -[NSError localizedDescription] crashes trying to treat it as one.
+      NSError *underlyingError = nwError ? (NSError *)CFBridgingRelease(nw_error_copy_cf_error(nwError)) : nil;
+      if ([underlyingError.domain isEqualToString:NSPOSIXErrorDomain]) {
+        // Surface POSIX errors (e.g. EADDRINUSE) directly, since callers like FBWebServer check
+        // for them by domain/code on the top-level error to decide whether to retry another port.
+        startupError = underlyingError;
+      } else {
+        NSMutableDictionary<NSString *, id> *userInfo = [NSMutableDictionary dictionary];
+        userInfo[NSLocalizedDescriptionKey] = underlyingError.localizedDescription ?: @"The TCP listener failed to start";
+        if (underlyingError) {
+          userInfo[NSUnderlyingErrorKey] = underlyingError;
+        }
+        startupError = [NSError errorWithDomain:@"AMTCPSocket" code:2 userInfo:userInfo];
+      }
+      dispatch_semaphore_signal(startupSemaphore);
+    }
+  });
+  nw_listener_start(listener);
+  BOOL didStartInTime = 0 == dispatch_semaphore_wait(startupSemaphore, dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5 * NSEC_PER_SEC)));
+  if (!didStartInTime) {
+    startupError = [NSError errorWithDomain:@"AMTCPSocket"
+                                        code:3
+                                    userInfo:@{NSLocalizedDescriptionKey: @"Timed out while starting the TCP listener"}];
+  }
+  if (nil != startupError) {
+    if (error) {
+      *error = startupError;
+    }
+    // Cancel rather than just dropping our reference - otherwise a late ready/failed callback
+    // can still fire and the port stays bound at the OS level even though the caller was told
+    // startup failed.
+    nw_listener_cancel(listener);
+    self.listener = nil;
+    return NO;
+  }
+  return YES;
+}
+
+- (void)acceptConnection:(nw_connection_t)connection
+{
+  @synchronized (self.connectedClients) {
+    [self.connectedClients addObject:connection];
+  }
+
+  __weak typeof(self) weakSelf = self;
+  nw_connection_set_queue(connection, self.socketQueue);
+  nw_connection_set_state_changed_handler(connection, ^(nw_connection_state_t state, nw_error_t connectionError) {
+    if (nw_connection_state_ready == state) {
+      __strong typeof(weakSelf) strongSelf = weakSelf;
+      if (nil == strongSelf) {
+        return;
+      }
+      id<AMTCPSocketDelegate> delegate = strongSelf.delegate;
+      if (nil != delegate) {
+        [delegate didClientConnect:connection];
+      }
+      [strongSelf scheduleReceiveForConnection:connection];
+    } else if (nw_connection_state_failed == state || nw_connection_state_cancelled == state) {
+      [weakSelf handleDisconnectForConnection:connection];
+    }
+  });
+  nw_connection_start(connection);
+}
+
+- (void)scheduleReceiveForConnection:(nw_connection_t)connection
+{
+  __weak typeof(self) weakSelf = self;
+  nw_connection_receive(connection, 1, UINT32_MAX, ^(dispatch_data_t  _Nullable content,
+                                                       nw_content_context_t  _Nullable context,
+                                                       bool isComplete,
+                                                       nw_error_t  _Nullable receiveError) {
+    __strong typeof(weakSelf) strongSelf = weakSelf;
+    if (nil == strongSelf) {
+      return;
+    }
+    if (nil != content) {
+      dispatch_data_t nonnullContent = (dispatch_data_t _Nonnull)content;
+      NSMutableData *data = [NSMutableData data];
+      dispatch_data_apply(nonnullContent, ^bool(dispatch_data_t  _Nonnull region, size_t offset, const void * _Nonnull buffer, size_t size) {
+        [data appendBytes:buffer length:size];
+        return true;
+      });
+      if (data.length > 0) {
+        id<AMTCPSocketDelegate> delegate = strongSelf.delegate;
+        if (nil != delegate) {
+          [delegate client:connection didReceiveData:data];
+        }
+      }
+    }
+    if (nil != receiveError || (isComplete && nil == content)) {
+      [strongSelf handleDisconnectForConnection:connection];
+      return;
+    }
+    [strongSelf scheduleReceiveForConnection:connection];
+  });
+}
+
+- (void)handleDisconnectForConnection:(nw_connection_t)connection
+{
+  BOOL wasConnected;
+  @synchronized (self.connectedClients) {
+    wasConnected = [self.connectedClients containsObject:connection];
+    [self.connectedClients removeObject:connection];
+  }
+  if (wasConnected) {
+    id<AMTCPSocketDelegate> delegate = self.delegate;
+    if (nil != delegate) {
+      [delegate didClientDisconnect:connection];
+    }
+  }
+}
+
+- (void)writeData:(NSData *)data toClient:(nw_connection_t)client
+{
+  [self writeData:data toClient:client completion:nil];
+}
+
+- (void)writeData:(NSData *)data toClient:(nw_connection_t)client completion:(nullable void (^)(void))completion
+{
+  dispatch_data_t dispatchData = dispatch_data_create(data.bytes, data.length, self.socketQueue, DISPATCH_DATA_DESTRUCTOR_DEFAULT);
+  nw_connection_send(client, dispatchData, NW_CONNECTION_DEFAULT_STREAM_CONTEXT, false, ^(nw_error_t  _Nullable sendError) {
+    if (completion) {
+      completion();
+    }
+  });
+}
+
+- (void)stop
+{
+  NSArray<nw_connection_t> *clients;
+  @synchronized (self.connectedClients) {
+    clients = self.connectedClients.copy;
+    [self.connectedClients removeAllObjects];
+  }
+  // Cancel on socketQueue, the same queue every connection's send/receive is bound to (see
+  // -acceptConnection:), so a write already issued just before -stop (e.g. a shutdown route's
+  // response) is processed before the cancellation rather than racing it.
+  dispatch_async(self.socketQueue, ^{
+    for (nw_connection_t client in clients) {
+      nw_connection_cancel(client);
+    }
+  });
+
+  self.delegate = nil;
+  nw_listener_t listener = self.listener;
+  if (nil != listener) {
+    nw_listener_cancel((nw_listener_t _Nonnull)listener);
+    self.listener = nil;
+  }
+}
+
+@end

package/WebDriverAgentMac/WebDriverAgentLib/Routing/FBWebServer.h

@@ -9,7 +9,7 @@
 
 #import <Foundation/Foundation.h>
 
-@class RouteResponse, RoutingHTTPServer, FBExceptionHandler;
+@class RouteResponse, AMHTTPServer, FBExceptionHandler;
 @protocol FBWebServerDelegate;
 
 NS_ASSUME_NONNULL_BEGIN

package/WebDriverAgentMac/WebDriverAgentLib/Routing/FBWebServer.m

@@ -9,8 +9,7 @@
 
 #import "FBWebServer.h"
 
-#import "RoutingConnection.h"
-#import "RoutingHTTPServer.h"
+#import "AMHTTPServer.h"
 
 #import "FBCommandHandler.h"
 #import "FBErrorBuilder.h"
@@ -25,23 +24,9 @@
 static NSString *const FBServerURLBeginMarker = @"ServerURLHere->";
 static NSString *const FBServerURLEndMarker = @"<-ServerURLHere";
 
-@interface FBHTTPConnection : RoutingConnection
-@end
-
-@implementation FBHTTPConnection
-
-- (void)handleResourceNotFound
-{
-  [FBLogger logFmt:@"Received request for %@ which we do not handle", self.requestURI];
-  [super handleResourceNotFound];
-}
-
-@end
-
-
 @interface FBWebServer ()
 @property (nonatomic, strong) FBExceptionHandler *exceptionHandler;
-@property (nonatomic, strong) RoutingHTTPServer *server;
+@property (nonatomic, strong) AMHTTPServer *server;
 @property (atomic, assign) BOOL keepAlive;
 @end
 
@@ -76,13 +61,12 @@ static NSString *const FBServerURLEndMarker = @"<-ServerURLHere";
 
 - (void)startHTTPServer
 {
-  self.server = [[RoutingHTTPServer alloc] init];
+  self.server = [[AMHTTPServer alloc] init];
   [self.server setRouteQueue:dispatch_get_main_queue()];
   [self.server setInterface:FBConfiguration.sharedConfiguration.serverInterface];
   [self.server setDefaultHeader:@"Server" value:@"WebDriverAgent/1.0"];
   [self.server setDefaultHeader:@"Access-Control-Allow-Origin" value:@"*"];
   [self.server setDefaultHeader:@"Access-Control-Allow-Headers" value:@"Content-Type, X-Requested-With"];
-  [self.server setConnectionClass:[FBHTTPConnection self]];
 
   [self registerRouteHandlers:[self.class collectCommandHandlerClasses]];
   [self registerServerKeyRouteHandlers];
@@ -119,7 +103,7 @@ static NSString *const FBServerURLEndMarker = @"<-ServerURLHere";
   self.keepAlive = NO;
 }
 
-- (BOOL)attemptToStartServer:(RoutingHTTPServer *)server onPort:(NSInteger)port withError:(NSError **)error
+- (BOOL)attemptToStartServer:(AMHTTPServer *)server onPort:(NSInteger)port withError:(NSError **)error
 {
   server.port = (UInt16)port;
   NSError *innerError = nil;
@@ -195,7 +179,11 @@ static NSString *const FBServerURLEndMarker = @"<-ServerURLHere";
       [FBSession.activeSession kill];
     } @finally {
       [response respondWithString:@"Shutting down"];
-      [self.delegate webServerDidRequestShutdown:self];
+      // Deferred so the "Shutting down" response is written to the client before
+      // webServerDidRequestShutdown: tears down the server's socket out from under it.
+      dispatch_async(dispatch_get_main_queue(), ^{
+        [self.delegate webServerDidRequestShutdown:self];
+      });
     }
   }];
 

package/WebDriverAgentMac/WebDriverAgentLib/Routing/RouteRequest.h

@@ -0,0 +1,36 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * See the NOTICE file distributed with this work for additional
+ * information regarding copyright ownership.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// A minimal request value type, exposing just the surface FBWebServer's route blocks and
+// FBRoute.decorateRequest: read.
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RouteRequest : NSObject
+
+@property (nonatomic, copy, readonly) NSURL *url;
+@property (nonatomic, copy, readonly) NSDictionary<NSString *, NSString *> *params;
+@property (nonatomic, copy, readonly) NSData *body;
+
+- (instancetype)initWithURL:(NSURL *)url
+                      params:(NSDictionary<NSString *, NSString *> *)params
+                        body:(NSData *)body;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/WebDriverAgentMac/WebDriverAgentLib/Routing/RouteRequest.m

@@ -0,0 +1,33 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * See the NOTICE file distributed with this work for additional
+ * information regarding copyright ownership.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "RouteRequest.h"
+
+@implementation RouteRequest
+
+- (instancetype)initWithURL:(NSURL *)url
+                      params:(NSDictionary<NSString *, NSString *> *)params
+                        body:(NSData *)body
+{
+  if ((self = [super init])) {
+    _url = url.copy;
+    _params = params.copy;
+    _body = body.copy;
+  }
+  return self;
+}
+
+@end

package/WebDriverAgentMac/WebDriverAgentLib/Routing/RouteResponse.h

@@ -0,0 +1,37 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * See the NOTICE file distributed with this work for additional
+ * information regarding copyright ownership.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// A minimal response value type, exposing just the surface FBRoute.m/FBResponseJSONPayload.m
+// call on it.
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RouteResponse : NSObject
+
+@property (nonatomic) NSInteger statusCode;
+@property (nonatomic, copy, readonly) NSDictionary<NSString *, NSString *> *headers;
+@property (nonatomic, copy, readonly, nullable) NSData *responseData;
+
+- (void)setHeader:(NSString *)field value:(NSString *)value;
+- (void)respondWithString:(NSString *)string;
+- (void)respondWithString:(NSString *)string encoding:(NSStringEncoding)encoding;
+- (void)respondWithData:(NSData *)data;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/WebDriverAgentMac/WebDriverAgentLib/Routing/RouteResponse.m

@@ -0,0 +1,62 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * See the NOTICE file distributed with this work for additional
+ * information regarding copyright ownership.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "RouteResponse.h"
+
+@interface RouteResponse ()
+@property (nonatomic, copy) NSMutableDictionary<NSString *, NSString *> *mutableHeaders;
+@end
+
+@implementation RouteResponse
+
+- (instancetype)init
+{
+  if ((self = [super init])) {
+    _statusCode = 200;
+    _mutableHeaders = [NSMutableDictionary dictionary];
+  }
+  return self;
+}
+
+- (NSDictionary<NSString *, NSString *> *)headers
+{
+  return self.mutableHeaders.copy;
+}
+
+- (void)setHeader:(NSString *)field value:(NSString *)value
+{
+  self.mutableHeaders[field] = value;
+}
+
+- (void)respondWithData:(NSData *)data
+{
+  _responseData = data.copy;
+  if (nil == self.mutableHeaders[@"Content-Length"]) {
+    self.mutableHeaders[@"Content-Length"] = [NSString stringWithFormat:@"%lu", (unsigned long)data.length];
+  }
+}
+
+- (void)respondWithString:(NSString *)string
+{
+  [self respondWithString:string encoding:NSUTF8StringEncoding];
+}
+
+- (void)respondWithString:(NSString *)string encoding:(NSStringEncoding)encoding
+{
+  [self respondWithData:[string dataUsingEncoding:encoding] ?: [NSData data]];
+}
+
+@end

package/WebDriverAgentMac/WebDriverAgentLib/Utilities/AMSnapshotUtils.h

@@ -43,6 +43,17 @@ NS_ASSUME_NONNULL_BEGIN
  */
 + (nullable NSString *)wdIdentifierWithSnapshot:(nullable id<XCUIElementSnapshot>)snapshot;
 
+/**
+ Whether this process is trusted for the Accessibility API. WebKit DOM identifier
+ resolution silently yields no results without this, since AXDOMIdentifier reads
+ fail with kAXErrorAPIDisabled - useful for tests and diagnostics to tell "no DOM id
+ fallback happened because the setting is off" apart from "no DOM id fallback
+ happened because this process lacks Accessibility permission".
+
+ @return YES if AXDOMIdentifier reads are expected to work, NO otherwise
+ */
++ (BOOL)isAccessibilityTrusted;
+
 /**
  Resolves snapshot hashes back to live elements below the given root element.
 
@@ -57,6 +68,17 @@ NS_ASSUME_NONNULL_BEGIN
                                   rootSnapshot:(id<XCUIElementSnapshot>)rootSnapshot
                          includeOnlyFirstMatch:(BOOL)firstMatch;
 
+/**
+ Reads the non-standard AXDOMIdentifier attribute, where WebKit publishes a web
+ node's HTML `id`. Returns nil for native elements, which report
+ kAXErrorAttributeUnsupported for it, or when this process lacks Accessibility
+ permission.
+
+ @param snapshot snapshot instance to read the DOM identifier from
+ @return The DOM identifier or nil
+ */
++ (nullable NSString *)domIdentifierWithSnapshot:(nullable id)snapshot;
+
 @end
 
 NS_ASSUME_NONNULL_END

package/WebDriverAgentMac/WebDriverAgentLib/Utilities/AMSnapshotUtils.m

@@ -65,17 +65,6 @@ static BOOL AMIsAccessibilityTrusted(void)
   return isTrusted;
 }
 
-@interface AMSnapshotUtils ()
-
-/**
- Reads the non-standard AXDOMIdentifier attribute, where WebKit publishes a web
- node's HTML `id`. Returns nil for native elements, which report
- kAXErrorAttributeUnsupported for it.
- */
-+ (nullable NSString *)domIdentifierWithSnapshot:(nullable id)snapshot;
-
-@end
-
 @implementation AMSnapshotUtils
 
 + (NSString *)hashWithSnapshot:(id)snapshot
@@ -94,6 +83,11 @@ static BOOL AMIsAccessibilityTrusted(void)
   return [self domIdentifierWithSnapshot:snapshot] ?: identifier;
 }
 
++ (BOOL)isAccessibilityTrusted
+{
+  return AMIsAccessibilityTrusted();
+}
+
 + (NSArray<XCUIElement *> *)elementsWithHashes:(NSSet<NSString *> *)hashes
                                    rootElement:(XCUIElement *)rootElement
                                   rootSnapshot:(id<XCUIElementSnapshot>)rootSnapshot

package/WebDriverAgentMac/WebDriverAgentLib/Utilities/FBElementUtils.m

@@ -11,6 +11,7 @@
 
 #import "FBExceptions.h"
 #import "FBMacros.h"
+#import "XCUIElement+AMAttributes.h"
 
 @implementation FBElementUtils
 
@@ -43,7 +44,12 @@
       FBStringify(XCUIElement, title),
       FBStringify(XCUIElement, value),
       FBStringify(XCUIElement, frame),
-      FBStringify(XCUIElement, identifier)
+      FBStringify(XCUIElement, identifier),
+      AM_IDENTIFIER_ATTRIBUTE_NAME,
+      AM_RECT_ATTRIBUTE_NAME,
+      AM_TEXT_ATTRIBUTE_NAME,
+      AM_TYPE_ATTRIBUTE_NAME,
+      AM_HAS_KEYBOARD_INPUT_FOCUS_ATTRIBUTE_NAME
     ];
   });
   return attributeNames;