Kr/relationship definitions pt2

.changes/unreleased/Feature-20250515-145437.yaml

@@ -1,3 +1,3 @@
 kind: Feature
-body: Add client functions to create, update and delete "RelationshipDefinition"'s
+body: Add client functions to create, get, list, update and delete "RelationshipDefinition"'s
 time: 2025-05-15T14:54:37.070312-05:00

clientGQL_test.go

@@ -32,17 +32,29 @@ var (
 	alias2        = dataTemplater.ParseValue("alias2")
 	alias3        = dataTemplater.ParseValue("alias3")
 	alias4        = dataTemplater.ParseValue("alias4")
+	name1         = "Example 1"
+	name2         = "Example 2"
+
+	_setups []func(m *testing.M)
 )
 
 func TestMain(m *testing.M) {
 	output := zerolog.ConsoleWriter{Out: os.Stderr}
 	log.Logger = log.Output(output)
 	flag.Parse()
 	teardown := autopilot.Setup()
+	for _, fn := range _setups {
+		fn(m)
+	}
 	defer teardown()
 	os.Exit(m.Run())
 }
 
+// TODO: move this to Autopilot to help with test data preparation
+func AddSetup(fn func(m *testing.M)) {
+	_setups = append(_setups, fn)
+}
+
 func Templated(input string) string {
 	response, err := autopilot.Templater.Use(input)
 	if err != nil {

relationship.go

@@ -16,6 +16,50 @@ func (client *Client) CreateRelationshipDefinition(input RelationshipDefinitionI
 	return &m.Payload.Definition, HandleErrors(err, m.Payload.Errors)
 }
 
+func (client *Client) GetRelationshipDefinition(identifier string) (*RelationshipDefinitionType, error) {
+	var q struct {
+		Account struct {
+			Resource RelationshipDefinitionType `graphql:"relationshipDefinition(input: $input)"`
+		}
+	}
+	v := PayloadVariables{
+		"input": *NewIdentifier(identifier),
+	}
+	err := client.Query(&q, v, WithName("RelationshipDefinitionGet"))
+	return &q.Account.Resource, HandleErrors(err, nil)
+}
+
+func (client *Client) ListRelationshipDefinitions(variables *PayloadVariables) (*RelationshipDefinitionConnection, error) {
+	var q struct {
+		Account struct {
+			Resources RelationshipDefinitionConnection `graphql:"relationshipDefinitions(after: $after, first: $first, componentType: $componentType, resource: $resource)"`
+		}
+	}
+	if variables == nil {
+		variables = client.InitialPageVariablesPointer()
+	}
+	if (*variables)["componentType"] == nil {
+		(*variables)["componentType"] = &IdentifierInput{}
+	}
+	if (*variables)["resource"] == nil {
+		(*variables)["resource"] = NewID("")
+	}
+	if err := client.Query(&q, *variables, WithName("RelationshipDefinitionList")); err != nil {
+		return nil, err
+	}
+	if q.Account.Resources.PageInfo.HasNextPage {
+		(*variables)["after"] = q.Account.Resources.PageInfo.End
+		resp, err := client.ListRelationshipDefinitions(variables)
+		if err != nil {
+			return nil, err
+		}
+		q.Account.Resources.Nodes = append(q.Account.Resources.Nodes, resp.Nodes...)
+		q.Account.Resources.PageInfo = resp.PageInfo
+	}
+	q.Account.Resources.TotalCount = len(q.Account.Resources.Nodes)
+	return &q.Account.Resources, nil
+}
+
 func (client *Client) UpdateRelationshipDefinition(identifier string, input RelationshipDefinitionInput) (*RelationshipDefinitionType, error) {
 	var m struct {
 		Payload RelationshipDefinitionPayload `graphql:"relationshipDefinitionUpdate(relationshipDefinition: $identifier, input: $input)"`

relationship_test.go

@@ -0,0 +1,145 @@
+package opslevel_test
+
+import (
+	"testing"
+
+	ol "github.com/opslevel/opslevel-go/v2025"
+	"github.com/rocktavious/autopilot/v2023"
+)
+
+var (
+	input ol.RelationshipDefinitionInput
+	resp1 ol.RelationshipDefinitionType
+	resp2 ol.RelationshipDefinitionType
+)
+
+func init() {
+	AddSetup(func(m *testing.M) {
+		input = autopilot.Register[ol.RelationshipDefinitionInput]("relationship_definition_input",
+			ol.RelationshipDefinitionInput{
+				Alias:         &alias1,
+				Name:          &name1,
+				Description:   ol.RefOf("Example Description"),
+				ComponentType: ol.NewIdentifier("example"),
+				Metadata: &ol.RelationshipDefinitionMetadataInput{
+					AllowedTypes: []string{"example"},
+				},
+			})
+		resp1 = autopilot.Register[ol.RelationshipDefinitionType]("relationship_definition1_response",
+			ol.RelationshipDefinitionType{
+				Id:    id1,
+				Alias: alias1,
+				Name:  name1,
+				Metadata: ol.RelationshipDefinitionMetadata{
+					AllowedTypes: []string{"example"},
+				},
+			})
+		resp2 = autopilot.Register[ol.RelationshipDefinitionType]("relationship_definition2_response",
+			ol.RelationshipDefinitionType{
+				Id:    id2,
+				Alias: alias2,
+				Name:  name2,
+				Metadata: ol.RelationshipDefinitionMetadata{
+					AllowedTypes: []string{"example2", "example3"},
+				},
+			})
+	})
+}
+
+func TestRelationshipDefinitionCreate(t *testing.T) {
+	// Arrange
+	testRequest := autopilot.NewTestRequest(
+		`mutation RelationshipDefinitionCreate($input:RelationshipDefinitionInput!){relationshipDefinitionCreate(input: $input){definition{alias,componentType{id,aliases},description,id,metadata{allowedTypes,maxItems,minItems},name},errors{message,path}}}`,
+		`{"input": {{ template "relationship_definition_input" }} }`,
+		`{"data": {"relationshipDefinitionCreate": {"definition": {{ template "relationship_definition1_response" }} }}}`,
+	)
+
+	client := BestTestClient(t, "relationship_definition/create", testRequest)
+	// Act
+	result, err := client.CreateRelationshipDefinition(input)
+	// Assert
+	autopilot.Ok(t, err)
+	autopilot.Equals(t, resp1.Id, result.Id)
+	autopilot.Equals(t, resp1.Alias, result.Alias)
+	autopilot.Equals(t, resp1.Metadata.AllowedTypes, result.Metadata.AllowedTypes)
+}
+
+func TestRelationshipDefinitionGet(t *testing.T) {
+	// Arrange
+	testRequest := autopilot.NewTestRequest(
+		`query RelationshipDefinitionGet($input:IdentifierInput!){account{relationshipDefinition(input: $input){alias,componentType{id,aliases},description,id,metadata{allowedTypes,maxItems,minItems},name}}}`,
+		`{"input": { {{ template "id1" }} }}`,
+		`{"data": {"account": {"relationshipDefinition": {{ template "relationship_definition1_response" }} }}}`,
+	)
+
+	client := BestTestClient(t, "relationship_definition/get", testRequest)
+	// Act
+	result, err := client.GetRelationshipDefinition(string(id1))
+	// Assert
+	autopilot.Ok(t, err)
+	autopilot.Equals(t, resp1.Id, result.Id)
+	autopilot.Equals(t, resp1.Alias, result.Alias)
+	autopilot.Equals(t, resp1.Metadata.AllowedTypes, result.Metadata.AllowedTypes)
+}
+
+func TestRelationshipDefinitionList(t *testing.T) {
+	// Arrange
+	testRequestOne := autopilot.NewTestRequest(
+		`query RelationshipDefinitionList($after:String!$componentType:IdentifierInput$first:Int!$resource:ID){account{relationshipDefinitions(after: $after, first: $first, componentType: $componentType, resource: $resource){nodes{alias,componentType{id,aliases},description,id,metadata{allowedTypes,maxItems,minItems},name},pageInfo{hasNextPage,hasPreviousPage,startCursor,endCursor}}}}`,
+		`{ {{ template "first_page_variables" }}, "componentType": null, "resource": null}`,
+		`{ "data": { "account": { "relationshipDefinitions": { "nodes": [ {{ template "relationship_definition1_response" }} ], {{ template "pagination_initial_pageInfo_response" }} }}}}`,
+	)
+	testRequestTwo := autopilot.NewTestRequest(
+		`query RelationshipDefinitionList($after:String!$componentType:IdentifierInput$first:Int!$resource:ID){account{relationshipDefinitions(after: $after, first: $first, componentType: $componentType, resource: $resource){nodes{alias,componentType{id,aliases},description,id,metadata{allowedTypes,maxItems,minItems},name},pageInfo{hasNextPage,hasPreviousPage,startCursor,endCursor}}}}`,
+		`{ {{ template "second_page_variables" }}, "componentType": null, "resource": null}`,
+		`{ "data": { "account": { "relationshipDefinitions": { "nodes": [ {{ template "relationship_definition2_response" }} ], {{ template "pagination_second_pageInfo_response" }} }}}}`,
+	)
+	requests := []autopilot.TestRequest{testRequestOne, testRequestTwo}
+
+	client := BestTestClient(t, "relationship_definition/list", requests...)
+	// Act
+	result, err := client.ListRelationshipDefinitions(nil)
+	// Assert
+	autopilot.Ok(t, err)
+	autopilot.Equals(t, 2, result.TotalCount)
+	autopilot.Equals(t, resp1.Id, result.Nodes[0].Id)
+	autopilot.Equals(t, resp1.Alias, result.Nodes[0].Alias)
+	autopilot.Equals(t, resp1.Metadata.AllowedTypes, result.Nodes[0].Metadata.AllowedTypes)
+	autopilot.Equals(t, resp2.Id, result.Nodes[1].Id)
+	autopilot.Equals(t, resp2.Alias, result.Nodes[1].Alias)
+	autopilot.Equals(t, resp2.Metadata.AllowedTypes, result.Nodes[1].Metadata.AllowedTypes)
+}
+
+func TestRelationshipDefinitionUpdate(t *testing.T) {
+	// Arrange
+	testRequest := autopilot.NewTestRequest(
+		`mutation RelationshipDefinitionUpdate($identifier:IdentifierInput$input:RelationshipDefinitionInput!){relationshipDefinitionUpdate(relationshipDefinition: $identifier, input: $input){definition{alias,componentType{id,aliases},description,id,metadata{allowedTypes,maxItems,minItems},name},errors{message,path}}}`,
+		`{"identifier": { {{ template "id1" }} }, "input": {{ template "relationship_definition_input" }} }`,
+		`{"data": {"relationshipDefinitionUpdate": {"definition": {{ template "relationship_definition1_response" }} }}}`,
+	)
+
+	client := BestTestClient(t, "relationship_definition/update", testRequest)
+	// Act
+	result, err := client.UpdateRelationshipDefinition(string(id1), input)
+	// Assert
+	autopilot.Ok(t, err)
+	autopilot.Equals(t, id1, result.Id)
+	autopilot.Equals(t, resp1.Id, result.Id)
+	autopilot.Equals(t, resp1.Alias, result.Alias)
+	autopilot.Equals(t, resp1.Metadata.AllowedTypes, result.Metadata.AllowedTypes)
+}
+
+func TestRelationshipDefinitionDelete(t *testing.T) {
+	// Arrange
+	testRequest := autopilot.NewTestRequest(
+		`mutation RelationshipDefinitionDelete($input:IdentifierInput!){relationshipDefinitionDelete(resource: $input){deletedId,errors{message,path}}}`,
+		`{"input": { {{ template "id1" }} }}`,
+		`{"data": {"relationshipDefinitionDelete": {"deletedId": "{{ template "id1_string" }}", "errors": [] }}}`,
+	)
+
+	client := BestTestClient(t, "relationship_definition/delete", testRequest)
+	// Act
+	_, err := client.DeleteRelationshipDefinition(string(id1))
+	// Assert
+	autopilot.Ok(t, err)
+}