// SPDX-FileCopyrightText: 2026 Echolot contributors
// SPDX-License-Identifier: GPL-3.0-or-later

package relsign

import (
	"strings"
	"testing"
)

func TestRoundTrip(t *testing.T) {
	pub, seed, err := GenerateKey()
	if err != nil {
		t.Fatal(err)
	}
	data := []byte("abc123  echolot-server_linux_amd64\n")
	sig, err := Sign(seed, data)
	if err != nil {
		t.Fatal(err)
	}
	if err := Verify(pub, data, sig); err != nil {
		t.Fatalf("a signature this package just made must verify: %v", err)
	}
}

func TestAlteredContentIsRefused(t *testing.T) {
	// The attack this exists for: same length, one checksum swapped for another.
	pub, seed, _ := GenerateKey()
	sig, _ := Sign(seed, []byte("aaa  echolot-server_linux_amd64\n"))
	if err := Verify(pub, []byte("bbb  echolot-server_linux_amd64\n"), sig); err == nil {
		t.Fatal("altered content must not verify")
	}
}

func TestWrongKeyIsRefused(t *testing.T) {
	// A compromised release host can re-sign with its own key; only ours may pass.
	pub1, _, _ := GenerateKey()
	_, seed2, _ := GenerateKey()
	data := []byte("payload")
	sig, _ := Sign(seed2, data)
	if err := Verify(pub1, data, sig); err == nil {
		t.Fatal("a signature from a different key must not verify")
	}
}

func TestSurroundingWhitespaceIsTolerated(t *testing.T) {
	// Keys travel through env vars and files; a trailing newline must not break verification.
	pub, seed, _ := GenerateKey()
	data := []byte("data")
	sig, err := Sign("  "+seed+"\n", data)
	if err != nil {
		t.Fatal(err)
	}
	if err := Verify(pub+"\n", data, "\t"+sig+"\n"); err != nil {
		t.Fatalf("whitespace around base64 must be tolerated: %v", err)
	}
}

func TestGarbageInputsFailCleanly(t *testing.T) {
	pub, seed, _ := GenerateKey()
	if _, err := Sign("not base64!!", []byte("x")); err == nil || !strings.Contains(err.Error(), "base64") {
		t.Fatalf("bad seed must name the problem, got %v", err)
	}
	if _, err := Sign("c2hvcnQ=", []byte("x")); err == nil {
		t.Fatal("short seed must be refused")
	}
	if err := Verify("c2hvcnQ=", []byte("x"), "AAAA"); err == nil {
		t.Fatal("short public key must be refused")
	}
	if err := Verify(pub, []byte("x"), "not base64!!"); err == nil {
		t.Fatal("bad signature encoding must be refused")
	}
	_ = seed
}