Basic implementation of OTA business logic

Author: aentinger

.github/workflows/compile-examples.yml

@@ -8,12 +8,12 @@ jobs:
 
     env:
       # libraries to install
-      UNIVERSAL_LIBRARIES: '"ArduinoCloudThing" "Arduino_ConnectionHandler" "Arduino_DebugUtils" "ArduinoMqttClient" "Arduino_MKRMEM"'
+      UNIVERSAL_LIBRARIES: '"ArduinoCloudThing" "Arduino_ConnectionHandler" "Arduino_DebugUtils" "ArduinoMqttClient" "Arduino_CRC32"'
       # board-specific libraries
-      WIFI_LIBRARIES: '"ArduinoBearSSL" "ArduinoECCX08" "RTCZero" "WiFi101" "WiFiNINA"'
+      WIFI_LIBRARIES: '"ArduinoBearSSL" "ArduinoECCX08" "RTCZero" "WiFi101" "WiFiNINA" "Arduino_MKRMEM"'
       WAN_LIBRARIES: '"ArduinoBearSSL" "ArduinoECCX08" "RTCZero" "MKRWAN"'
-      GSM_LIBRARIES: '"ArduinoBearSSL" "ArduinoECCX08" "RTCZero" "MKRGSM"'
-      NB_LIBRARIES: '"ArduinoBearSSL" "ArduinoECCX08" "RTCZero" "MKRNB"'
+      GSM_LIBRARIES: '"ArduinoBearSSL" "ArduinoECCX08" "RTCZero" "MKRGSM" "Arduino_MKRMEM"'
+      NB_LIBRARIES: '"ArduinoBearSSL" "ArduinoECCX08" "RTCZero" "MKRNB" "Arduino_MKRMEM"'
       ESP8266_LIBRARIES: ''
       # sketch paths to compile (recursive)
       UNIVERSAL_SKETCH_PATHS: '"examples/ArduinoIoTCloud-Advanced" "examples/ArduinoIoTCloud-Basic" "examples/utility/ArduinoIoTCloud_Travis_CI"'

.gitignore

@@ -3,4 +3,5 @@
 *~
 .vscode
 *.orig
-.vs
+.vs
+build

extras/test/CMakeLists.txt

@@ -10,6 +10,7 @@ project(testArduinoIoTCloud)
 
 include_directories(include)
 include_directories(../../src/utility/ota)
+include_directories(../../../Arduino_CRC32/src)
 include_directories(external/catch/v2.12.1/include)
 
 ##########################################################################
@@ -26,11 +27,13 @@ set(TEST_SRCS
   src/test_main.cpp
   src/test_OTALogic.cpp
   src/OTAStorage_Mock.cpp
+  src/OTATestData.cpp
   ../../src/utility/ota/OTALogic.cpp
 )
 
 ##########################################################################
 
+add_compile_definitions(HOST)
 add_compile_options(-Wall -Wextra -Wpedantic -Werror)
 
 ##########################################################################

extras/test/include/OTAStorage_Mock.h

@@ -11,6 +11,8 @@
 
 #include <OTAStorage.h>
 
+#include <vector>
+
 /**************************************************************************************
    CLASS DECLARATION
  **************************************************************************************/
@@ -31,6 +33,7 @@ class OTAStorage_Mock : public OTAStorage
 
   bool _init_return_val;
   bool _open_return_val;
+  std::vector <uint8_t> _binary;
 
 };
 

extras/test/include/OTATestData.h

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2020 Arduino.  All rights reserved.
+ */
+
+#ifndef OTA_TEST_DATA_H_
+#define OTA_TEST_DATA_H_
+
+/**************************************************************************************
+   INCLUDE
+ **************************************************************************************/
+
+#include <stdint.h>
+
+/**************************************************************************************
+   TYPEDEF
+ **************************************************************************************/
+
+union OTAData
+{
+  struct __attribute__((packed))
+  {
+    uint32_t len;
+    uint32_t crc32;
+    uint8_t  bin[256*1024]; /* Maximum flash size of ATSAMD21G18 is 256 KB */
+  } data;
+  uint8_t buf[sizeof(data)];
+};
+
+/**************************************************************************************
+   FUNCTION DECLARATION
+ **************************************************************************************/
+
+void generate_valid_ota_data(OTAData & ota_data);
+
+#endif /* OTA_TEST_DATA_H_ */

extras/test/src/OTAStorage_Mock.cpp

@@ -30,11 +30,13 @@ bool OTAStorage_Mock::init()
 
 bool OTAStorage_Mock::open()
 {
+  _binary.clear();
   return _open_return_val;
 }
 
-size_t OTAStorage_Mock::write(uint8_t const * const /* buf */, size_t const num_bytes)
+size_t OTAStorage_Mock::write(uint8_t const * const buf, size_t const num_bytes)
 {
+  std::copy(buf, buf + num_bytes, std::back_inserter(_binary));
   return num_bytes;
 }
 

extras/test/src/OTATestData.cpp

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2020 Arduino.  All rights reserved.
+ */
+
+/**************************************************************************************
+   INCLUDE
+ **************************************************************************************/
+
+#include <OTATestData.h>
+
+#include <algorithm>
+
+/**************************************************************************************
+   FUNCTION DEFINITION
+ **************************************************************************************/
+
+void generate_valid_ota_data(OTAData & ota_data)
+{
+  /* Set length. Attention: header length (8 bytes for len and crc32 are not included - this is only the payload length. */
+  ota_data.data.len = 64 * 1024;
+  
+  /* Fill array */
+  std::generate(ota_data.data.bin,
+                ota_data.data.bin + ota_data.data.len,
+                [](void) -> uint8_t
+                {
+                  static uint8_t val = 0;
+                  return val++;
+                });
+
+  /* Generate CRC */
+  
+}

extras/test/src/test_OTALogic.cpp

@@ -6,49 +6,64 @@
    INCLUDE
  **************************************************************************************/
 
+#include <algorithm>
+
 #include <catch.hpp>
 
+#include <OTATestData.h>
 #include <OTAStorage_Mock.h>
 
 #include <OTALogic.h>
 
 /**************************************************************************************
-   TEST CODE
+   TEST HELPER
  **************************************************************************************/
 
-TEST_CASE("A OTALogic object is instantiated", "[OTALogic::OTALogic]")
+void simulateOTABinaryReception(OTALogic & ota_logic, OTAStorage_Mock & ota_storage, OTAData const & ota_test_data)
 {
-  OTALogic ota_logic;
-
-  REQUIRE(ota_logic.state() == OTAState::Init);
+  uint32_t bytes_written = 0;
+  uint32_t const bytes_to_write = sizeof(uint32_t) + sizeof(uint32_t) + ota_test_data.data.len;
+  for(; bytes_written < (bytes_to_write - MQTT_OTA_BUF_SIZE); bytes_written += MQTT_OTA_BUF_SIZE)
+  {
+    ota_logic.onOTADataReceived(ota_test_data.buf + bytes_written, MQTT_OTA_BUF_SIZE);
+    ota_logic.update(&ota_storage);
+  }
 
-  WHEN("update(nullptr) is run")
+  if(bytes_written < bytes_to_write)
   {
-    ota_logic.update(nullptr);
-    THEN("the logic shall transitition to the Error state") {
-      REQUIRE(ota_logic.state() == OTAState::Error);
-    }
+    uint32_t const remaining_bytes = (bytes_to_write - bytes_written);
+    ota_logic.onOTADataReceived(ota_test_data.buf + bytes_written, remaining_bytes);
+    ota_logic.update(&ota_storage);
   }
 }
 
-TEST_CASE("A OTALogic object checks is valid OTAStorage is available", "[OTALogic::update-1]")
+/**************************************************************************************
+   TEST CODE
+ **************************************************************************************/
+
+TEST_CASE("A valid OTA binary is received ", "[OTALogic - valid data]")
 {
   OTALogic ota_logic;
+  OTAData valid_ota_test_data;
   OTAStorage_Mock ota_storage;
 
-  WHEN("update(&ota_storage) is run")
+  ota_storage._init_return_val = true;
+  ota_storage._open_return_val = true;
+
+  generate_valid_ota_data(valid_ota_test_data);
+
+  simulateOTABinaryReception(ota_logic, ota_storage, valid_ota_test_data);
+
+  THEN("the complete binary file should have been written to the OTA storage")
+  {
+    REQUIRE(ota_storage._binary.size() == valid_ota_test_data.data.len);
+    REQUIRE(std::equal(ota_storage._binary.begin(),
+                       ota_storage._binary.end(),
+                       valid_ota_test_data.data.bin));
+  }
+
+  THEN("The OTA logic should be in the 'Reset' state")
   {
-    WHEN("OTAStorage::init() succeeds")
-    {
-      ota_storage._init_return_val = true;
-      ota_logic.update(&ota_storage);
-      THEN("the logic shall transitition to the Idle state") REQUIRE(ota_logic.state() == OTAState::Idle);
-    }
-    WHEN("OTAStorage::init() fails")
-    {
-      ota_storage._init_return_val = false;
-      ota_logic.update(&ota_storage);
-      THEN("the logic shall transitition to the Error state") REQUIRE(ota_logic.state() == OTAState::Error);
-    }
+    REQUIRE(ota_logic.state() == OTAState::Reset);
   }
 }