Add composable schema test syntax parsing

pkg/composableschemadsl/compiler/development_test.go

@@ -110,7 +110,7 @@ func TestPositionToAstNode(t *testing.T) {
 			line:   2,
 			column: 6,
 			expected: []dslshape.NodeType{
-				dslshape.NodeTypeCaveatExpression,
+				dslshape.NodeTypeOpaqueBraceExpression,
 				dslshape.NodeTypeCaveatDefinition,
 				dslshape.NodeTypeFile,
 			},

pkg/composableschemadsl/compiler/translator.go

@@ -162,12 +162,12 @@ func translateCaveatDefinition(tctx translationContext, defNode *dslNode) (*core
 	}
 
 	// caveat expression.
-	expressionStringNode, err := defNode.Lookup(dslshape.NodeCaveatDefinitionPredicateExpession)
+	expressionStringNode, err := defNode.Lookup(dslshape.NodeOpaqueBraceExpressionPredicateExpression)
 	if err != nil {
 		return nil, defNode.WithSourceErrorf(definitionName, "invalid expression: %w", err)
 	}
 
-	expressionString, err := expressionStringNode.GetString(dslshape.NodeCaveatExpressionPredicateExpression)
+	expressionString, err := expressionStringNode.GetString(dslshape.NodeOpaqueBraceExpressionPredicateExpression)
 	if err != nil {
 		return nil, defNode.WithSourceErrorf(expressionString, "invalid expression: %w", err)
 	}

pkg/composableschemadsl/dslshape/dslshape.go

@@ -37,6 +37,21 @@ const (
 	NodeTypeCaveatTypeReference // A type reference for a caveat parameter.
 
 	NodeTypeImport
+
+	// A balanced brace-enclosed expression. Represents both caveat CELs and caveat JSON context.
+	NodeTypeOpaqueBraceExpression
+
+	NodeTypeTest
+	NodeTypeTestRelations
+	NodeTypeTestRelation
+	NodeTypeTestObject
+	NodeTypeTestPermission
+	NodeTypeTestNegativePermission
+	NodeTypeTestAssertions
+	NodeTypeTestAssertion
+	NodeTypeTestExpectedRelations
+	NodeTypeTestExpectedRelation
+	NodeTypeTestExpectedRelationSource
 )
 
 const (
@@ -198,4 +213,24 @@ const (
 	NodeImportPredicateSource         = "import-source"
 	NodeImportPredicatePathSegment    = "path-segment"
 	NodeImportPredicateDefinitionName = "imported-definition"
+
+	NodeTestPredicateName = "test-name"
+
+	NodeTestPredicateSubject        = "subject"
+	NodeTestPredicateObject         = "object"
+	NodeTestPredicateRelation       = "relation"
+	NodeTestPredicatePermission     = "permission"
+	NodeTestPredicateAssertionType  = "assertion-type"
+	NodeTestPredicateCaveatName     = "caveat-name"
+	NodeTestPredicateCaveatContext  = "caveat-context"
+	NodeTestPredicateExpirationTime = "expiration-time"
+
+	NodeTestObjectPredicateObjectType = "object-type"
+	NodeTestObjectPredicateObjectID   = "object-id"
+	// Used for both positive and negative permissions
+	NodeTestRelationPermissionPredicateName = "permission-name"
+
+	NodeTestExpectedRelationSourcePredicateCaveatAnnotation = "caveat-annotation"
+
+	NodeOpaqueBraceExpressionPredicateExpression = "expression"
 )

pkg/composableschemadsl/lexer/lex_def.go

@@ -82,6 +82,20 @@ var keywords = map[string]struct{}{
 	"import":     {},
 	"all":        {},
 	"any":        {},
+	// caveat syntax
+	"and":        {},
+	"expiration": {},
+	// Test keywords
+	"test":          {},
+	"relationships": {},
+	"assertions":    {},
+	"expected":      {},
+	"is":            {},
+	"of":            {},
+	"not":           {},
+	"conditional":   {},
+	"when":          {},
+	"for":           {},
 }
 
 // IsKeyword returns whether the specified input string is a reserved keyword.

pkg/composableschemadsl/lexer/lex_test.go

@@ -66,6 +66,19 @@ var lexerTests = []lexerTest{
 	{"keyword", "import", []Lexeme{{TokenTypeKeyword, 0, "import", ""}, tEOF}},
 	{"keyword", "all", []Lexeme{{TokenTypeKeyword, 0, "all", ""}, tEOF}},
 	{"keyword", "nil", []Lexeme{{TokenTypeKeyword, 0, "nil", ""}, tEOF}},
+	{"keyword", "and", []Lexeme{{TokenTypeKeyword, 0, "and", ""}, tEOF}},
+	// Test keywords
+	{"keyword", "test", []Lexeme{{TokenTypeKeyword, 0, "test", ""}, tEOF}},
+	{"keyword", "relationships", []Lexeme{{TokenTypeKeyword, 0, "relationships", ""}, tEOF}},
+	{"keyword", "assertions", []Lexeme{{TokenTypeKeyword, 0, "assertions", ""}, tEOF}},
+	{"keyword", "expected", []Lexeme{{TokenTypeKeyword, 0, "expected", ""}, tEOF}},
+	{"keyword", "is", []Lexeme{{TokenTypeKeyword, 0, "is", ""}, tEOF}},
+	{"keyword", "of", []Lexeme{{TokenTypeKeyword, 0, "of", ""}, tEOF}},
+	{"keyword", "not", []Lexeme{{TokenTypeKeyword, 0, "not", ""}, tEOF}},
+	{"keyword", "conditional", []Lexeme{{TokenTypeKeyword, 0, "conditional", ""}, tEOF}},
+	{"keyword", "when", []Lexeme{{TokenTypeKeyword, 0, "when", ""}, tEOF}},
+	{"keyword", "for", []Lexeme{{TokenTypeKeyword, 0, "for", ""}, tEOF}},
+
 	{"identifier", "define", []Lexeme{{TokenTypeIdentifier, 0, "define", ""}, tEOF}},
 	{"typepath", "foo/bar", []Lexeme{
 		{TokenTypeIdentifier, 0, "foo", ""},