Fixes downlink runtime incorrectly sending event frames when there has been no event when syncing

Author: SirCipher

runtime/swimos_runtime/src/downlink/mod.rs

@@ -653,7 +653,13 @@ where
                     trace!("Entering Synced state.");
                     dl_state = ReadTaskDlState::Synced;
                     if is_active {
-                        if I::SINGLE_FRAME_STATE {
+                        // Current will be empty if we're communicating with a Supply Lane as no
+                        // event envelope will have been sent. Therefore, we can't use
+                        // `sync_current` as it will send an event notification with an empty body
+                        // and cause the downlink's runtime task envelope decoder will potentially
+                        // fail due to reading an extant. Therefore, delegate the operation to
+                        // `sync_only` which will not send an event notification.
+                        if I::SINGLE_FRAME_STATE && !current.is_empty() {
                             sync_current(&mut awaiting_synced, &mut registered, &current).await;
                         } else {
                             sync_only(&mut awaiting_synced, &mut registered).await;

runtime/swimos_runtime/src/downlink/tests/value.rs

@@ -731,7 +731,7 @@ async fn exhaust_output_buffer() {
 }
 
 #[tokio::test]
-async fn shutdowm_after_timeout_with_no_subscribers() {
+async fn shutdown_after_timeout_with_no_subscribers() {
     let ((_stop, events), result) = run_test_with_config(
         DownlinkOptions::empty(),
         DownlinkRuntimeConfig {
@@ -1079,3 +1079,48 @@ async fn receive_from_two_consumers() {
     assert_eq!(first_events, vec![DownlinkNotification::Unlinked]);
     assert_eq!(second_events, vec![DownlinkNotification::Unlinked]);
 }
+
+#[tokio::test]
+async fn sync_no_event() {
+    let (events, result) = run_test(
+        DownlinkOptions::SYNC,
+        |TestContext {
+             mut tx,
+             mut rx,
+             start_client,
+             stop,
+             mut events,
+             ..
+         }| async move {
+            expect_message(rx.recv().await, Operation::Link);
+
+            tx.link().await;
+
+            start_client.trigger();
+
+            expect_event(
+                events.next().await,
+                State::Unlinked,
+                DownlinkNotification::Linked,
+            );
+            expect_message(rx.recv().await, Operation::Sync);
+
+            tx.sync().await;
+
+            expect_event(
+                events.next().await,
+                State::Linked,
+                DownlinkNotification::Synced,
+            );
+
+            stop.trigger();
+            events.collect::<Vec<_>>().await
+        },
+    )
+    .await;
+    assert!(result.is_ok());
+    assert_eq!(
+        events,
+        vec![(State::Synced, DownlinkNotification::Unlinked)]
+    );
+}