bashrs 6.66.0

/// Test REPRODUCIBLE_003: Detect $RANDOM variable
#[test]
fn test_REPRODUCIBLE_003_detect_random() {
    // ARRANGE: Makefile with $RANDOM
    let makefile = r#"
SESSION_ID := session-$$RANDOM

test:
	echo "Session: $(SESSION_ID)"
"#;
    let ast = crate::make_parser::parser::parse_makefile(makefile).unwrap();

    // ACT: Purify
    let result = purify_makefile(&ast);

    // ASSERT: Should detect $RANDOM
    assert!(
        result.report.iter().any(|r| r.contains("RANDOM")
            || r.contains("random")
            || r.contains("non-deterministic")),
        "Should detect non-deterministic $RANDOM variable"
    );
}

/// Test REPRODUCIBLE_004: Detect process ID $$
#[test]
fn test_REPRODUCIBLE_004_detect_process_id() {
    // ARRANGE: Makefile with process ID
    let makefile = r#"
TMP_FILE := /tmp/build-$$$$

build:
	touch $(TMP_FILE)
	gcc -o app main.c
	rm $(TMP_FILE)
"#;
    let ast = crate::make_parser::parser::parse_makefile(makefile).unwrap();

    // ACT: Purify
    let result = purify_makefile(&ast);

    // ASSERT: Should detect process ID
    assert!(
        result
            .report
            .iter()
            .any(|r| r.contains("process") || r.contains("$$") || r.contains("PID")),
        "Should detect non-deterministic process ID $$"
    );
}

/// Test REPRODUCIBLE_005: Suggest SOURCE_DATE_EPOCH replacement
#[test]
fn test_REPRODUCIBLE_005_suggest_source_date_epoch() {
    // ARRANGE: Makefile with timestamp that should use SOURCE_DATE_EPOCH
    let makefile = r#"
BUILD_DATE := $(shell date)

package:
	echo "Built on: $(BUILD_DATE)" > version.txt
"#;
    let ast = crate::make_parser::parser::parse_makefile(makefile).unwrap();

    // ACT: Purify
    let result = purify_makefile(&ast);

    // ASSERT: Should suggest SOURCE_DATE_EPOCH
    assert!(
        result
            .report
            .iter()
            .any(|r| r.contains("SOURCE_DATE_EPOCH")),
        "Should suggest using SOURCE_DATE_EPOCH for reproducibility"
    );
}

/// Test REPRODUCIBLE_006: Detect non-deterministic command substitution
#[test]
fn test_REPRODUCIBLE_006_detect_command_substitution() {
    // ARRANGE: Makefile with non-deterministic command
    let makefile = r#"
HOSTNAME := $(shell hostname)

config:
	echo "Host: $(HOSTNAME)" > config.txt
"#;
    let ast = crate::make_parser::parser::parse_makefile(makefile).unwrap();

    // ACT: Purify
    let result = purify_makefile(&ast);

    // ASSERT: Should detect hostname (environment-dependent)
    assert!(
        result.report.iter().any(|r| r.contains("hostname")
            || r.contains("environment")
            || r.contains("deterministic")),
        "Should detect environment-dependent hostname"
    );
}

/// Test REPRODUCIBLE_007: Preserve deterministic timestamps
#[test]
fn test_REPRODUCIBLE_007_preserve_deterministic() {
    // ARRANGE: Makefile already using SOURCE_DATE_EPOCH
    let makefile = r#"
BUILD_DATE := $(SOURCE_DATE_EPOCH)

build:
	echo "Build: $(BUILD_DATE)"
"#;
    let ast = crate::make_parser::parser::parse_makefile(makefile).unwrap();

    // ACT: Purify
    let result = purify_makefile(&ast);

    // ASSERT: Should not flag SOURCE_DATE_EPOCH as issue
    // Test passes if purify_makefile runs without panic
    // May still have other transformations, but not for SOURCE_DATE_EPOCH
    let _ = result.transformations_applied; // Verify result exists
}

/// Test REPRODUCIBLE_008: Detect git commit hash timestamp
#[test]
fn test_REPRODUCIBLE_008_detect_git_timestamp() {
    // ARRANGE: Makefile using git commit timestamp
    let makefile = r#"
GIT_DATE := $(shell git log -1 --format=%cd)

version:
	echo "Git date: $(GIT_DATE)" > version.txt
"#;
    let ast = crate::make_parser::parser::parse_makefile(makefile).unwrap();

    // ACT: Purify
    let result = purify_makefile(&ast);

    // ASSERT: Should detect git timestamp
    assert!(
        result
            .report
            .iter()
            .any(|r| r.contains("git") || r.contains("timestamp") || r.contains("deterministic")),
        "Should detect git commit timestamp"
    );
}

/// Test REPRODUCIBLE_009: Detect mktemp usage
#[test]
fn test_REPRODUCIBLE_009_detect_mktemp() {
    // ARRANGE: Makefile using mktemp (non-deterministic temp files)
    let makefile = r#"
build:
	TMP=$$(mktemp); \
	gcc -o $$TMP main.c; \
	cp $$TMP app
"#;
    let ast = crate::make_parser::parser::parse_makefile(makefile).unwrap();

    // ACT: Purify
    let result = purify_makefile(&ast);

    // ASSERT: Should detect mktemp
    assert!(
        result
            .report
            .iter()
            .any(|r| r.contains("mktemp") || r.contains("temp") || r.contains("deterministic")),
        "Should detect non-deterministic mktemp usage"
    );
}

/// Test REPRODUCIBLE_010: Comprehensive reproducibility check
#[test]
fn test_REPRODUCIBLE_010_comprehensive_check() {
    // ARRANGE: Makefile with multiple reproducibility issues
    let makefile = r#"
VERSION := $(shell date +%Y%m%d)
SESSION := $$RANDOM
BUILD_HOST := $(shell hostname)

all: build

build:
	echo "Version: $(VERSION)" > version.txt
	echo "Session: $(SESSION)" >> version.txt
	echo "Host: $(BUILD_HOST)" >> version.txt
	gcc -o app main.c
"#;
    let ast = crate::make_parser::parser::parse_makefile(makefile).unwrap();

    // ACT: Purify
    let result = purify_makefile(&ast);

    // ASSERT: Should detect multiple issues
    assert!(
        result.transformations_applied >= 3,
        "Should detect at least 3 reproducibility issues (date, RANDOM, hostname)"
    );
}

// ========================================
// Sprint 83 - Day 5: Performance Optimization Tests
// ========================================

/// Test PERFORMANCE_001: Detect multiple shell invocations
#[test]
fn test_PERFORMANCE_001_detect_multiple_shell_invocations() {
    // ARRANGE: Makefile with multiple shell commands that could be combined
    let makefile = r#"
build:
	mkdir -p bin
	gcc -c main.c -o bin/main.o
	gcc -c util.c -o bin/util.o
	gcc bin/main.o bin/util.o -o bin/app
"#;
    let ast = crate::make_parser::parser::parse_makefile(makefile).unwrap();

    // ACT: Purify
    let result = purify_makefile(&ast);

    // ASSERT: Should recommend combining shell invocations
    assert!(
        result
            .report
            .iter()
            .any(|r| r.contains("combine") || r.contains("shell") || r.contains("performance")),
        "Should detect multiple shell invocations that could be combined"
    );
}

/// Test PERFORMANCE_002: Suggest using := instead of =
#[test]
fn test_PERFORMANCE_002_suggest_simple_expansion() {
    // ARRANGE: Makefile with recursive variable that could be simple
    let makefile = r#"
CC = gcc
CFLAGS = -Wall -O2
LDFLAGS = -lm

build:
	$(CC) $(CFLAGS) main.c $(LDFLAGS) -o app
"#;
    let ast = crate::make_parser::parser::parse_makefile(makefile).unwrap();

    // ACT: Purify
    let result = purify_makefile(&ast);

    // ASSERT: Should suggest using := for simple variables
    assert!(
        result
            .report
            .iter()
            .any(|r| r.contains(":=") || r.contains("simple") || r.contains("expansion")),
        "Should suggest using := instead of = for simple variables"
    );
}

/// Test PERFORMANCE_003: Detect missing .SUFFIXES
#[test]
fn test_PERFORMANCE_003_detect_missing_suffixes() {
    // ARRANGE: Makefile without .SUFFIXES, with performance issue (recursive var with shell)
    // Note: .SUFFIXES is only recommended when other performance issues are detected
    let makefile = r#"
VERSION = $(shell git describe)

all: app

app: main.o
	gcc main.o -o app

main.o: main.c
	gcc -c main.c
"#;
    let ast = crate::make_parser::parser::parse_makefile(makefile).unwrap();

    // ACT: Purify
    let result = purify_makefile(&ast);

    // ASSERT: Should recommend adding .SUFFIXES (because of VERSION performance issue)
    assert!(
        result
            .report
            .iter()
            .any(|r| r.contains(".SUFFIXES") || r.contains("builtin") || r.contains("performance")),
        "Should recommend adding .SUFFIXES: when performance issues detected"
    );
}

/// Test PERFORMANCE_004: Detect inefficient variable expansion
#[test]
fn test_PERFORMANCE_004_detect_inefficient_expansion() {
    // ARRANGE: Makefile with variable that re-expands $(shell) multiple times
    let makefile = r#"
VERSION = $(shell git describe --tags)

build:
	echo "Building $(VERSION)"
	tar -czf myapp-$(VERSION).tar.gz src/
	echo "Created myapp-$(VERSION).tar.gz"
"#;
    let ast = crate::make_parser::parser::parse_makefile(makefile).unwrap();

    // ACT: Purify
    let result = purify_makefile(&ast);

    // ASSERT: Should suggest using := to avoid re-expansion
    assert!(
        result
            .report
            .iter()
            .any(|r| r.contains(":=") || r.contains("expansion") || r.contains("shell")),
        "Should suggest := to avoid re-expanding $(shell) multiple times"
    );
}

/// Test PERFORMANCE_005: Preserve existing .SUFFIXES
#[test]
fn test_PERFORMANCE_005_preserve_existing_suffixes() {
    // ARRANGE: Makefile already has .SUFFIXES:
    let makefile = r#"
.SUFFIXES:

all: app

app: main.c
	gcc main.c -o app
"#;
    let ast = crate::make_parser::parser::parse_makefile(makefile).unwrap();

    // ACT: Purify
    let result = purify_makefile(&ast);

    // Test passes if purify_makefile runs without panic
    // Should not add duplicate .SUFFIXES
    let _ = result.transformations_applied; // Verify result exists
}

/// Test PERFORMANCE_006: Detect sequential recipe lines
#[test]
fn test_PERFORMANCE_006_detect_sequential_recipes() {
    // ARRANGE: Makefile with many sequential recipe lines
    let makefile = r#"
install:
	mkdir -p /usr/local/bin
	cp app /usr/local/bin/
	chmod +x /usr/local/bin/app
	mkdir -p /usr/local/share/doc/app
	cp README.md /usr/local/share/doc/app/
"#;
    let ast = crate::make_parser::parser::parse_makefile(makefile).unwrap();

    // ACT: Purify
    let result = purify_makefile(&ast);

    // ASSERT: Should suggest combining with && or ;
    assert!(
        result
            .report
            .iter()
            .any(|r| r.contains("combine") || r.contains("&&") || r.contains("performance")),
        "Should suggest combining sequential recipe lines"
    );
}


include!("tests_tests_performance_.rs");