www

Overview

This file contains a module write_new_messages_tests which defines a suite of unit tests for the functionality related to writing or processing new messages in a message database context. The tests are conditionally compiled only when the test configuration and the feature flag "messages_db" are enabled. The primary focus is testing the behavior of the write_new_messages function, which is expected to handle messages grouped by accounts and determine which messages are new compared to those already saved.

The tests cover scenarios including:

• Empty input message sets.

• Cases where there is no record of the last saved message.

• Cases with partially saved messages.

• Cases where all messages have already been saved.

• Multiple accounts with mixed saved and new messages.

This file is tightly coupled with types and functions such as WrappedMessage, MessageIdentifier, AccountAddress, and the account_inbox::range::MessagesRange structure, which are assumed to be defined elsewhere in the application. It also relies on synchronization primitives like Mutex and collections like BTreeMap and HashMap.

Module: write_new_messages_tests

Purpose

This module defines unit tests verifying the correctness of the write_new_messages function, specifically its ability to filter and return the new messages for accounts based on a tracking map of last saved messages.

Helper Functions

dummy_message

fn dummy_message(id: u64) -> Arc<WrappedMessage>

• Parameters:

  • id: A unique identifier (u64) used to create a dummy WrappedMessage.

• Returns: An Arc wrapped WrappedMessage instance with the provided id.

• Usage: Creates dummy message instances for testing message processing without relying on real message content.

• Implementation Detail: Invokes a presumed method WrappedMessage::dummy_with_id to create the dummy message.

make_range

fn make_range(
    items: Vec<(MessageIdentifier, Arc<WrappedMessage>)>
) -> account_inbox::range::MessagesRange<MessageIdentifier, Arc<WrappedMessage>>

• Parameters:

  • items: A vector of tuples, where each tuple consists of a MessageIdentifier and a corresponding Arc<WrappedMessage>.

• Returns: A MessagesRange object constructed from the provided vector.

• Usage: Converts raw pairs of message identifiers and wrapped messages into a MessagesRange suitable for passing to write_new_messages.

• Implementation Detail: Utilizes MessagesRange::from_vec to create the range.

Test Cases

Each test case uses the helpers above to simulate message data and verifies the behavior of write_new_messages.

test_write_new_messages_empty

• Scenario: Input message map (BTreeMap) is empty.

• Expectation: Result should be an empty map, indicating no new messages to write.

• Assertion: Checks that the returned map from write_new_messages is empty.

test_write_new_messages_no_last_saved

• Scenario: Messages exist for an account, but there is no record of last saved message in the tracking map (m_map).

• Expectation: All messages for the account should be returned as new.

• Assertion: Result contains all messages for the account.

test_write_new_messages_with_last_saved

• Scenario: Some messages for an account have been saved (tracked by m_map), and new messages follow after the last saved message.

• Expectation: Only messages after the last saved message are returned.

• Assertion: Result contains only the new messages following the last saved one.

test_write_new_messages_all_saved

• Scenario: All messages for an account are already saved according to m_map.

• Expectation: No new messages are returned.

• Assertion: Result is empty.

test_write_new_messages_multiple_accounts

• Scenario: Messages for multiple accounts with mixed saved and new messages.

• Expectation: Each account's new messages are correctly identified and returned.

• Assertion: Result map contains the correct subset of new messages for each account.

Important Implementation Details

• Use of Arc: Messages are wrapped in Arc to allow for shared ownership and thread-safe reference counting, indicating concurrent or shared access in the application.

• Synchronization with Mutex: The map tracking last saved messages is protected by a Mutex to ensure safe concurrent access during tests.

• Use of BTreeMap and HashMap: The message batches are stored in a sorted map (BTreeMap) keyed by account addresses, while the last saved message identifiers are stored in a hash map (HashMap) keyed by accounts.

• Message Identification: Messages are identified and compared using the MessageIdentifier type, which is derived from the message content.

• Test Assertions: The tests use Rust’s assert! and assert_eq! macros to ensure the function’s output matches expected results, focusing on the presence, absence, and correctness of returned messages.

Interaction with Other Components

• WrappedMessage: This file depends on the WrappedMessage struct/class, which represents a message entity wrapped for processing.

• MessageIdentifier: Used to uniquely identify messages, critical for comparing new versus saved messages.

• AccountAddress: Represents the account to which messages belong; used as keys in maps.

• account_inbox::range::MessagesRange: A data structure representing a range or collection of messages, supporting conversion from vectors.

• write_new_messages function: Although not defined in this file, this is the central function being tested. It presumably takes the current message ranges per account and a map of last saved message identifiers, returning new messages to be written.

Diagram: Structure of write_new_messages_tests Module

classDiagram
class write_new_messages_tests {
-dummy_message()
-make_range()
+test_write_new_messages_empty()
+test_write_new_messages_no_last_saved()
+test_write_new_messages_with_last_saved()
+test_write_new_messages_all_saved()
+test_write_new_messages_multiple_accounts()
}

This class diagram represents the test module as a container of helper functions and test functions verifying the behavior of the message writing logic. The private helper functions (dummy_message and make_range) facilitate test setup, while the public test functions execute specific test scenarios.