statepro/definition_validator_test.go at main · rendis/statepro · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
package statepro

import (
	"os"
	"strings"
	"testing"
)

func TestValidateQuantumMachineDefinitionFromBinary_AllStateMachineFixtures(t *testing.T) {
	fixtures := []string{
		"example/sm/state_machine.json",
		"example/cli/state_machine.json",
		"example/bot/state_machine.json",
		"schema/examples/neutral-machine.json",
	}

	for _, file := range fixtures {
		file := file
		t.Run(file, func(t *testing.T) {
			b, err := os.ReadFile(file)
			if err != nil {
				t.Fatalf("error reading fixture %s: %v", file, err)
			}
			if err = ValidateQuantumMachineDefinitionFromBinary(b); err != nil {
				t.Fatalf("expected fixture %s to be semantically valid, got: %v", file, err)
			}
		})
	}
}

func TestValidateQuantumMachineDefinitionFromBinary_InvalidSemanticCases(t *testing.T) {
	cases := []struct {
		name        string
		payload     string
		mustContain string
	}{
		{
			name: "unknown internal target reality",
			payload: `{
				"id":"machine",
				"canonicalName":"machine",
				"version":"1.0.0",
				"initials":["U:main"],
				"universes":{
					"main":{
						"id":"main",
						"canonicalName":"main",
						"version":"1.0.0",
						"initial":"A",
						"realities":{
							"A":{
								"id":"A",
								"type":"transition",
								"on":{"go":[{"targets":["B"]}]}
							},
							"END":{"id":"END","type":"final"}
						}
					}
				}
			}`,
			mustContain: "unknown internal reality 'B'",
		},
		{
			name: "unknown universe in initials",
			payload: `{
				"id":"machine",
				"canonicalName":"machine",
				"version":"1.0.0",
				"initials":["U:missing"],
				"universes":{
					"main":{
						"id":"main",
						"canonicalName":"main",
						"version":"1.0.0",
						"initial":"A",
						"realities":{
							"A":{
								"id":"A",
								"type":"transition",
								"always":[{"targets":["END"]}]
							},
							"END":{"id":"END","type":"final"}
						}
					}
				}
			}`,
			mustContain: "references unknown universe 'missing'",
		},
		{
			name: "universe map key mismatch",
			payload: `{
				"id":"machine",
				"canonicalName":"machine",
				"version":"1.0.0",
				"initials":["U:main"],
				"universes":{
					"main":{
						"id":"main-v2",
						"canonicalName":"main",
						"version":"1.0.0",
						"initial":"A",
						"realities":{
							"A":{
								"id":"A",
								"type":"transition",
								"always":[{"targets":["END"]}]
							},
							"END":{"id":"END","type":"final"}
						}
					}
				}
			}`,
			mustContain: "universe key 'main' must match universe.id 'main-v2'",
		},
	}

	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			err := ValidateQuantumMachineDefinitionFromBinary([]byte(tc.payload))
			if err == nil {
				t.Fatal("expected semantic validation error, got nil")
			}

			if !strings.Contains(err.Error(), tc.mustContain) {
				t.Fatalf("expected error to contain %q, got: %v", tc.mustContain, err)
			}
		})
	}
}