Janady13/missionmatch / cmd/opportunity-extract/uivocab_test.go

Source identity

Field	Recorded value
Source type	GitHub source
Original record	Janady13/missionmatch / cmd/opportunity-extract/uivocab_test.go
Date	Not specified in source
Repository	Janady13/missionmatch
Revision	720d47fae476b0d38477ae4401697d372b1ea2bc
Branch	feature/opportunity-to-outcome
Path or archive member	cmd/opportunity-extract/uivocab_test.go
Original SHA-256	50855287b615146c6a0401383bb3e2982d97780422510ed9bc11817dad857f4b
Git blob SHA	87edbb88915aa017b3605cd1747eb19b2322ac47
Reading-copy SHA-256	50855287b615146c6a0401383bb3e2982d97780422510ed9bc11817dad857f4b

Original source ↗

Recovered source transcript

Download complete source text ↓123 lines · 4.3 KB

package main

import (
	"os"
	"regexp"
	"sort"
	"strings"
	"testing"
)

// A CROSS LANGUAGE CONTRACT TEST. The extractor writes a CLOSED vocabulary of failure codes into
// extraction_error_code, and the Documents screen turns each one into a sentence a reviewer can act on. Those two
// lists live in different languages and nothing connected them, so they drifted.
//
// WHEN THIS WAS FIRST RUN, THREE OF THE SIX UI KEYS MATCHED NOTHING: 'malformed', 'empty' and
// 'unsupported_media_type' were never emitted by any code path, while FOUR codes that are emitted had no
// explanation at all. One of the four was unsupported_format, which is the status the xlsx attachment in Package
// A actually carries, so the single document an owner decision was written about rendered a bare code and no
// sentence.
//
// A DEAD KEY IS INVISIBLE AND A MISSING KEY IS WORSE. A dead key costs nothing and hides the fact that nobody
// checked. A missing key means the product shows a reviewer a raw enum where it promised an explanation, which is
// the same class of defect as a status that is technically correct and practically useless.
//
// The test reads the TSX rather than duplicating the list, because a duplicated list is the thing that drifted.

const documentsScreen = "../../frontend/src/tools/slatematch/Documents.tsx"

func TestUIExplainsEveryExtractionFailureCodeAndInventsNone(t *testing.T) {
	raw, err := os.ReadFile(documentsScreen)
	if err != nil {
		t.Fatalf("reading the Documents screen: %v. If this file moved, the contract moved with it and this "+
			"test must be pointed at the new path rather than deleted.", err)
	}
	src := string(raw)

	start := strings.Index(src, "const REASONS")
	if start < 0 {
		t.Fatal("no REASONS map in the Documents screen. If the explanations moved, point this test at them.")
	}
	// The map body ends at the first line that is exactly a closing brace.
	rest := src[start:]
	end := strings.Index(rest, "\n}")
	if end < 0 {
		t.Fatal("could not find the end of the REASONS map")
	}
	body := rest[:end]

	keyRe := regexp.MustCompile(`(?m)^\s{2}([a-z_]+):`)
	uiKeys := map[string]bool{}
	for _, m := range keyRe.FindAllStringSubmatch(body, -1) {
		uiKeys[m[1]] = true
	}
	if len(uiKeys) == 0 {
		t.Fatal("parsed zero keys out of the REASONS map, so this test would pass while checking nothing")
	}

	// THE SOURCE OF TRUTH is the Go vocabulary, declared as constants in this package.
	goCodes := map[string]bool{
		errBytesMissing: true,
		errEmpty:        true,
		errTooLarge:     true,
		errEncrypted:    true,
		errUnsupported:  true,
		errNoTextLayer:  true,
		errNoChunks:     true,
	}

	var missing, dead []string
	for code := range goCodes {
		if !uiKeys[code] {
			missing = append(missing, code)
		}
	}
	for key := range uiKeys {
		if !goCodes[key] {
			dead = append(dead, key)
		}
	}
	sort.Strings(missing)
	sort.Strings(dead)

	if len(missing) > 0 {
		t.Errorf("extraction codes with NO explanation in the UI: %v. A reviewer sees a bare enum where the "+
			"product promised a sentence.", missing)
	}
	if len(dead) > 0 {
		t.Errorf("UI explanations for codes nothing emits: %v. Harmless in itself, and evidence that the two "+
			"lists are not being checked against each other.", dead)
	}
	t.Logf("%d codes, %d explanations, exact match", len(goCodes), len(uiKeys))
}

// The no_text_layer sentence must cover BOTH causes. It described only a scanned image, which is not the case
// this build actually meets: the SCA wage determination HAS a text layer and it cannot be decoded. A status whose
// explanation names the wrong cause sends a reviewer looking for a scanner.
func TestNoTextLayerExplanationCoversAnUndecodableLayerNotOnlyAScan(t *testing.T) {
	raw, err := os.ReadFile(documentsScreen)
	if err != nil {
		t.Skipf("Documents screen unreadable: %v", err)
	}
	src := strings.ToLower(string(raw))
	i := strings.Index(src, "no_text_layer:")
	if i < 0 {
		t.Fatal("no_text_layer has no explanation at all")
	}
	// Look at the sentence that follows the key.
	window := src[i:min(i+700, len(src))]
	for _, want := range []string{"scanned", "decode", "character map"} {
		if !strings.Contains(window, want) {
			t.Errorf("the no_text_layer explanation does not mention %q, so it describes only one of the two "+
				"ways a document reaches this status", want)
		}
	}
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}