RTL1

ably-ios/ARTPresenceMap.h

@@ -7,22 +7,24 @@
 //
 
 #import <Foundation/Foundation.h>
+#import "CompatibilityMacros.h"
 
 @class ARTPresenceMessage;
 
+ART_ASSUME_NONNULL_BEGIN
+
 /// Used to maintain a list of members present on a channel
-@interface ARTPresenceMap : NSObject {
-
-}
+@interface ARTPresenceMap : NSObject
+
+/// List of members.
+/// The key is the clientId and the value is the latest relevant ARTPresenceMessage for that clientId.
+@property (readonly, atomic, getter=getMembers) __GENERIC(NSDictionary, NSString *, ARTPresenceMessage *) *members;
 
 @property (readwrite, nonatomic, assign) int64_t syncSerial;
 
 - (ARTPresenceMessage *)getClient:(NSString *) clientId;
 - (void)put:(ARTPresenceMessage *) message;
 
-//of the form <NSString *, ARTPresenceMessage*> where
-// the key is the clientId and the value is the latest relevant ARTPresenceMessage for that clientId.
-- (NSDictionary *) members;
 - (void)startSync;
 - (void)endSync;
 - (BOOL)isSyncComplete;
@@ -33,3 +35,5 @@ typedef void(^VoidCb)();
 - (void)onSync:(VoidCb) cb;
 
 @end
+
+ART_ASSUME_NONNULL_END

ably-ios/ARTPresenceMap.m

@@ -11,7 +11,7 @@
 
 @interface ARTPresenceMap ()
 
-@property (readwrite, strong, atomic) NSMutableDictionary *mostRecentMessageForMember; //<clientId, artPresenceMessage *> message
+@property (readwrite, strong, atomic) __GENERIC(NSMutableDictionary, NSString *, ARTPresenceMessage *) *mostRecentMessageForMember;
 @property (readonly, nonatomic, assign) bool syncStarted;
 @property (readonly, nonatomic, assign) bool syncComplete;
 @property (nonatomic, copy) VoidCb cb;
@@ -20,23 +20,26 @@ @interface ARTPresenceMap ()
 
 @implementation ARTPresenceMap
 
--(id) init {
+- (id)init {
     self = [super init];
     if(self) {
-        self.mostRecentMessageForMember = [NSMutableDictionary dictionary];
+        _mostRecentMessageForMember = [NSMutableDictionary dictionary];
         _syncStarted = false;
         _syncComplete = false;
         _cb = nil;
     }
     return self;
 }
 
+- (__GENERIC(NSDictionary, NSString *, ARTPresenceMessage *) *)getMembers {
+    return self.mostRecentMessageForMember;
+}
+
 - (void)onSync:(VoidCb)cb {
     _cb = cb;
 }
 
-- (void) syncMessageProcessed {
-
+- (void)syncMessageProcessed {
     if(self.cb) {
         self.cb();
     }
@@ -52,14 +55,10 @@ - (void)put:(ARTPresenceMessage *) message {
         [self.mostRecentMessageForMember setObject:message forKey:message.clientId];
     }
 }
+
 - (void)startSync {
     self.mostRecentMessageForMember = [NSMutableDictionary dictionary];
     _syncStarted = true;
-
-}
-
-- (NSDictionary *) members {
-    return self.mostRecentMessageForMember;
 }
 
 - (void)endSync {

ably-ios/ARTRealtimeChannel.m

@@ -274,15 +274,12 @@ - (void)onChannelMessage:(ARTProtocolMessage *)message {
             [self onError:message];
             break;
         case ARTProtocolMessageSync:
+            [self.presenceMap syncMessageProcessed];
             break;
         default:
             [self.logger warn:@"ARTRealtime, unknown ARTProtocolMessage action: %tu", message.action];
             break;
     }
-
-    if(message.action == ARTProtocolMessageSync) {
-        [self.presenceMap syncMessageProcessed];
-    }
 }
 
 - (ARTRealtimeChannelState)state {

ablySpec/RealtimeClientChannel.swift

@@ -13,6 +13,70 @@ class RealtimeClientChannel: QuickSpec {
     override func spec() {
         describe("Channel") {
 
+            // RTL1
+            it("should process all incoming messages and presence messages as soon as a Channel becomes attached") {
+                let options = AblyTests.commonAppSetup()
+                let client1 = ARTRealtime(options: options)
+                defer { client1.close() }
+
+                let channel1 = client1.channel("room")
+                channel1.attach()
+
+                waitUntil(timeout: testTimeout) { done in
+                    channel1.presence().enterClient("Client 1", data: nil) { status in
+                        expect(status.state).to(equal(ARTState.Ok))
+                        done()
+                    }
+                }
+
+                options.clientId = "Client 2"
+                let client2 = ARTRealtime(options: options)
+                defer { client2.close() }
+
+                let channel2 = client2.channel(channel1.name)
+                channel2.attach()
+
+                expect(channel2.presence().isSyncComplete()).to(beFalse())
+
+                expect(channel1.presenceMap.members).to(haveCount(1))
+                expect(channel2.presenceMap.members).to(haveCount(0))
+
+                expect(channel2.state).toEventually(equal(ARTRealtimeChannelState.Attached), timeout: testTimeout)
+
+                expect(channel2.presence().isSyncComplete()).toEventually(beTrue(), timeout: testTimeout)
+
+                expect(channel1.presenceMap.members).to(haveCount(1))
+                expect(channel2.presenceMap.members).to(haveCount(1))
+
+                // Check if receives incoming messages
+                channel2.subscribeToName("Client 1") { message, errorInfo in
+                    expect(message.data as? String).to(equal("message"))
+                }
+
+                waitUntil(timeout: testTimeout) { done in
+                    channel1.publish("message", cb: { status in
+                        expect(status.state).to(equal(ARTState.Ok))
+                        done()
+                    })
+                }
+
+                waitUntil(timeout: testTimeout) { done in
+                    channel2.presence().enter(nil) { status in
+                        expect(status.state).to(equal(ARTState.Ok))
+                        done()
+                    }
+                }
+
+                expect(channel1.presenceMap.members).to(haveCount(2))
+                expect(channel1.presenceMap.members).to(allKeysPass({ $0.hasPrefix("Client") }))
+                expect(channel1.presenceMap.members).to(allValuesPass({ $0.action == .Enter }))
+
+                expect(channel2.presenceMap.members).to(haveCount(2))
+                expect(channel2.presenceMap.members).to(allKeysPass({ $0.hasPrefix("Client") }))
+                expect(channel2.presenceMap.members["Client 1"]!.action).to(equal(ARTPresenceAction.Present))
+                expect(channel2.presenceMap.members["Client 2"]!.action).to(equal(ARTPresenceAction.Enter))
+            }
+
             // RTL4
             describe("attach") {
 

ablySpec/TestUtilities.swift

@@ -531,3 +531,69 @@ public func haveParam(key: String, withValue expectedValue: String) -> NonNilMat
         return false
     }
 }
+
+/// A Nimble matcher that succeeds when all Keys from a Dictionary are valid.
+public func allKeysPass<U: CollectionType where U: DictionaryLiteralConvertible, U.Generator.Element == (U.Key, U.Value)> (passFunc: (U.Key) -> Bool) -> NonNilMatcherFunc<U> {
+
+    let elementEvaluator: (Expression<U.Generator.Element>, FailureMessage) throws -> Bool = {
+        expression, failureMessage in
+        failureMessage.postfixMessage = "pass a condition"
+        let value = try expression.evaluate()!
+        return passFunc(value.0)
+    }
+
+    return NonNilMatcherFunc { actualExpression, failureMessage in
+        failureMessage.actualValue = nil
+        if let actualValue = try actualExpression.evaluate() {
+            for item in actualValue {
+                let exp = Expression(expression: { item }, location: actualExpression.location)
+                if try !elementEvaluator(exp, failureMessage) {
+                    failureMessage.postfixMessage =
+                        "all \(failureMessage.postfixMessage),"
+                        + " but failed first at element <\(item.0)>"
+                        + " in <\(actualValue.map({ $0.0 }))>"
+                    return false
+                }
+            }
+            failureMessage.postfixMessage = "all \(failureMessage.postfixMessage)"
+        } else {
+            failureMessage.postfixMessage = "all pass (use beNil() to match nils)"
+            return false
+        }
+
+        return true
+    }
+}
+
+/// A Nimble matcher that succeeds when all Values from a Dictionary are valid.
+public func allValuesPass<U: CollectionType where U: DictionaryLiteralConvertible, U.Generator.Element == (U.Key, U.Value)> (passFunc: (U.Value) -> Bool) -> NonNilMatcherFunc<U> {
+
+    let elementEvaluator: (Expression<U.Generator.Element>, FailureMessage) throws -> Bool = {
+        expression, failureMessage in
+        failureMessage.postfixMessage = "pass a condition"
+        let value = try expression.evaluate()!
+        return passFunc(value.1)
+    }
+
+    return NonNilMatcherFunc { actualExpression, failureMessage in
+        failureMessage.actualValue = nil
+        if let actualValue = try actualExpression.evaluate() {
+            for item in actualValue {
+                let exp = Expression(expression: { item }, location: actualExpression.location)
+                if try !elementEvaluator(exp, failureMessage) {
+                    failureMessage.postfixMessage =
+                        "all \(failureMessage.postfixMessage),"
+                        + " but failed first at element <\(item.1)>"
+                        + " in <\(actualValue.map({ $0.1 }))>"
+                    return false
+                }
+            }
+            failureMessage.postfixMessage = "all \(failureMessage.postfixMessage)"
+        } else {
+            failureMessage.postfixMessage = "all pass (use beNil() to match nils)"
+            return false
+        }
+
+        return true
+    }
+}