465 lines
16 KiB
Go
465 lines
16 KiB
Go
package modules_test
|
|
|
|
import (
|
|
"fmt"
|
|
"go/parser"
|
|
"go/token"
|
|
"io/fs"
|
|
"path/filepath"
|
|
"runtime"
|
|
"strconv"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
const moduleImportPrefix = "gitea.maximumdirect.net/eric/notarius/internal/modules/"
|
|
|
|
func TestProductionImportBoundaries(t *testing.T) {
|
|
repositoryRoot := testRepositoryRoot(t)
|
|
err := filepath.WalkDir(repositoryRoot, func(path string, entry fs.DirEntry, walkErr error) error {
|
|
if walkErr != nil {
|
|
return walkErr
|
|
}
|
|
if entry.IsDir() {
|
|
if entry.Name() == ".git" || entry.Name() == "testdata" || entry.Name() == "vendor" {
|
|
return filepath.SkipDir
|
|
}
|
|
return nil
|
|
}
|
|
if filepath.Ext(path) != ".go" {
|
|
return nil
|
|
}
|
|
return checkImportBoundaries(repositoryRoot, path)
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestImportBoundaryFixtureIsRejected(t *testing.T) {
|
|
repositoryRoot := testRepositoryRoot(t)
|
|
fixture := filepath.Join(repositoryRoot, "internal", "modules", "generic", "testdata", "importboundaries", "imports_dnd.go")
|
|
err := checkImportBoundaries(repositoryRoot, fixture)
|
|
if err == nil {
|
|
t.Fatal("fixture import was accepted, want generic-to-concrete violation")
|
|
}
|
|
if !strings.Contains(err.Error(), "generic family must not import concrete family") {
|
|
t.Fatalf("fixture error = %q, want generic-to-concrete violation", err)
|
|
}
|
|
}
|
|
|
|
func TestImportBoundaryRules(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
filename string
|
|
sourcePackage string
|
|
importPath string
|
|
wantError bool
|
|
}{
|
|
{
|
|
name: "concrete implementation cannot import peer concrete family",
|
|
filename: "internal/modules/dnd/extract/example/extractor.go",
|
|
sourcePackage: "example",
|
|
importPath: moduleImportPrefix + "seriatim/input/transcript",
|
|
wantError: true,
|
|
},
|
|
{
|
|
name: "future concrete family cannot import current concrete family",
|
|
filename: "internal/modules/almanac/extract/example/extractor.go",
|
|
sourcePackage: "example",
|
|
importPath: moduleImportPrefix + "dnd/shared",
|
|
wantError: true,
|
|
},
|
|
{
|
|
name: "current concrete family cannot import future concrete family",
|
|
filename: "internal/modules/seriatim/input/example/adapter.go",
|
|
sourcePackage: "example",
|
|
importPath: moduleImportPrefix + "almanac/shared",
|
|
wantError: true,
|
|
},
|
|
{
|
|
name: "generic implementation cannot import current concrete family",
|
|
filename: "internal/modules/generic/merge/example/merger.go",
|
|
sourcePackage: "example",
|
|
importPath: moduleImportPrefix + "dnd/shared",
|
|
wantError: true,
|
|
},
|
|
{
|
|
name: "generic implementation cannot import future concrete family",
|
|
filename: "internal/modules/generic/merge/example/merger.go",
|
|
sourcePackage: "example",
|
|
importPath: moduleImportPrefix + "almanac/shared",
|
|
wantError: true,
|
|
},
|
|
{
|
|
name: "concrete implementation cannot import generic implementation",
|
|
filename: "internal/modules/dnd/extract/example/extractor.go",
|
|
sourcePackage: "example",
|
|
importPath: moduleImportPrefix + "generic/normalize/noop",
|
|
wantError: true,
|
|
},
|
|
{
|
|
name: "concrete white-box test follows production rules",
|
|
filename: "internal/modules/dnd/extract/example/extractor_test.go",
|
|
sourcePackage: "example",
|
|
importPath: moduleImportPrefix + "generic/normalize/noop",
|
|
wantError: true,
|
|
},
|
|
{
|
|
name: "concrete registrar may compose generic implementation",
|
|
filename: "internal/modules/almanac/register/register.go",
|
|
sourcePackage: "register",
|
|
importPath: moduleImportPrefix + "generic/normalize/noop",
|
|
},
|
|
{
|
|
name: "family root cannot import child implementation",
|
|
filename: "internal/modules/almanac/types.go",
|
|
sourcePackage: "almanac",
|
|
importPath: moduleImportPrefix + "almanac/extract/events",
|
|
wantError: true,
|
|
},
|
|
{
|
|
name: "family root cannot import registrar",
|
|
filename: "internal/modules/almanac/types.go",
|
|
sourcePackage: "almanac",
|
|
importPath: moduleImportPrefix + "almanac/register",
|
|
wantError: true,
|
|
},
|
|
{
|
|
name: "child may import family root",
|
|
filename: "internal/modules/almanac/extract/events/extractor.go",
|
|
sourcePackage: "events",
|
|
importPath: moduleImportPrefix + "almanac",
|
|
},
|
|
{
|
|
name: "child may import same-family sibling",
|
|
filename: "internal/modules/almanac/extract/events/extractor.go",
|
|
sourcePackage: "events",
|
|
importPath: moduleImportPrefix + "almanac/shared",
|
|
},
|
|
{
|
|
name: "concrete registrar may compose own child",
|
|
filename: "internal/modules/almanac/register/register.go",
|
|
sourcePackage: "register",
|
|
importPath: moduleImportPrefix + "almanac/extract/events",
|
|
},
|
|
{
|
|
name: "generic registrar may compose generic child",
|
|
filename: "internal/modules/generic/register/register.go",
|
|
sourcePackage: "register",
|
|
importPath: moduleImportPrefix + "generic/output/json",
|
|
},
|
|
{
|
|
name: "application composition root may compose registrars",
|
|
filename: "internal/cli/catalog.go",
|
|
sourcePackage: "cli",
|
|
importPath: moduleImportPrefix + "almanac/register",
|
|
},
|
|
{
|
|
name: "production CLI cannot import family root",
|
|
filename: "internal/cli/catalog.go",
|
|
sourcePackage: "cli",
|
|
importPath: moduleImportPrefix + "almanac",
|
|
wantError: true,
|
|
},
|
|
{
|
|
name: "production CLI cannot import concrete leaf",
|
|
filename: "internal/cli/catalog.go",
|
|
sourcePackage: "cli",
|
|
importPath: moduleImportPrefix + "almanac/extract/events",
|
|
wantError: true,
|
|
},
|
|
{
|
|
name: "production CLI cannot import generic leaf",
|
|
filename: "internal/cli/catalog.go",
|
|
sourcePackage: "cli",
|
|
importPath: moduleImportPrefix + "generic/output/json",
|
|
wantError: true,
|
|
},
|
|
{
|
|
name: "production CLI cannot import non-registrar package",
|
|
filename: "internal/cli/catalog.go",
|
|
sourcePackage: "cli",
|
|
importPath: moduleImportPrefix + "almanac/register/helpers",
|
|
wantError: true,
|
|
},
|
|
{
|
|
name: "CLI test may import concrete leaf",
|
|
filename: "internal/cli/compatibility_test.go",
|
|
sourcePackage: "cli",
|
|
importPath: moduleImportPrefix + "almanac/extract/events",
|
|
},
|
|
{
|
|
name: "command production cannot import registrar",
|
|
filename: "cmd/notarius/main.go",
|
|
sourcePackage: "main",
|
|
importPath: moduleImportPrefix + "almanac/register",
|
|
wantError: true,
|
|
},
|
|
{
|
|
name: "command production cannot import concrete leaf",
|
|
filename: "cmd/notarius/main.go",
|
|
sourcePackage: "main",
|
|
importPath: moduleImportPrefix + "almanac/extract/events",
|
|
wantError: true,
|
|
},
|
|
{
|
|
name: "unknown production package cannot import concrete leaf",
|
|
filename: "internal/application/bootstrap.go",
|
|
sourcePackage: "application",
|
|
importPath: moduleImportPrefix + "almanac/extract/events",
|
|
wantError: true,
|
|
},
|
|
{
|
|
name: "unknown production package cannot import registrar",
|
|
filename: "internal/application/bootstrap.go",
|
|
sourcePackage: "application",
|
|
importPath: moduleImportPrefix + "almanac/register",
|
|
wantError: true,
|
|
},
|
|
{
|
|
name: "unknown test package is not a compatibility root",
|
|
filename: "internal/application/bootstrap_test.go",
|
|
sourcePackage: "application",
|
|
importPath: moduleImportPrefix + "almanac/extract/events",
|
|
wantError: true,
|
|
},
|
|
{
|
|
name: "framework production cannot import concrete module",
|
|
filename: "internal/framework/pipeline/runner.go",
|
|
sourcePackage: "pipeline",
|
|
importPath: moduleImportPrefix + "almanac/extract/events",
|
|
wantError: true,
|
|
},
|
|
{
|
|
name: "framework production cannot import generic module",
|
|
filename: "internal/framework/pipeline/runner.go",
|
|
sourcePackage: "pipeline",
|
|
importPath: moduleImportPrefix + "generic/normalize/noop",
|
|
wantError: true,
|
|
},
|
|
{
|
|
name: "core production cannot import concrete module",
|
|
filename: "internal/core/source/source.go",
|
|
sourcePackage: "source",
|
|
importPath: moduleImportPrefix + "almanac",
|
|
wantError: true,
|
|
},
|
|
{
|
|
name: "core production cannot import generic module",
|
|
filename: "internal/core/source/source.go",
|
|
sourcePackage: "source",
|
|
importPath: moduleImportPrefix + "generic/chunk/units",
|
|
wantError: true,
|
|
},
|
|
{
|
|
name: "framework test may import module implementation",
|
|
filename: "internal/framework/pipeline/compatibility_test.go",
|
|
sourcePackage: "pipeline",
|
|
importPath: moduleImportPrefix + "generic/chunk/units",
|
|
},
|
|
{
|
|
name: "core test may import module implementation",
|
|
filename: "internal/core/source/compatibility_test.go",
|
|
sourcePackage: "source",
|
|
importPath: moduleImportPrefix + "almanac",
|
|
},
|
|
{
|
|
name: "module production cannot import integration infrastructure",
|
|
filename: "internal/modules/almanac/register/register.go",
|
|
sourcePackage: "register",
|
|
importPath: moduleImportPrefix + "integration",
|
|
wantError: true,
|
|
},
|
|
{
|
|
name: "non-module production cannot import integration infrastructure",
|
|
filename: "cmd/notarius/main.go",
|
|
sourcePackage: "main",
|
|
importPath: moduleImportPrefix + "integration/helpers",
|
|
wantError: true,
|
|
},
|
|
{
|
|
name: "test may import integration infrastructure",
|
|
filename: "internal/cli/compatibility_test.go",
|
|
sourcePackage: "cli",
|
|
importPath: moduleImportPrefix + "integration",
|
|
},
|
|
{
|
|
name: "black-box integration test may compose families",
|
|
filename: "internal/modules/integration/example_test.go",
|
|
sourcePackage: "integration_test",
|
|
importPath: moduleImportPrefix + "almanac/extract/events",
|
|
},
|
|
{
|
|
name: "white-box integration test is not exempt",
|
|
filename: "internal/modules/integration/example_test.go",
|
|
sourcePackage: "integration",
|
|
importPath: moduleImportPrefix + "almanac/extract/events",
|
|
wantError: true,
|
|
},
|
|
{
|
|
name: "integration production file is not exempt",
|
|
filename: "internal/modules/integration/example.go",
|
|
sourcePackage: "integration",
|
|
importPath: moduleImportPrefix + "almanac/extract/events",
|
|
wantError: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
err := validateImport(tt.filename, tt.sourcePackage, tt.importPath)
|
|
if tt.wantError && err == nil {
|
|
t.Fatal("validateImport() error = nil, want boundary violation")
|
|
}
|
|
if tt.wantError && (!strings.Contains(err.Error(), tt.filename) || !strings.Contains(err.Error(), tt.importPath)) {
|
|
t.Fatalf("validateImport() error = %q, want importing file and import target", err)
|
|
}
|
|
if !tt.wantError && err != nil {
|
|
t.Fatalf("validateImport() error = %v, want nil", err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func checkImportBoundaries(repositoryRoot string, filename string) error {
|
|
parsed, err := parser.ParseFile(token.NewFileSet(), filename, nil, parser.ImportsOnly)
|
|
if err != nil {
|
|
return fmt.Errorf("parse %s: %w", filename, err)
|
|
}
|
|
relative, err := filepath.Rel(repositoryRoot, filename)
|
|
if err != nil {
|
|
return fmt.Errorf("resolve relative path for %s: %w", filename, err)
|
|
}
|
|
relative = filepath.ToSlash(relative)
|
|
for _, imported := range parsed.Imports {
|
|
importPath, err := strconv.Unquote(imported.Path.Value)
|
|
if err != nil {
|
|
return fmt.Errorf("parse import in %s: %w", relative, err)
|
|
}
|
|
if err := validateImport(relative, parsed.Name.Name, importPath); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func validateImport(filename string, sourcePackage string, importPath string) error {
|
|
target, ok := moduleTargetForImport(importPath)
|
|
if !ok {
|
|
return nil
|
|
}
|
|
isTest := strings.HasSuffix(filename, "_test.go")
|
|
if target.integration && !isTest {
|
|
return importBoundaryViolation(filename, importPath, "module integration infrastructure is not a production dependency target")
|
|
}
|
|
if isIntegrationFile(filename) {
|
|
if isBlackBoxIntegrationTest(filename, sourcePackage) {
|
|
return nil
|
|
}
|
|
return importBoundaryViolation(filename, importPath, "module integration composition is allowed only in black-box tests")
|
|
}
|
|
sourceFamily, sourceRoot, sourceRegistrar := moduleFamilyForFile(filename)
|
|
if sourceFamily != "" {
|
|
if sourceRoot && sourceFamily == target.family && target.child {
|
|
return importBoundaryViolation(filename, importPath, "family root must not import child packages")
|
|
}
|
|
if sourceFamily == target.family {
|
|
return nil
|
|
}
|
|
if sourceFamily == "generic" {
|
|
return importBoundaryViolation(filename, importPath, fmt.Sprintf("generic family must not import concrete family %q", target.family))
|
|
}
|
|
if target.family == "generic" {
|
|
if sourceRegistrar {
|
|
return nil
|
|
}
|
|
return importBoundaryViolation(filename, importPath, fmt.Sprintf("concrete family %q may import generic implementations only from its registrar", sourceFamily))
|
|
}
|
|
return importBoundaryViolation(filename, importPath, fmt.Sprintf("concrete family %q must not import concrete family %q", sourceFamily, target.family))
|
|
}
|
|
if isTest {
|
|
if isCompatibilityTestFile(filename) {
|
|
return nil
|
|
}
|
|
return importBoundaryViolation(filename, importPath, "direct module imports from non-module tests are allowed only in CLI, core, and framework compatibility-test roots")
|
|
}
|
|
if strings.HasPrefix(filename, "internal/framework/") || strings.HasPrefix(filename, "internal/core/") {
|
|
return importBoundaryViolation(filename, importPath, "core and framework production code must not import module implementations")
|
|
}
|
|
if strings.HasPrefix(filename, "internal/cli/") {
|
|
if target.registrar {
|
|
return nil
|
|
}
|
|
return importBoundaryViolation(filename, importPath, "CLI production code may import only exact module family registrar packages")
|
|
}
|
|
return importBoundaryViolation(filename, importPath, "production code outside module families may import modules only from the CLI composition root through exact registrar packages")
|
|
}
|
|
|
|
type moduleImportTarget struct {
|
|
family string
|
|
child bool
|
|
registrar bool
|
|
integration bool
|
|
}
|
|
|
|
func moduleTargetForImport(importPath string) (moduleImportTarget, bool) {
|
|
if !strings.HasPrefix(importPath, moduleImportPrefix) {
|
|
return moduleImportTarget{}, false
|
|
}
|
|
remainder := strings.TrimPrefix(importPath, moduleImportPrefix)
|
|
parts := strings.Split(remainder, "/")
|
|
if len(parts) == 0 || parts[0] == "" {
|
|
return moduleImportTarget{}, false
|
|
}
|
|
return moduleImportTarget{
|
|
family: parts[0],
|
|
child: len(parts) > 1,
|
|
registrar: len(parts) == 2 && parts[1] == "register",
|
|
integration: parts[0] == "integration",
|
|
}, true
|
|
}
|
|
|
|
func importBoundaryViolation(filename string, importPath string, rule string) error {
|
|
return fmt.Errorf("import boundary violation: %s imports %s: %s", filename, importPath, rule)
|
|
}
|
|
|
|
func moduleFamilyForFile(filename string) (family string, root bool, registrar bool) {
|
|
const prefix = "internal/modules/"
|
|
if !strings.HasPrefix(filename, prefix) {
|
|
return "", false, false
|
|
}
|
|
remainder := strings.TrimPrefix(filename, prefix)
|
|
parts := strings.Split(remainder, "/")
|
|
if len(parts) < 2 || parts[0] == "integration" {
|
|
return "", false, false
|
|
}
|
|
return parts[0], len(parts) == 2, len(parts) > 2 && parts[1] == "register"
|
|
}
|
|
|
|
func isIntegrationFile(filename string) bool {
|
|
return strings.HasPrefix(filename, "internal/modules/integration/")
|
|
}
|
|
|
|
func isBlackBoxIntegrationTest(filename string, sourcePackage string) bool {
|
|
return isIntegrationFile(filename) && strings.HasSuffix(filename, "_test.go") && sourcePackage == "integration_test"
|
|
}
|
|
|
|
func isCompatibilityTestFile(filename string) bool {
|
|
if !strings.HasSuffix(filename, "_test.go") {
|
|
return false
|
|
}
|
|
return strings.HasPrefix(filename, "internal/cli/") ||
|
|
strings.HasPrefix(filename, "internal/core/") ||
|
|
strings.HasPrefix(filename, "internal/framework/")
|
|
}
|
|
|
|
func testRepositoryRoot(t *testing.T) string {
|
|
t.Helper()
|
|
_, filename, _, ok := runtime.Caller(0)
|
|
if !ok {
|
|
t.Fatal("resolve import-boundary test location")
|
|
}
|
|
return filepath.Clean(filepath.Join(filepath.Dir(filename), "..", ".."))
|
|
}
|