[HEAP-37223] Add HeapBridgeSupport.trackInteraction (#97)

Author: bnickel

Demos/Webview Demos/Webview Demos/javascript-bridge.html

@@ -76,6 +76,42 @@
                     new Date(),
                     source
                 );
+                
+                document.addEventListener('click', (e) => {
+                    
+                    const eTarget = e.target;
+                    if (!eTarget) { return; }
+                    
+                    const nodes = [];
+                    const attributeNames = ['aria-role', 'type'];
+                    
+                    for (let target = eTarget; target && target.nodeName; target = target.parentElement) {
+                        
+                        const attributes = {};
+                        for (const name of attributeNames) {
+                            attributes[name] = target.getAttribute(name)
+                        }
+                        
+                        
+                        nodes.push({
+                            nodeName: target.nodeName,
+                            nodeId: target.id || undefined,
+                            nodeHtmlClass: target.className || undefined,
+                            accessibilityLabel: target.getAttribute('aria-label'),
+                            attributes,
+                        });
+                    }
+                    
+                    nodes[0].nodeText = eTarget.textContent;
+                    
+                    Heap.trackInteraction(
+                        'click',
+                        nodes,
+                        null,
+                        new Date(),
+                        source
+                    );
+                });
             }
 
             document.getElementById('startAutocapture').addEventListener('click', function (e) {

Development/Sources/HeapSwiftCore/HeapBridgeSupport/HeapBridgeSupport.swift

@@ -32,6 +32,8 @@ public class HeapBridgeSupport
             return try track(arguments: arguments)
         case "trackPageview":
             return try trackPageview(arguments: arguments)
+        case "trackInteraction":
+            return try trackInteraction(arguments: arguments)
         case "identify":
             return try identify(arguments: arguments)
         case "resetIdentity":
@@ -118,6 +120,17 @@ public class HeapBridgeSupport
         ]
     }
 
+    func trackInteraction(arguments: [String: Any]) throws -> JSONEncodable? {
+        let interaction = try getRequiredInteraction(from: arguments, methodName: "trackInteraction")
+        let nodes = try getRequiredInteractionNodes(from: arguments, methodName: "trackInteraction")
+        let callbackName = try getOptionalString(named: "callbackName", from: arguments, message: "HeapBridgeSupport.trackInteraction received an invalid callback name and will not complete the bridged method call.")
+        let timestamp = try getOptionalTimestamp(arguments, methodName: "trackInteraction")
+        let sourceInfo = try getOptionalSourceLibrary(arguments, methodName: "trackInteraction")
+        let pageview = try getOptionalPageview(from: arguments, methodName: "trackInteraction")
+        eventConsumer.trackInteraction(interaction: interaction, nodes: nodes, callbackName: callbackName, timestamp: timestamp, sourceInfo: sourceInfo, pageview: pageview)
+        return nil
+    }
+    
     func identify(arguments: [String: Any]) throws -> JSONEncodable? {
         let identity = try getRequiredString(named: "identity", from: arguments, message: "HeapBridgeSupport.identify received an invalid identity and will not complete the bridged method call.")
         eventConsumer.identify(identity)
@@ -284,6 +297,71 @@ extension HeapBridgeSupport {
         return pageview
     }
 
+    func getRequiredInteraction(from arguments: [String: Any], methodName: String) throws -> Interaction {
+        guard let rawValue = arguments["interaction"] else {
+            HeapLogger.shared.debug("HeapBridgeSupport.\(methodName) received an event without an interaction type and will not complete the bridged method call.")
+            throw InvocationError.invalidParameters
+        }
+        
+        if let builtinName = rawValue as? String {
+            switch builtinName {
+            case "unspecified": return .unspecified
+            case "click": return .click
+            case "touch": return .touch
+            case "change": return .change
+            case "submit": return .submit
+            default:
+                HeapLogger.shared.debug("HeapBridgeSupport.\(methodName) received an an unknown interaction type, \(builtinName), and will not complete the bridged method call.")
+                throw InvocationError.invalidParameters
+            }
+        }
+        
+        if let rawDictionary = rawValue as? [String: Any] {
+            if let name = rawDictionary["custom"] as? String {
+                return .custom(name)
+            }
+            
+            if let value = rawDictionary["builtin"] as? Int {
+                return .builtin(value)
+            }
+        }
+        
+        HeapLogger.shared.debug("HeapBridgeSupport.\(methodName) received an an invalid interaction type and will not complete the bridged method call.")
+        throw InvocationError.invalidParameters
+    }
+    
+    func getRequiredInteractionNodes(from arguments: [String: Any], methodName: String) throws -> [InteractionNode] {
+        
+        guard
+            let rawArray = arguments["nodes"] as? [Any],
+            !rawArray.isEmpty
+        else {
+            HeapLogger.shared.debug("HeapBridgeSupport.\(methodName) received an event without a list of nodes and will not complete the bridged method call.")
+            throw InvocationError.invalidParameters
+        }
+        
+        return try rawArray.map(getInteractionNode(_:))
+        
+        func message() -> String { "HeapBridgeSupport.\(methodName) received an invalid list of nodes and will not complete the bridged method call." }
+        
+        func getInteractionNode(_ rawNode: Any) throws -> InteractionNode {
+            guard let rawObject = rawNode as? [String: Any] else {
+                HeapLogger.shared.debug(message())
+                throw InvocationError.invalidParameters
+            }
+            
+            var node = InteractionNode(nodeName: try getRequiredString(named: "nodeName", from: rawObject, message: message()))
+            node.nodeText = try getOptionalString(named: "nodeText", from: rawObject, message: message())
+            node.nodeHtmlClass = try getOptionalString(named: "nodeHtmlClass", from: rawObject, message: message())
+            node.nodeId = try getOptionalString(named: "nodeId", from: rawObject, message: message())
+            node.href = try getOptionalString(named: "href", from: rawObject, message: message())
+            node.accessibilityLabel = try getOptionalString(named: "accessibilityLabel", from: rawObject, message: message())
+            node.referencingPropertyName = try getOptionalString(named: "referencingPropertyName", from: rawObject, message: message())
+            node.attributes = try getOptionalParameterDictionary(named: "attributes", from: rawObject, message: message())
+            return node
+        }
+    }
+    
     func getOptionalArrayOfStrings(named name: String, from arguments: [String: Any], message: @autoclosure () -> String) throws -> [String] {
         guard let rawArray = arguments[name] else {
             return []

Development/Sources/HeapSwiftCore/Implementations/WebviewBridge/HeapWebviewBridgeJavaScript.swift

@@ -1,6 +1,13 @@
 import Foundation
 @testable import HeapSwiftCore
 
+struct SessionMessages {
+    let sessionMessage: Message?
+    let initialPageviewMessage: Message?
+    let versionChangeMessage: Message?
+    let postStartMessages: [Message]
+}
+
 extension DataStoreProtocol {
 
     func getPendingMessages(for user: UserToUpload, sessionId: String?, messageLimit: Int = .max, file: StaticString = #file, line: UInt = #line) throws -> [Message] {
@@ -40,6 +47,64 @@ extension DataStoreProtocol {
         return messages
     }
 
+    @discardableResult
+    func assertOnlySession(hasPostStartMessageCount count: Int, file: StaticString = #file, line: UInt = #line) throws -> SessionMessages {
+        
+        let users = usersToUpload().filter({ !$0.sessionIds.isEmpty })
+        
+        guard users.count == 1 else {
+            throw TestFailure("Expected a single user with sessions but found \(users.map(\.userId))", file: file, line: line)
+        }
+        
+        return try assertOnlySession(for: users[0], hasPostStartMessageCount: count, file: file, line: line)
+    }
+    
+    @discardableResult
+    func assertOnlySession(for user: UserToUpload, hasPostStartMessageCount count: Int, file: StaticString = #file, line: UInt = #line) throws -> SessionMessages {
+        guard user.sessionIds.count == 1 else {
+            throw TestFailure("Expected a single session but found \(user.sessionIds)", file: file, line: line)
+        }
+        return try assertSession(for: user, sessionId: user.sessionIds[0], hasPostStartMessageCount: count, file: file, line: line)
+    }
+    
+    @discardableResult
+    func assertSession(for user: UserToUpload, sessionId: String?, hasPostStartMessageCount count: Int, file: StaticString = #file, line: UInt = #line) throws -> SessionMessages {
+        
+        var messages = try getPendingMessages(for: user, sessionId: sessionId, file: file, line: line)
+        
+        var sessionMessage: Message?
+        let initialPageviewMessage: Message?
+        let versionChangeMessage: Message?
+        
+        if case .session(_) = messages.first?.kind {
+            sessionMessage = messages.removeFirst()
+        } else {
+            sessionMessage = nil
+        }
+        
+        if let message = messages.first,
+           case .pageview(_) = message.kind,
+           !message.pageviewInfo.hasComponentOrClassName,
+           !message.pageviewInfo.hasTitle,
+           !message.pageviewInfo.hasURL {
+            initialPageviewMessage = messages.removeFirst()
+        } else {
+            initialPageviewMessage = nil
+        }
+        
+        if case .versionChange(_) = messages.first?.event.kind {
+            versionChangeMessage = messages.removeFirst()
+        } else {
+            versionChangeMessage = nil
+        }
+        
+        guard messages.count == count else {
+            throw TestFailure("Expected exactly \(count) messages after session start messages, but got \(messages.count)", file: file, line: line)
+        }
+        
+        return .init(sessionMessage: sessionMessage, initialPageviewMessage: initialPageviewMessage, versionChangeMessage: versionChangeMessage, postStartMessages: messages)
+    }
+    
     @discardableResult
     func assertOnlyOneUserToUpload(message: String? = nil, file: StaticString = #file, line: UInt = #line) throws -> UserToUpload {
 

Development/Sources/HeapSwiftCoreTestSupport/Helpers/DataStoreProtocol.swift

@@ -117,12 +117,12 @@ extension Message {
         }
         validateBaseMessage(file: file, line: line, user: user, id: nil, timestamp: timestamp, hasSourceLibrary: hasSourceLibrary, sourceLibrary: sourceLibrary, eventProperties: eventProperties)
 
-        expect(event.interaction.kind).to(equal(interaction), description: "The event does not match expected Kind")
-        expect(event.interaction.nodes).to(equal(nodes), description: "The event does not match expected Nodes")
+        expect(file: file, line: line, event.interaction.kind).to(equal(interaction), description: "The event does not match expected Kind")
+        expect(file: file, line: line, event.interaction.nodes).to(equal(nodes), description: "The event does not match expected Nodes")
         if let callbackName = callbackName {
-            expect(event.interaction.callbackName).to(equal(callbackName), description: "The event does not match expected callbackName")
+            expect(file: file, line: line, event.interaction.callbackName).to(equal(callbackName), description: "The event does not match expected callbackName")
         } else {
-            expect(event.interaction.hasCallbackName).to(beFalse(), description: "The event flag hasCallbackName for callbackName is mismatched, expected false flag for nil value")
+            expect(file: file, line: line, event.interaction.hasCallbackName).to(beFalse(), description: "The event flag hasCallbackName for callbackName is mismatched, expected false flag for nil value")
         }
 
         expect(file: file, line: line, hasPageviewInfo).to(beTrue(), description: "The event must have pageview info")