effect invocations used in transitions

.github/workflows/run-tests.yml

@@ -36,6 +36,12 @@ jobs:
         env:
           WORKSPACE_PATH: ${{ github.workspace }}
         run: .\\.github\\workflows\\release\\build-packages.ps1
+      - name: Run unit tests
+        env: 
+          PN_PUB_KEY: ${{ secrets.PN_PUB_KEY }}
+          PN_SUB_KEY: ${{ secrets.PN_SUB_KEY }}
+          PN_SEC_KEY: ${{ secrets.PN_SEC_KEY }}    
+        run: dotnet test .\\src\\UnitTests\\PubnubApiPCL.Tests\\PubnubApiPCL.Tests.csproj --verbosity normal --logger trx 
       - name: Cancel workflow runs for commit on error
         if: failure()
         uses: ./.github/.release/actions/actions/utils/fast-jobs-failure

src/Api/PubnubApi/EventEngine/Presence/Common/PresenceInput.cs

@@ -5,24 +5,24 @@ namespace PubnubApi.EventEngine.Presence.Common
 {
     public class PresenceInput
     {
-        public IEnumerable<string> Channels { get; set; }
-        public IEnumerable<string> ChannelGroups { get; set; }
+        public IEnumerable<string> Channels { get; set; } = Enumerable.Empty<string>();
+        public IEnumerable<string> ChannelGroups { get; set; } = Enumerable.Empty<string>();
 
         public static PresenceInput operator +(PresenceInput a, PresenceInput b)
         {
             return new PresenceInput
             {
-                Channels = a.Channels?.Union(b.Channels ?? new string[0]),
-                ChannelGroups = a.ChannelGroups?.Union(b.ChannelGroups ?? new string[0]),
+                Channels = a.Channels?.Union(b.Channels ?? new string[0]).ToArray(),
+                ChannelGroups = a.ChannelGroups?.Union(b.ChannelGroups ?? new string[0]).ToArray(),
             };
         }
 
         public static PresenceInput operator -(PresenceInput a, PresenceInput b)
         {
             return new PresenceInput
             {
-                Channels = a.Channels?.Except(b.Channels ?? new string[0]),
-                ChannelGroups = a.ChannelGroups?.Except(b.ChannelGroups ?? new string[0]),
+                Channels = a.Channels?.Except(b.Channels ?? new string[0]).ToArray(),
+                ChannelGroups = a.ChannelGroups?.Except(b.ChannelGroups ?? new string[0]).ToArray(),
             };
         }
 
@@ -32,5 +32,15 @@ public bool IsEmpty()
                 || ((Channels != null && Channels.Count() == 0)
                         && (ChannelGroups != null && ChannelGroups.Count() == 0));
         }
+
+        public override bool Equals(object obj)
+        {
+            if (obj is null || obj is not PresenceInput)
+                return false;
+
+            var typedObj = obj as PresenceInput;
+            return this.Channels.SequenceEqual(typedObj.Channels)
+                && this.ChannelGroups.SequenceEqual(typedObj.ChannelGroups);
+        }
     }
 }

src/Api/PubnubApi/EventEngine/Presence/Invocations/CancelDelayedHeartbeatInvocation.cs

@@ -0,0 +1,6 @@
+using PubnubApi.EventEngine.Core;
+
+namespace PubnubApi.EventEngine.Presence.Invocations
+{
+    public class CancelDelayedHeartbeatInvocation : Core.IEffectInvocation {}
+}

src/Api/PubnubApi/EventEngine/Presence/Invocations/CancelWaitInvocation.cs

@@ -0,0 +1,6 @@
+using PubnubApi.EventEngine.Core;
+
+namespace PubnubApi.EventEngine.Presence.Invocations
+{
+    public class CancelWaitInvocation : Core.IEffectInvocation {}
+}

src/Api/PubnubApi/EventEngine/Presence/Invocations/DelayedHeartbeatInvocation.cs

@@ -0,0 +1,12 @@
+using PubnubApi.EventEngine.Presence.Common;
+using PubnubApi.EventEngine.Core;
+
+namespace PubnubApi.EventEngine.Presence.Invocations
+{
+    public class DelayedHeartbeatInvocation : Core.IEffectInvocation
+    {
+        public PresenceInput Input { get; set; }
+        public int Attempts { get; set; }
+        public PNStatus Reason { get; set; }
+    }
+}

src/Api/PubnubApi/EventEngine/Presence/Invocations/HearbeatInvocation.cs

@@ -0,0 +1,10 @@
+using PubnubApi.EventEngine.Presence.Common;
+using PubnubApi.EventEngine.Core;
+
+namespace PubnubApi.EventEngine.Presence.Invocations
+{
+    public class HeartbeatInvocation : Core.IEffectInvocation
+    {
+        public PresenceInput Input { get; set; }
+    }
+}

src/Api/PubnubApi/EventEngine/Presence/Invocations/LeaveInvocation.cs

@@ -0,0 +1,10 @@
+using PubnubApi.EventEngine.Presence.Common;
+using PubnubApi.EventEngine.Core;
+
+namespace PubnubApi.EventEngine.Presence.Invocations
+{
+    public class LeaveInvocation : Core.IEffectInvocation
+    {
+        public PresenceInput Input { get; set; }
+    }
+}

src/Api/PubnubApi/EventEngine/Presence/Invocations/TerminateEventEngineInvocation.cs

@@ -0,0 +1,6 @@
+using PubnubApi.EventEngine.Core;
+
+namespace PubnubApi.EventEngine.Presence.Invocations
+{
+    public class TerminateEventEngineInvocation : Core.IEffectInvocation {}
+}

src/Api/PubnubApi/EventEngine/Presence/Invocations/WaitInvocation.cs

@@ -0,0 +1,10 @@
+using PubnubApi.EventEngine.Presence.Common;
+using PubnubApi.EventEngine.Core;
+
+namespace PubnubApi.EventEngine.Presence.Invocations
+{
+    public class WaitInvocation : Core.IEffectInvocation
+    {
+        public PresenceInput Input { get; set; }
+    }
+}

src/Api/PubnubApi/EventEngine/Presence/States/APresenceState.cs

@@ -1,11 +1,12 @@
 using PubnubApi.EventEngine.Core;
 using PubnubApi.EventEngine.Presence.Common;
+using PubnubApi.EventEngine.Presence.Invocations;
 
 namespace PubnubApi.EventEngine.Presence.States
 {
     public abstract class APresenceState : Core.State
     {
-        public PresenceInput Input { get; set; }
+        public PresenceInput Input { get; set; } = new PresenceInput(); // empty by default
 
         public bool IsEmpty()
         {
@@ -16,12 +17,22 @@ protected TransitionResult HandleLeftEvent(Events.LeftEvent e)
         {
             var newInput = this.Input - e.Input;
 
-            return newInput.IsEmpty()
-                ? (TransitionResult)new InactiveState()
-                : (TransitionResult)new HeartbeatingState()
+            State state = newInput.IsEmpty()
+                ? new InactiveState()
+                : new HeartbeatingState()
                 {
                     Input = newInput,
                 };
+
+            return state.With(new LeaveInvocation(){ Input = e.Input });
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (obj is null || obj is not APresenceState) 
+                return false;
+
+            return this.Input.Equals(((APresenceState)obj).Input);
         }
     }
 }

src/Api/PubnubApi/EventEngine/Presence/States/CooldownState.cs

@@ -22,11 +22,12 @@ public override TransitionResult Transition(IEvent ev)
                     Input = e.Input != this.Input ? this.Input + e.Input : this.Input,
                 },
                 Events.LeftEvent e => HandleLeftEvent(e),
-                Events.LeftAllEvent e => new InactiveState(),
+                Events.LeftAllEvent e => new InactiveState()
+                    .With(new LeaveInvocation(){ Input = this.Input }),
                 Events.DisconnectEvent e => new StoppedState()
                 {
                     Input = this.Input,
-                },
+                }.With(new LeaveInvocation(){ Input = this.Input }),
                 Events.TimesUpEvent e => new HeartbeatingState()
                 {
                     Input = this.Input,

src/Api/PubnubApi/EventEngine/Presence/States/FailedState.cs

@@ -23,15 +23,16 @@ public override TransitionResult Transition(IEvent ev)
                     Input = e.Input != this.Input ? this.Input + e.Input : this.Input,
                 },
                 Events.LeftEvent e => HandleLeftEvent(e),
-                Events.LeftAllEvent e => new InactiveState(),
+                Events.LeftAllEvent e => new InactiveState()
+                    .With(new LeaveInvocation(){ Input = this.Input }),
                 Events.ReconnectEvent e => new HeartbeatingState()
                 {
                     Input = this.Input,
                 },
                 Events.DisconnectEvent e => new StoppedState()
                 {
                     Input = this.Input,
-                }, 
+                }.With(new LeaveInvocation() { Input = this.Input }),
                 _ => null,
             };
         }

src/Api/PubnubApi/EventEngine/Presence/States/HeartBeatingState.cs

@@ -21,7 +21,8 @@ public override TransitionResult Transition(IEvent ev)
                     Input = e.Input != this.Input ? this.Input + e.Input : this.Input,
                 },
                 Events.LeftEvent e => HandleLeftEvent(e),
-                Events.LeftAllEvent e => new InactiveState(),
+                Events.LeftAllEvent e => new InactiveState()
+                    .With(new LeaveInvocation(){ Input = this.Input }),
                 Events.HeartbeatSuccessEvent e => new CooldownState()
                 {
                     Input = this.Input,
@@ -30,7 +31,7 @@ public override TransitionResult Transition(IEvent ev)
                 Events.DisconnectEvent e => new StoppedState()
                 {
                     Input = this.Input,
-                }, 
+                }.With(new LeaveInvocation(){ Input = this.Input }), 
                 _ => null,
             };
         }

src/Api/PubnubApi/EventEngine/Presence/States/InactiveState.cs

@@ -1,4 +1,5 @@
 using PubnubApi.EventEngine.Presence.Invocations;
+using PubnubApi.EventEngine.Presence.Common;
 using PubnubApi.EventEngine.Core;
 using System.Collections.Generic;
 using System;
@@ -9,7 +10,7 @@ public class InactiveState : APresenceState
     {
         public InactiveState()
         {
-            Input = null;
+            Input = new PresenceInput();
         }
 
         // TODO: Dummy Invocation until we have real ones

src/Api/PubnubApi/EventEngine/Presence/States/ReconnectingState.cs

@@ -24,7 +24,8 @@ public override TransitionResult Transition(IEvent ev)
                     Input = e.Input != this.Input ? this.Input + e.Input : this.Input,
                 },
                 Events.LeftEvent e => HandleLeftEvent(e),
-                Events.LeftAllEvent e => new InactiveState(),
+                Events.LeftAllEvent e => new InactiveState()
+                    .With(new LeaveInvocation(){ Input = this.Input }),
                 Events.HeartbeatSuccessEvent e => new CooldownState()
                 {
                     Input = this.Input,
@@ -38,7 +39,7 @@ public override TransitionResult Transition(IEvent ev)
                 Events.DisconnectEvent e => new StoppedState()
                 {
                     Input = this.Input,
-                }, 
+                }.With(new LeaveInvocation(){ Input = this.Input }), 
                 _ => null,
             };
         }

src/Api/PubnubApiPCL/PubnubApiPCL.csproj

@@ -249,6 +249,23 @@
     <Compile Include="..\PubnubApi\EventEngine\Subscribe\States\UnsubscribedState.cs" Link="EventEngine\Subscribe\States\UnsubscribedState.cs" />
     <Compile Include="..\PubnubApi\EventEngine\Subscribe\SubscribeEventEngine.cs" Link="EventEngine\Subscribe\SubscribeEventEngine.cs" />
     <Compile Include="..\PubnubApi\EventEngine\Subscribe\SubscribeEventEngineFactory.cs" Link="EventEngine\Subscribe\SubscribeEventEngineFactory.cs" />
+	<Compile Include="..\PubnubApi\EventEngine\Presence\Common\PresenceInput.cs" Link="EventEngine\Presence\Common\PresenceInput.cs" />
+	<Compile Include="..\PubnubApi\EventEngine\Presence\Events\PresenceEvents.cs" Link="EventEngine\Presence\Events\PresenceEvents.cs" />
+	<Compile Include="..\PubnubApi\EventEngine\Presence\Invocations\CancelDelayedHeartbeatInvocation.cs" Link="EventEngine\Presence\Invocations\CancelDelayedHeartbeatInvocation.cs" />
+	<Compile Include="..\PubnubApi\EventEngine\Presence\Invocations\CancelWaitInvocation.cs" Link="EventEngine\Presence\Invocations\CancelWaitInvocation.cs" />
+	<Compile Include="..\PubnubApi\EventEngine\Presence\Invocations\DelayedHeartbeatInvocation.cs" Link="EventEngine\Presence\Invocations\DelayedHeartbeatInvocation.cs" />
+	<Compile Include="..\PubnubApi\EventEngine\Presence\Invocations\Dummy.cs" Link="EventEngine\Presence\Invocations\Dummy.cs" />
+	<Compile Include="..\PubnubApi\EventEngine\Presence\Invocations\HearbeatInvocation.cs" Link="EventEngine\Presence\Invocations\HearbeatInvocation.cs" />
+	<Compile Include="..\PubnubApi\EventEngine\Presence\Invocations\LeaveInvocation.cs" Link="EventEngine\Presence\Invocations\LeaveInvocation.cs" />
+	<Compile Include="..\PubnubApi\EventEngine\Presence\Invocations\TerminateEventEngineInvocation.cs" Link="EventEngine\Presence\Invocations\TerminateEventEngineInvocation.cs" />
+	<Compile Include="..\PubnubApi\EventEngine\Presence\Invocations\WaitInvocation.cs" Link="EventEngine\Presence\Invocations\WaitInvocation.cs" />
+	<Compile Include="..\PubnubApi\EventEngine\Presence\States\APresenceState.cs" Link="EventEngine\Presence\States\APresenceState.cs" />
+	<Compile Include="..\PubnubApi\EventEngine\Presence\States\CooldownState.cs" Link="EventEngine\Presence\States\CooldownState.cs" />
+	<Compile Include="..\PubnubApi\EventEngine\Presence\States\FailedState.cs" Link="EventEngine\Presence\States\FailedState.cs" />
+	<Compile Include="..\PubnubApi\EventEngine\Presence\States\HeartBeatingState.cs" Link="EventEngine\Presence\States\HeartBeatingState.cs" />
+	<Compile Include="..\PubnubApi\EventEngine\Presence\States\InactiveState.cs" Link="EventEngine\Presence\States\InactiveState.cs" />
+	<Compile Include="..\PubnubApi\EventEngine\Presence\States\ReconnectingState.cs" Link="EventEngine\Presence\States\ReconnectingState.cs" />
+	<Compile Include="..\PubnubApi\EventEngine\Presence\States\StoppedState.cs" Link="EventEngine\Presence\States\StoppedState.cs" />
     <Compile Include="..\PubnubApi\Helper\MobilePushHelper.cs" Link="Helper\MobilePushHelper.cs" />
     <Compile Include="..\PubnubApi\HttpUtility\HttpUtility.cs">
       <Link>HttpUtility\HttpUtility.cs</Link>

src/UnitTests/PubnubApi.Tests/EncryptionTests.cs

@@ -821,4 +821,4 @@ public static string DecodeEncodedNonAsciiCharacters(string value)
                 });
         }
     }
-}
+}

src/UnitTests/PubnubApi.Tests/EventEngine/Presence/CooldownState.cs

@@ -3,68 +3,104 @@
 using PubnubApi.EventEngine.Presence.Common;
 using PubnubApi.EventEngine.Presence.Events;
 using PubnubApi.EventEngine.Presence.States;
+using PubnubApi.EventEngine.Presence.Invocations;
+using System.Linq;
 
 namespace PubnubApi.Tests.EventEngine.Presence
 {
     internal class CooldownTransitions
     {
+        // Test case:
+        // - Current state
+        // - Event
+        // - Expected next state
+        // - Invocations
         private static readonly object[] testCases = {
             new object[] {
                 new CooldownState(),
                 new JoinedEvent() { Input = new PresenceInput() { Channels = new [] { "a" } } },
                 new HeartbeatingState() { Input = new PresenceInput() { Channels = new [] { "a" } } },
+                null
             },
             new object[] {
                 new CooldownState() { Input = new PresenceInput() { Channels = new [] { "a", "b" } } },
                 new LeftEvent() { Input = new PresenceInput() { Channels = new [] { "b" } } },
                 new HeartbeatingState() { Input = new PresenceInput() { Channels = new [] { "a" } } },
+                new IEffectInvocation[] { new LeaveInvocation() { Input = new PresenceInput() { Channels = new [] { "b" } } } }
             },
             new object[] {
                 new CooldownState() { Input = new PresenceInput() { Channels = new [] { "a" } } },
                 new LeftEvent() { Input = new PresenceInput() { Channels = new [] { "a" } } },
                 new InactiveState(),
+                new IEffectInvocation[] { new LeaveInvocation() { Input = new PresenceInput() { Channels = new [] { "a" } } } }
             },
             new object[] {
                 new CooldownState(),
                 new LeftAllEvent(),
                 new InactiveState(),
+                new IEffectInvocation[] { new LeaveInvocation() { Input = new PresenceInput() { Channels = new string[] { } } } }
             },
             new object[] {
                 new CooldownState(),
                 new HeartbeatSuccessEvent(),
                 null,
+                null
             },
             new object[] {
                 new CooldownState(),
                 new HeartbeatFailureEvent() { Status = new PNStatus() },
                 null,
-            },
-            new object[] {
-                new CooldownState(),
-                new HeartbeatGiveUpEvent() { Status = new PNStatus() { Category = PNStatusCategory.PNCancelledCategory } },
-                null,
+                null
             },
             new object[] {
                 new CooldownState(),
                 new ReconnectEvent(),
                 null,
+                null
             },
             new object[] {
                 new CooldownState(),
                 new DisconnectEvent(),
                 new StoppedState(),
+                new IEffectInvocation[] { new LeaveInvocation() { Input = new PresenceInput() } }
             },
             new object[] {
                 new CooldownState(),
                 new TimesUpEvent(),
                 new HeartbeatingState(),
+                null
             },
         };
 
-        [TestCasesSource(nameof(testCases))]
-        public void TestTransition(State @sut, IEvent @ev, State @expected)
+        [TestCaseSource(nameof(testCases))]
+        public void TestTransition(APresenceState @sut, IEvent @ev, APresenceState @expected, IEffectInvocation[] @_)
         {
-            Assert.AreEqual(expected, sut.Transition(ev));
+            var result = @sut.Transition(@ev);
+
+            if (result == null && expected == null)
+            {
+                // it's expected result
+                return;
+            }
+
+            Assert.AreEqual(@expected, result.State);
+        }
+
+        [TestCaseSource(nameof(testCases))]
+         public void TestReturnedInvocations(State @sut, IEvent @ev, State @_, IEffectInvocation[] @expected)
+        {
+            var result = @sut.Transition(@ev);
+
+            if (result == null && expected == null)
+            {
+                // it's expected result
+                return;
+            }
+
+            foreach (var item in result.Invocations)
+            {
+                Assert.True(expected.Select(i => i.GetType()).Contains(item.GetType()));
+            }
         }
     }
 }