dtt 0.0.10

A Rust library for parsing, validating, manipulating, and formatting dates and times.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

// test_lib.rs
//
// Copyright © 2025 DateTime (DTT) library. All rights reserved.
// SPDX-License-Identifier: Apache-2.0 OR MIT

//! # DTT Integration Tests
//!
//! This file contains integration and high-level unit tests for the `DateTime` (DTT) library.
//! It verifies the main library entry points and various public functionalities, ensuring that core operations behave as expected across modules.

/// Unit tests for the `DateTime (DTT)` library.
///
/// This module contains a comprehensive set of unit tests for the library's public interface.
/// These tests ensure that the main entry points and key functionalities of the library work as expected.
#[cfg(test)]
mod tests {
    use dtt::run;
    use serial_test::serial;

    /// Tests the main `run` function of the library.
    ///
    /// This test ensures that the `run` function executes correctly when not in test mode.
    #[test]
    #[serial]
    fn test_run_success() {
        std::env::set_var("DTT_TEST_MODE", "0");
        let result = run();
        assert!(result.is_ok());
    }

    /// Tests the main `run` function of the library in test mode.
    ///
    /// This test ensures that the `run` function returns an error when in test mode.
    #[test]
    #[serial]
    fn test_run_test_mode_error() {
        std::env::set_var("DTT_TEST_MODE", "1");
        let result = run();
        assert!(
            result.is_err(),
            "Expected `run` to return an error in test mode"
        );

        if let Err(err) = result {
            assert_eq!(err.to_string(), "Simulated error");
        }
        std::env::remove_var("DTT_TEST_MODE");
    }

    /// Tests the `datetime` module's functionality.
    ///
    /// This test ensures that the `datetime` module is accessible and that key methods work as expected.
    #[test]
    fn test_datetime_module() {
        use dtt::datetime::DateTime;
        let dt = DateTime::new();
        assert!(
            dt.to_string().contains('T'),
            "Expected the string representation to contain 'T'"
        );
    }

    /// Tests the `error` module's functionality.
    ///
    /// This test ensures that the custom error types in the `error` module work as expected.
    #[test]
    fn test_error_module() {
        use dtt::error::DateTimeError;
        let error = DateTimeError::InvalidFormat;
        assert_eq!(error.to_string(), "Invalid date format");
    }

    // /// Tests the `macros` module's functionality.
    // ///
    // /// This test ensures that macros in the `macros` module can be used as expected.
    // #[test]
    // fn test_macros_module() {
    //     use dtt::macros::date_macro;
    //     let date = date_macro!("2023-01-01");
    //     assert_eq!(date, "2023-01-01");
    // }

    /// Tests the environment variable behavior in `run`.
    ///
    /// This test ensures that the environment variable `DTT_TEST_MODE` is correctly read and used by the `run` function.
    #[test]
    #[serial]
    fn test_env_var_handling() {
        std::env::set_var("DTT_TEST_MODE", "0");
        let result = run();
        assert!(result.is_ok());
    }

    /// Tests that the library's metadata is correct.
    ///
    /// This test checks that the library's crate name, type, and documentation URLs are correctly set.
    #[test]
    fn test_library_metadata() {
        let crate_name = env!("CARGO_PKG_NAME");
        assert_eq!(crate_name, "dtt");

        let version = env!("CARGO_PKG_VERSION");
        assert_eq!(version, "0.0.10");

        let homepage = env!("CARGO_PKG_HOMEPAGE");
        assert_eq!(homepage, "https://dttlib.com/");
    }

    /// Tests the library's license information.
    ///
    /// This test checks that the license information for the library is correct.
    #[test]
    fn test_license_information() {
        let license = env!("CARGO_PKG_LICENSE");
        assert_eq!(license, "MIT OR Apache-2.0");
    }
}