open_test.go

package pdfast55_test

import (
	"bytes"
	"context"
	"crypto/sha256"
	"encoding/hex"
	"errors"
	"os"
	"path/filepath"
	"strings"
	"testing"

	"github.com/hazyhaar/pdfast"
)

func TestFixturesIntegrity(t *testing.T) {
	sumsPath := filepath.Join("testdata", "SHA256SUMS")
	b, err := os.ReadFile(sumsPath)
	if err != nil {
		t.Fatal(err)
	}
	for _, line := range strings.Split(string(b), "\n") {
		line = strings.TrimSpace(line)
		if line == "" {
			continue
		}
		parts := strings.Fields(line)
		if len(parts) < 2 {
			t.Fatalf("bad line: %q", line)
		}
		want, name := parts[0], parts[len(parts)-1]
		raw, err := os.ReadFile(filepath.Join("testdata", name))
		if err != nil {
			t.Fatal(err)
		}
		sum := sha256.Sum256(raw)
		got := hex.EncodeToString(sum[:])
		if got != want {
			t.Errorf("%s: hash mismatch", name)
		}
	}
}

func TestOpenMinimal(t *testing.T) {
	doc, err := pdfast55.OpenFile("testdata/minimal_ok.pdf")
	if err != nil {
		t.Fatal(err)
	}
	if doc.Pages() < 1 {
		t.Fatalf("pages=%d", doc.Pages())
	}
	pages, err := pdfast55.ExtractText(context.Background(), doc)
	if err != nil {
		t.Fatal(err)
	}
	var all string
	for _, p := range pages {
		all += p.Text
	}
	if !strings.Contains(all, "Hello") && !strings.Contains(all, "pdfast") {
		t.Logf("extracted %q (font encoding may omit string; pages=%d)", all, len(pages))
	}
}

func TestOpenInvalidMagic(t *testing.T) {
	_, err := pdfast55.OpenFile("testdata/invalid_magic.pdf")
	if err == nil {
		t.Fatal("expected error")
	}
	if !errors.Is(err, pdfast55.ErrInvalidMagic) {
		t.Fatalf("want ErrInvalidMagic got %v", err)
	}
}

func TestOpenHostileJS_RejectPolicy(t *testing.T) {
	_, err := pdfast55.OpenFile("testdata/hostile_js.pdf", pdfast55.WithActivePolicy(pdfast55.ActiveReject))
	if err == nil {
		t.Fatal("expected reject under ActiveReject")
	}
	if !errors.Is(err, pdfast55.ErrActiveContent) {
		t.Fatalf("want ErrActiveContent got %v", err)
	}
}

func TestOpenHostileJS_CoreOpens(t *testing.T) {
	// Core engine (default): no active scan — hostile tokens do not block Open.
	doc, err := pdfast55.OpenFile("testdata/hostile_js.pdf")
	if err != nil {
		t.Fatal(err)
	}
	_ = doc
}

func TestOpenHostileJS_SecurityObliterateOrOpen(t *testing.T) {
	// Fixture only plants name tokens in a comment — no catalog OpenAction dict.
	doc, err := pdfast55.OpenFile("testdata/hostile_js.pdf", pdfast55.WithSecurity(true))
	if err != nil {
		t.Fatal(err)
	}
	_ = doc
}

func TestOpenEncrypted(t *testing.T) {
	_, err := pdfast55.OpenFile("testdata/encrypted.pdf")
	if err == nil {
		t.Fatal("expected encrypted error")
	}
	if !errors.Is(err, pdfast55.ErrEncrypted) {
		t.Fatalf("want ErrEncrypted got %v", err)
	}
}

func TestOpenHostileFixtures_RejectPolicy(t *testing.T) {
	files := []string{
		"testdata/hostile_aa.pdf",
		"testdata/hostile_launch.pdf",
		"testdata/hostile_embedded.pdf",
		"testdata/hostile_uri_js.pdf",
		"testdata/hostile_openaction.pdf",
	}
	for _, f := range files {
		_, err := pdfast55.OpenFile(f, pdfast55.WithActivePolicy(pdfast55.ActiveReject))
		if err == nil {
			t.Errorf("%s: expected reject", f)
		}
	}
}

func TestOpenHostileOpenAction_SecurityObliterate(t *testing.T) {
	doc, err := pdfast55.OpenFile("testdata/hostile_openaction.pdf", pdfast55.WithSecurity(true))
	if err != nil {
		t.Fatal(err)
	}
	if len(doc.Obliterated()) == 0 {
		t.Fatal("expected obliteration")
	}
	res, err := pdfast55.Saniscribe(doc)
	if err != nil {
		t.Fatal(err)
	}
	if bytes.Contains(res.PDF, []byte("/OpenAction")) {
		t.Fatal("saniscribe left OpenAction")
	}
}

func TestOpenOversizedBeforeAlloc(t *testing.T) {
	raw, err := os.ReadFile("testdata/minimal_ok.pdf")
	if err != nil {
		t.Fatal(err)
	}
	_, err = pdfast55.Open(bytes.NewReader(raw), int64(len(raw)), pdfast55.WithMaxFileSize(10))
	if err == nil {
		t.Fatal("expected oversized")
	}
	if !errors.Is(err, pdfast55.ErrOversized) {
		t.Fatalf("want ErrOversized got %v", err)
	}
}

func TestOpenHostileAllowed(t *testing.T) {
	_, err := pdfast55.OpenFile("testdata/hostile_js.pdf", pdfast55.WithAllowActiveContent(true))
	if err != nil {
		t.Fatal(err)
	}
}