relay_chn/test_apps/main/test_relay_chn_nvs_multi.c

/*
 * SPDX-FileCopyrightText: 2025 Kozmotronik Tech
 *
 * SPDX-License-Identifier: MIT
 */

#include <string.h>
#include "unity.h"
#include "esp_system.h"
#include "nvs_flash.h"
#include "relay_chn_nvs.h"

TEST_CASE("Test relay storage init/deinit", "[relay_chn][nvs]")
{
    TEST_ESP_OK(relay_chn_nvs_init());
    TEST_ESP_OK(relay_chn_nvs_deinit());
}

TEST_CASE("Test direction setting and getting", "[relay_chn][nvs]")
{
    TEST_ESP_OK(relay_chn_nvs_init());
    
    // Test all channels
    relay_chn_direction_t dir;
    relay_chn_direction_t test_directions[] = {
        RELAY_CHN_DIRECTION_DEFAULT,
        RELAY_CHN_DIRECTION_FLIPPED
    };
    
    for (int channel = 0; channel < 2; channel++) {
        TEST_ESP_OK(relay_chn_nvs_set_direction(channel, test_directions[channel]));
        TEST_ESP_OK(relay_chn_nvs_get_direction(channel, &dir));
        TEST_ASSERT_EQUAL(test_directions[channel], dir);
    }
    
    TEST_ESP_OK(relay_chn_nvs_deinit());
}

TEST_CASE("Test invalid parameters", "[relay_chn][nvs]")
{
    TEST_ESP_OK(relay_chn_nvs_init());
    
    // Test NULL pointer for all channels
    for (int channel = 0; channel < CONFIG_RELAY_CHN_COUNT; channel++) {
        TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, relay_chn_nvs_get_direction(channel, NULL));
    }
    
    TEST_ESP_OK(relay_chn_nvs_deinit());
}

TEST_CASE("Test relay_chn_nvs_erase_all", "[relay_chn][nvs]")
{
    TEST_ESP_OK(relay_chn_nvs_init());

    // Store some test data first
    relay_chn_direction_t direction = RELAY_CHN_DIRECTION_FLIPPED;
    // Set direction for all channels
    TEST_ESP_OK(relay_chn_nvs_set_direction(0, direction));
    TEST_ESP_OK(relay_chn_nvs_set_direction(1, direction));

#if CONFIG_RELAY_CHN_ENABLE_TILTING
    uint8_t sensitivity = 50;
    for (int channel = 0; channel < CONFIG_RELAY_CHN_COUNT; channel++) {
        TEST_ESP_OK(relay_chn_nvs_set_tilt_sensitivity(channel, sensitivity));
        TEST_ESP_OK(relay_chn_nvs_set_tilt_count(channel, 100 + channel));
    }
#endif

    // Test erase all
    TEST_ESP_OK(relay_chn_nvs_erase_all());

    // Verify data was erased by trying to read it back
    relay_chn_direction_t read_direction;
    TEST_ASSERT_EQUAL(ESP_ERR_NVS_NOT_FOUND, relay_chn_nvs_get_direction(0, &read_direction));

#if CONFIG_RELAY_CHN_ENABLE_TILTING
    for (int channel = 0; channel < CONFIG_RELAY_CHN_COUNT; channel++) {
        uint8_t read_sensitivity;
        TEST_ASSERT_EQUAL(ESP_ERR_NVS_NOT_FOUND, relay_chn_nvs_get_tilt_sensitivity(channel, &read_sensitivity));

        uint16_t tilt_count;
        TEST_ASSERT_EQUAL(ESP_ERR_NVS_NOT_FOUND, relay_chn_nvs_get_tilt_count(channel, &tilt_count));
    }
#endif

    TEST_ESP_OK(relay_chn_nvs_deinit());
}

#if CONFIG_RELAY_CHN_ENABLE_RUN_LIMIT
TEST_CASE("Test run limit setting and getting", "[relay_chn][nvs][run_limit]")
{
    TEST_ESP_OK(relay_chn_nvs_init());
    
    // Use different values for each channel to detect overwrites
    uint16_t test_limits[CONFIG_RELAY_CHN_COUNT];
    for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
        test_limits[i] = 30 + i; // e.g., 30, 31, 32...
    }

    // 1. Set all values first
    for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
        TEST_ESP_OK(relay_chn_nvs_set_run_limit(i, test_limits[i]));
    }

    // 2. Then, read them all back and verify
    for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
        uint16_t run_limit_read;
        TEST_ESP_OK(relay_chn_nvs_get_run_limit(i, &run_limit_read));
        TEST_ASSERT_EQUAL_UINT16(test_limits[i], run_limit_read);
    }

    // 3. Verify that changing one channel doesn't affect another
    uint16_t new_limit_ch0 = 99;
    TEST_ESP_OK(relay_chn_nvs_set_run_limit(0, new_limit_ch0));

    uint16_t read_val_ch0, read_val_ch1;
    TEST_ESP_OK(relay_chn_nvs_get_run_limit(0, &read_val_ch0));
    TEST_ESP_OK(relay_chn_nvs_get_run_limit(1, &read_val_ch1));
    TEST_ASSERT_EQUAL_UINT16(new_limit_ch0, read_val_ch0);
    TEST_ASSERT_EQUAL_UINT16(test_limits[1], read_val_ch1); // Should still be the old value

    TEST_ESP_OK(relay_chn_nvs_deinit());
}
#endif

#if CONFIG_RELAY_CHN_ENABLE_TILTING
TEST_CASE("Test sensitivity setting and getting", "[relay_chn][nvs][tilt]")
{
    TEST_ESP_OK(relay_chn_nvs_init());
    
    uint8_t test_sensitivities[CONFIG_RELAY_CHN_COUNT];
    for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
        test_sensitivities[i] = 70 + i; // e.g., 70, 71, 72...
    }
    
    // 1. Set all values first
    for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
        TEST_ESP_OK(relay_chn_nvs_set_tilt_sensitivity(i, test_sensitivities[i]));
    }

    // 2. Then, read them all back and verify
    for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
        uint8_t sensitivity_read;
        TEST_ESP_OK(relay_chn_nvs_get_tilt_sensitivity(i, &sensitivity_read));
        TEST_ASSERT_EQUAL_UINT8(test_sensitivities[i], sensitivity_read);
    }
    
    TEST_ESP_OK(relay_chn_nvs_deinit());
}

TEST_CASE("Test tilt counter operations", "[relay_chn][nvs][tilt]")
{
    TEST_ESP_OK(relay_chn_nvs_init());
    
    uint16_t test_counts[CONFIG_RELAY_CHN_COUNT];
    for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
        test_counts[i] = 100 + i; // e.g., 100, 101, 102...
    }
    
    // 1. Set all values first
    for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
        TEST_ESP_OK(relay_chn_nvs_set_tilt_count(i, test_counts[i]));
    }

    // 2. Then, read them all back and verify
    for (uint8_t i = 0; i < CONFIG_RELAY_CHN_COUNT; i++) {
        uint16_t count_read;
        TEST_ESP_OK(relay_chn_nvs_get_tilt_count(i, &count_read));
        TEST_ASSERT_EQUAL_UINT16(test_counts[i], count_read);
    }
    
    TEST_ESP_OK(relay_chn_nvs_deinit());
}

TEST_CASE("Test tilting invalid parameters", "[relay_chn][nvs][tilt]")
{
    TEST_ESP_OK(relay_chn_nvs_init());
    
    // Test NULL pointers for all channels
    for (int channel = 0; channel < CONFIG_RELAY_CHN_COUNT; channel++) {
        TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, relay_chn_nvs_get_tilt_sensitivity(channel, NULL));
        TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, relay_chn_nvs_get_tilt_count(channel, NULL));
    }
    
    TEST_ESP_OK(relay_chn_nvs_deinit());
}
#endif // CONFIG_RELAY_CHN_ENABLE_TILTING