101 lines
3.9 KiB
Go
101 lines
3.9 KiB
Go
package engine
|
|
|
|
import (
|
|
"reflect"
|
|
"testing"
|
|
)
|
|
|
|
func TestImportSchedulingKeepsUnselectedSlotsAndScopeBoundaries(t *testing.T) {
|
|
dependent := importNodeKey{resourcePath: "a-dependent"}
|
|
external := importNodeKey{resourcePath: "external"}
|
|
prerequisite := importNodeKey{resourcePath: "z-prerequisite"}
|
|
graph := newImportInclusionGraph()
|
|
for _, key := range []importNodeKey{dependent, external, prerequisite} {
|
|
graph.addNode(importGraphNode{key: key})
|
|
}
|
|
graph.addEdge(dependent, prerequisite, Location{})
|
|
graph.addEdge(dependent, external, Location{})
|
|
graph.addEdge(external, prerequisite, Location{})
|
|
contributions := []acquiredContribution{
|
|
{identity: dependent}, {identity: external}, {identity: prerequisite},
|
|
}
|
|
scheduled := scheduleContributionSlots(contributions, []int{0, 2}, indexImportDependencies(graph))
|
|
if scheduled[0].identity != prerequisite || scheduled[1].identity != external || scheduled[2].identity != dependent {
|
|
t.Fatalf("scope schedule = %#v", scheduled)
|
|
}
|
|
if contributions[0].identity != dependent || contributions[2].identity != prerequisite {
|
|
t.Fatal("scheduling changed the input slots")
|
|
}
|
|
}
|
|
|
|
func TestImportAndInheritanceIntegrationsUseEquivalentReadySchedules(t *testing.T) {
|
|
names := []string{"a-base", "b-independent", "z-dependent"}
|
|
keys := make(map[string]importNodeKey, len(names))
|
|
contributions := make([]acquiredContribution, len(names))
|
|
for index, name := range names {
|
|
key := importNodeKey{
|
|
namespaceKind: "host", namespaceAnchor: "/shared",
|
|
resourceKind: "file", resourcePath: "/" + name,
|
|
}
|
|
keys[name] = key
|
|
contributions[index] = acquiredContribution{
|
|
identity: key,
|
|
source: SourceInfo{ID: "source-" + name, Path: name},
|
|
}
|
|
}
|
|
|
|
var want []string
|
|
for _, reverse := range []bool{false, true} {
|
|
graph := newImportInclusionGraph()
|
|
orderedNames := append([]string(nil), names...)
|
|
if reverse {
|
|
orderedNames[0], orderedNames[2] = orderedNames[2], orderedNames[0]
|
|
}
|
|
for _, name := range orderedNames {
|
|
graph.addNode(importGraphNode{key: keys[name], sourceID: "source-" + name, role: importRoleMapping})
|
|
}
|
|
graph.addEdge(keys["z-dependent"], keys["a-base"], Location{})
|
|
|
|
scheduled := scheduleContributionSlots(contributions, []int{0, 1, 2}, indexImportDependencies(graph))
|
|
got := make([]string, len(scheduled))
|
|
for index, contribution := range scheduled {
|
|
got[index] = contribution.identity.resourcePath[1:]
|
|
}
|
|
if !reflect.DeepEqual(got, []string{"a-base", "b-independent", "z-dependent"}) {
|
|
t.Fatalf("import schedule reverse=%t: %v", reverse, got)
|
|
}
|
|
if !reflect.DeepEqual(
|
|
[]string{contributions[0].source.ID, contributions[1].source.ID, contributions[2].source.ID},
|
|
[]string{"source-a-base", "source-b-independent", "source-z-dependent"},
|
|
) {
|
|
t.Fatal("scheduling mutated acquisition source records")
|
|
}
|
|
|
|
inheritanceText := "a-base: {value: ready}\nb-independent: {value: independent}\nz-dependent: {extends: a-base}\n"
|
|
if reverse {
|
|
inheritanceText = "z-dependent: {extends: a-base}\nb-independent: {value: independent}\na-base: {value: ready}\n"
|
|
}
|
|
scope := parseCompositionDocument(t, "inheritance", inheritanceText)
|
|
inheritance, diagnostics := analyzeInheritanceGraph(scope, Path{})
|
|
if len(diagnostics) != 0 {
|
|
t.Fatalf("analyze inheritance reverse=%t: %#v", reverse, diagnostics)
|
|
}
|
|
order, diagnostics := inheritance.schedule()
|
|
if len(diagnostics) != 0 {
|
|
t.Fatalf("schedule inheritance reverse=%t: %#v", reverse, diagnostics)
|
|
}
|
|
inheritanceNames := make([]string, len(order))
|
|
for index, node := range order {
|
|
inheritanceNames[index] = inheritance.nodes[node].name
|
|
}
|
|
if !reflect.DeepEqual(inheritanceNames, got) {
|
|
t.Fatalf("equivalent graph schedules differ reverse=%t: imports=%v inheritance=%v", reverse, got, inheritanceNames)
|
|
}
|
|
if want == nil {
|
|
want = got
|
|
} else if !reflect.DeepEqual(got, want) {
|
|
t.Fatalf("import graph construction changed schedule: got %v, want %v", got, want)
|
|
}
|
|
}
|
|
}
|