test(aggregate): cover all of the AstarteObject functions

Signed-off-by: Joshua Chapman <joshua.chapman@secomind.com>

Author: joshuachp

Cargo.toml

@@ -2,7 +2,19 @@
 #
 # Copyright 2022 - 2025 SECO Mind Srl
 #
-# SPDX-License-Identifier: CC0-1.0
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# SPDX-License-Identifier: Apache-2.0
 
 [package]
 name = "astarte-device-sdk"

scripts/coverage.sh

@@ -0,0 +1,148 @@
+#!/usr/bin/env bash
+
+# This file is part of Astarte.
+#
+# Copyright 2025 SECO Mind Srl
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+set -exEuo pipefail
+
+# Output directories for the profile files and coverage
+#
+# You'll find the coverage report and `lcov` file under: $CARGO_TARGET_DIR/debug/coverage/
+#
+# Use absolute paths every where
+CARGO_TARGET_DIR=$(
+    cargo metadata --format-version 1 --no-deps --locked |
+        jq '.target_directory' --raw-output
+)
+export CARGO_TARGET_DIR
+SRC_DIR="$(
+    cargo +nightly locate-project |
+        jq .root --raw-output |
+        xargs dirname
+)"
+export SRC_DIR
+export PROFS_DIR="$CARGO_TARGET_DIR/profs"
+export LLVM_PROFILE_FILE="$PROFS_DIR/coverage-%p-%m.profraw"
+export COVERAGE_OUT_DIR="$CARGO_TARGET_DIR/debug/coverage"
+
+# This require a nightly compiler
+#
+# Rustc options:
+#
+# - `instrument-coverage`: enable coverage for all
+# - `coverage-options=branch``: enable block and branch coverage (unstable option)
+#
+# See: https://doc.rust-lang.org/rustc/instrument-coverage.html
+export RUSTFLAGS="-Cinstrument-coverage -Zcoverage-options=branch"
+export CARGO_INCREMENTAL=0
+
+# Helpful for testing changes in the generation options
+if [[ ${1:-} != '--no-gen' ]]; then
+    cargo +nightly clean
+
+    mkdir -p "$COVERAGE_OUT_DIR"
+    mkdir -p "$PROFS_DIR"
+
+    cargo +nightly test --locked --all-features --tests --no-fail-fast -p astarte-device-sdk
+fi
+
+find_target_tool() {
+    local libdir
+    local tool_path
+
+    libdir=$(rustup run nightly rustc --print target-libdir)
+    tool_path=$(realpath "$libdir/../bin/$1")
+
+    echo "$tool_path"
+}
+
+rustup_llvm_profdata=$(find_target_tool llvm-profdata)
+rustup_llvm_cov=$(find_target_tool llvm-cov)
+
+LLVM_PROFDATA=${LLVM_PROFDATA:-$rustup_llvm_profdata}
+LLVM_COV=${LLVM_COV:-$rustup_llvm_cov}
+
+$LLVM_PROFDATA merge -sparse "$PROFS_DIR/"*.profraw -o "$PROFS_DIR/coverage.profdata"
+
+object_files() {
+    tests=$(
+        cargo +nightly test --tests --all-features --no-run --message-format=json "$@" |
+            jq -r "select(.profile.test == true) | .filenames[]" |
+            grep -v dSYM -
+    )
+
+    for file in $tests; do
+        printf "%s %s " -object "$file"
+    done
+}
+
+export_lcov() {
+    local src
+    if [[ $1 == 'astarte-device-sdk' ]]; then
+        src="$SRC_DIR/src"
+    else
+        src="$SRC_DIR/$1/src"
+    fi
+
+    # shellcheck disable=2086,2046
+    $LLVM_COV export \
+        -format=lcov \
+        -ignore-filename-regex='/.cargo/registry' \
+        -instr-profile="$PROFS_DIR/coverage.profdata" \
+        -ignore-filename-regex='.*test\.rs' \
+        -ignore-filename-regex='.*mock\.rs' \
+        -sources "$src" $(object_files -p "$1") \
+        >"$COVERAGE_OUT_DIR/$1/lcov.info"
+}
+
+filter_lcov() {
+    local src
+    if [[ $1 == 'astarte-device-sdk' ]]; then
+        src="$SRC_DIR"
+    else
+        src="$SRC_DIR/$1"
+    fi
+
+    grcov \
+        "$COVERAGE_OUT_DIR/$1/lcov.info" \
+        --binary-path "$CARGO_TARGET_DIR/debug" \
+        --output-path "$COVERAGE_OUT_DIR/$1/" \
+        --source-dir "$src" \
+        --branch \
+        --llvm \
+        --excl-start 'mod test(s)?' \
+        --output-type lcov,html
+}
+
+list=(
+    'astarte-device-sdk'
+)
+
+for p in "${list[@]}"; do
+    mkdir -p "$COVERAGE_OUT_DIR/$p/"
+
+    export_lcov "$p"
+
+    filter_lcov "$p"
+
+    cp -v "$COVERAGE_OUT_DIR/$p/lcov" "$COVERAGE_OUT_DIR/coverage-$p.info"
+
+    if [[ -n "${EXPORT_FOR_CI:-}" ]]; then
+        cp -v "$COVERAGE_OUT_DIR/$p/lcov" "$PWD/coverage-$p.info"
+    fi
+done

src/aggregate.rs

@@ -93,6 +93,16 @@ impl AstarteObject {
         Some(value)
     }
 
+    /// Returns the number of key values pairs in the object.
+    pub fn len(&self) -> usize {
+        self.inner.len()
+    }
+
+    /// Returns true if the object has no values.
+    pub fn is_empty(&self) -> bool {
+        self.inner.is_empty()
+    }
+
     /// Iterates the name and values of the object.
     pub fn iter(&self) -> impl Iterator<Item = &(String, AstarteType)> {
         self.inner.iter()
@@ -189,6 +199,8 @@ impl Value {
 
 #[cfg(test)]
 mod tests {
+    use pretty_assertions::assert_eq;
+
     use super::*;
 
     #[test]
@@ -198,12 +210,62 @@ mod tests {
         assert!(val.is_individual());
         assert_eq!(val.as_individual(), Some(&individual));
         assert_eq!(val.as_object(), None);
+        assert_eq!(val.take_individual(), Some(individual));
+
+        let val = Value::Individual(AstarteType::Integer(42));
+        assert_eq!(val.take_object(), None);
 
         let val = Value::Object(AstarteObject::new());
         assert!(val.is_object());
         assert_eq!(val.as_individual(), None);
         assert_eq!(val.as_object(), Some(&AstarteObject::new()));
+        assert_eq!(val.take_object(), Some(AstarteObject::new()));
+
+        let val = Value::Object(AstarteObject::new());
+        assert_eq!(val.take_individual(), None);
 
         assert!(Value::Unset.is_unset());
     }
+
+    #[test]
+    fn create_with_capacity() {
+        let exp = 10;
+        let object = AstarteObject::with_capacity(exp);
+        assert_eq!(object.inner.capacity(), exp);
+    }
+
+    #[test]
+    fn add_value_to_obj_and_replace() {
+        let mut object = AstarteObject::new();
+        let exp = AstarteType::from("foo");
+        object.insert("foo".to_string(), exp.clone());
+        assert_eq!(object.get("foo"), Some(&exp));
+
+        let exp = AstarteType::from("other");
+        object.insert("foo".to_string(), exp.clone());
+        assert_eq!(object.get("foo"), Some(&exp));
+    }
+
+    #[test]
+    fn iter_object_values() {
+        let values = [
+            ("foo", AstarteType::from("foo")),
+            ("bar", AstarteType::from("bar")),
+            ("some", AstarteType::from("some")),
+        ]
+        .map(|(n, v)| (n.to_string(), v));
+
+        let object = AstarteObject::from_iter(values.clone());
+
+        assert!(!object.is_empty());
+        assert_eq!(object.len(), values.len());
+
+        for (exp, val) in object.iter().zip(&values) {
+            assert_eq!(exp, val)
+        }
+
+        for (exp, val) in object.into_key_values().zip(values) {
+            assert_eq!(exp, val)
+        }
+    }
 }