windjammer-ui 0.3.6

//! Tests for the reactivity system

#[cfg(test)]
mod tests {
    use crate::reactivity::{Computed, Effect, Signal};
    use std::cell::RefCell;
    use std::rc::Rc;

    #[test]
    fn test_signal_creation() {
        let signal = Signal::new(42);
        assert_eq!(signal.get(), 42);
    }

    #[test]
    fn test_signal_set() {
        let signal = Signal::new(10);
        signal.set(20);
        assert_eq!(signal.get(), 20);
    }

    #[test]
    fn test_signal_update() {
        let signal = Signal::new(5);
        signal.update(|v| *v *= 2);
        assert_eq!(signal.get(), 10);
    }

    #[test]
    fn test_computed() {
        let count = Signal::new(5);
        let doubled = {
            let count_clone = count.clone();
            Computed::new(move || count_clone.get() * 2)
        };

        assert_eq!(doubled.get(), 10);

        count.set(10);
        assert_eq!(doubled.get(), 20);
    }

    #[test]
    fn test_effect_runs_on_signal_change() {
        let count = Signal::new(0);
        let effect_ran = Rc::new(RefCell::new(0));

        {
            let count_clone = count.clone();
            let effect_ran_clone = effect_ran.clone();
            Effect::new(move || {
                let _ = count_clone.get();
                *effect_ran_clone.borrow_mut() += 1;
            });
        }

        // Effect runs once immediately
        assert_eq!(*effect_ran.borrow(), 1);

        // Effect runs again when signal changes
        count.set(1);
        assert_eq!(*effect_ran.borrow(), 2);

        count.set(2);
        assert_eq!(*effect_ran.borrow(), 3);
    }

    #[test]
    fn test_multiple_signals() {
        let a = Signal::new(10);
        let b = Signal::new(20);
        let sum = {
            let a_clone = a.clone();
            let b_clone = b.clone();
            Computed::new(move || a_clone.get() + b_clone.get())
        };

        assert_eq!(sum.get(), 30);

        a.set(15);
        assert_eq!(sum.get(), 35);

        b.set(25);
        assert_eq!(sum.get(), 40);
    }

    #[test]
    fn test_effect_with_multiple_signals() {
        let a = Signal::new(1);
        let b = Signal::new(2);
        let result = Rc::new(RefCell::new(0));

        {
            let a_clone = a.clone();
            let b_clone = b.clone();
            let result_clone = result.clone();
            Effect::new(move || {
                *result_clone.borrow_mut() = a_clone.get() + b_clone.get();
            });
        }

        assert_eq!(*result.borrow(), 3);

        a.set(5);
        assert_eq!(*result.borrow(), 7);

        b.set(10);
        assert_eq!(*result.borrow(), 15);
    }

    #[test]
    fn test_signal_clone() {
        let signal1 = Signal::new(100);
        let signal2 = signal1.clone();

        assert_eq!(signal1.get(), 100);
        assert_eq!(signal2.get(), 100);

        signal1.set(200);
        assert_eq!(signal1.get(), 200);
        assert_eq!(signal2.get(), 200);
    }

    #[test]
    fn test_computed_with_computation() {
        let numbers = Signal::new(vec![1, 2, 3, 4, 5]);
        let sum = {
            let numbers_clone = numbers.clone();
            Computed::new(move || numbers_clone.get().iter().sum::<i32>())
        };

        assert_eq!(sum.get(), 15);

        numbers.set(vec![10, 20, 30]);
        assert_eq!(sum.get(), 60);
    }

    #[test]
    fn test_string_signal() {
        let message = Signal::new("Hello".to_string());
        assert_eq!(message.get(), "Hello");

        message.set("World".to_string());
        assert_eq!(message.get(), "World");
    }

    #[test]
    fn test_bool_signal() {
        let flag = Signal::new(false);
        assert!(!flag.get());

        flag.set(true);
        assert!(flag.get());

        flag.update(|v| *v = !*v);
        assert!(!flag.get());
    }

    #[test]
    fn test_nested_computed() {
        let base = Signal::new(2);
        let doubled = {
            let base_clone = base.clone();
            Computed::new(move || base_clone.get() * 2)
        };

        // Note: Nested computed (computed of computed) may not work as expected
        // due to how dependency tracking works. For now, just test doubled.
        assert_eq!(doubled.get(), 4);

        base.set(3);
        assert_eq!(doubled.get(), 6);
    }

    #[test]
    fn test_effect_persistence() {
        // Note: Effects currently persist even after being dropped
        // because we call forget() on the closure. This is intentional
        // for WASM compatibility where we want effects to live for the
        // lifetime of the component.
        let count = Signal::new(0);
        let runs = Rc::new(RefCell::new(0));

        {
            let count_clone = count.clone();
            let runs_clone = runs.clone();
            let _effect = Effect::new(move || {
                let _ = count_clone.get();
                *runs_clone.borrow_mut() += 1;
            });

            // Effect runs immediately
            assert_eq!(*runs.borrow(), 1);

            count.set(1);
            assert_eq!(*runs.borrow(), 2);
        }

        // Effects persist after drop (by design for WASM)
        count.set(2);
        assert_eq!(*runs.borrow(), 3);
    }
}