sfx_integration_test.go

package main

import (
	"bytes"
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"runtime"
	"testing"
	"time"
)

func TestSFXBuildAndPathResolution(t *testing.T) {
	if runtime.GOARCH != "amd64" {
		t.Skip("SFX build is only supported on x64 (amd64) architecture")
	}

	// Skip if strictly running unit tests without build capabilities or no go compiler
	if _, err := exec.LookPath("go"); err != nil {
		t.Skip("go compiler not found, skipping SFX integration test")
	}

	// Setup temporary directory
	tempDir, err := os.MkdirTemp("", "fastfinder_sfx_test")
	if err != nil {
		t.Fatal(err)
	}
	defer os.RemoveAll(tempDir)

	// Create a dummy YARA rule in a subfolder to test relative paths
	rulesDir := filepath.Join(tempDir, "rules")
	err = os.Mkdir(rulesDir, 0755)
	if err != nil {
		t.Fatal(err)
	}

	ruleContent := `
rule TestRule {
	strings:
		$a = "FindMeInSFX"
	condition:
		$a
}`
	rulePath := filepath.Join(rulesDir, "test.yar")
	err = os.WriteFile(rulePath, []byte(ruleContent), 0644)
	if err != nil {
		t.Fatal(err)
	}

	// Create a matching file to scan
	targetFile := filepath.Join(tempDir, "target.txt")
	err = os.WriteFile(targetFile, []byte("This file contains the string FindMeInSFX and should be detected."), 0644)
	if err != nil {
		t.Fatal(err)
	}

	//  Create configuration file using relative path for YARA
	targetPathSlash := filepath.ToSlash(targetFile)
	configContent := fmt.Sprintf(`
input:
  path:
    - "%s"
  content:
    yara:
      - "./rules/test.yar"
options:
  contentMatchDependsOnPathMatch: false
output:
  copyMatchingFiles: false
  base64Files: false
  filesCopyPath: ""
`, targetPathSlash)

	configPath := filepath.Join(tempDir, "config.yaml")
	err = os.WriteFile(configPath, []byte(configContent), 0644)
	if err != nil {
		t.Fatal(err)
	}

	// Build fastfinder itself first (the builder)
	builderExe := filepath.Join(tempDir, "fastfinder_builder.exe")
	if runtime.GOOS != "windows" {
		builderExe = filepath.Join(tempDir, "fastfinder_builder")
	}

	// We compile the current package "."
	t.Log("Building fastfinder builder...")
	cmdBuild := exec.Command("go", "build", "-tags", "yara_static", "-o", builderExe, ".")
	if out, err := cmdBuild.CombinedOutput(); err != nil {
		t.Logf("Build failed: %s\n", string(out))
		t.Fatalf("Failed to build fastfinder builder: %v\nOutput: %s", err, string(out))
	}
	t.Log("Builder built.")

	// Run the builder to create the SFX
	sfxExe := filepath.Join(tempDir, "sfx_result.exe")
	if runtime.GOOS != "windows" {
		sfxExe = filepath.Join(tempDir, "sfx_result")
	}

	cmdSFX := exec.Command(builderExe, "-c", configPath, "-b", sfxExe)
	t.Log("Running builder to create SFX...")
	if out, err := cmdSFX.CombinedOutput(); err != nil {
		t.Logf("SFX creation failed: %s\n", string(out))
		t.Fatalf("Failed to run fastfinder builder to create SFX: %v\nOutput: %s", err, string(out))
	}
	t.Log("SFX created.")

	// Give OS time to release handle
	time.Sleep(500 * time.Millisecond)

	systemTemp := os.TempDir()
	// extractedBinary := "fastfinder"
	extractionSubDir := "fastfinder" // Linux default

	if runtime.GOOS == "windows" {
		// extractedBinary = "fastfinder.exe"
		extractionSubDir = "FastFinder"
	}

	extractionRoot := filepath.Join(systemTemp, extractionSubDir)
	// extractedPath := filepath.Join(extractionRoot, extractedBinary)

	if err := os.RemoveAll(extractionRoot); err != nil && !os.IsNotExist(err) {
		t.Logf("Warning: Failed to remove previous extraction directory: %v", err)
	}

	if _, err := os.Stat(sfxExe); os.IsNotExist(err) {
		t.Fatalf("SFX executable was not created at %s", sfxExe)
	}
	
	// Ensure SFX is executable on Linux/Unix
	if runtime.GOOS != "windows" {
		if err := os.Chmod(sfxExe, 0755); err != nil {
			t.Fatalf("Failed to make SFX executable: %v", err)
		}
	}

	// Run the SFX executable checking for immediate crash
	cmdRunSFX := exec.Command(sfxExe, "-r", tempDir)
	var outBuf bytes.Buffer
	cmdRunSFX.Stdout = &outBuf
	cmdRunSFX.Stderr = &outBuf

	if err := cmdRunSFX.Start(); err != nil {
		t.Fatalf("Failed to start SFX: %v", err)
	}

	// Wait for 2 seconds
	done := make(chan error, 1)
	go func() {
		done <- cmdRunSFX.Wait()
	}()

	select {
	case <-time.After(2 * time.Second):
		// It's still running after 2 seconds. valid behavior.
		if err := cmdRunSFX.Process.Kill(); err != nil {
			t.Logf("Failed to kill SFX: %v", err)
		}
		t.Log("SFX ran for 2 seconds without crashing. Test passed.")
	case err := <-done:
		// Exited before 2 seconds.
		// If exit code is 0, success. If != 0, crash.
		if err != nil {
			t.Fatalf("SFX exited with error: %v. Output:\n%s", err, outBuf.String())
		}
		t.Log("SFX finished successfully within 2 seconds.")
	}
}