feat(attestations): Allow custom name on external evidence (#1174)

Signed-off-by: Javier Rodriguez <[email protected]>

Author: javirln

app/cli/internal/action/attestation_add.go

@@ -133,18 +133,37 @@ func (action *AttestationAdd) Run(ctx context.Context, attestationID, materialNa
 	}
 
 	// Add material to the attestation crafting state based on if the material is contract free or not.
-	// By default, try to detect the material kind automatically
+	// The checks are performed in the following order:
+	// 1. If materialName is empty and materialType is empty, we don't know anything about the material so, we add it with auto-detected kind and random name
+	// 2. If materialName is not empty, check if the material is in the contract. If it is, add material from contract
+	// 2.1. If materialType is empty, try to guess the material kind with auto-detected kind and materialName
+	// 3. If materialType is not empty, add material contract free with materialType and materialName
+	var kind schemaapi.CraftingSchema_Material_MaterialType
 	switch {
 	case materialName == "" && materialType == "":
-		var kind schemaapi.CraftingSchema_Material_MaterialType
-		if kind, err = crafter.AddMaterialContactFreeAutomatic(ctx, attestationID, materialValue, casBackend, annotations); err != nil {
+		kind, err = crafter.AddMaterialContactFreeWithAutoDetectedKind(ctx, attestationID, "", materialValue, casBackend, annotations)
+		if err != nil {
 			return fmt.Errorf("adding material: %w", err)
 		}
 		action.Logger.Info().Str("kind", kind.String()).Msg("material kind detected")
 	case materialName != "":
-		err = crafter.AddMaterialFromContract(ctx, attestationID, materialName, materialValue, casBackend, annotations)
+		switch {
+		// If the material is in the contract, add it from the contract
+		case crafter.IsMaterialInContract(materialName):
+			err = crafter.AddMaterialFromContract(ctx, attestationID, materialName, materialValue, casBackend, annotations)
+		// If the material is not in the contract and the materialType is not provided, add material contract free with auto-detected kind, guessing the kind
+		case materialType == "":
+			kind, err = crafter.AddMaterialContactFreeWithAutoDetectedKind(ctx, attestationID, materialName, materialValue, casBackend, annotations)
+			if err != nil {
+				return fmt.Errorf("adding material: %w", err)
+			}
+			action.Logger.Info().Str("kind", kind.String()).Msg("material kind detected")
+		// If the material is not in the contract and has a materialType, add material contract free with the provided materialType
+		default:
+			err = crafter.AddMaterialContractFree(ctx, attestationID, materialType, materialName, materialValue, casBackend, annotations)
+		}
 	default:
-		err = crafter.AddMaterialContractFree(ctx, attestationID, materialType, materialValue, casBackend, annotations)
+		err = crafter.AddMaterialContractFree(ctx, attestationID, materialType, materialName, materialValue, casBackend, annotations)
 	}
 
 	if err != nil {

internal/attestation/crafter/crafter.go

@@ -468,8 +468,8 @@ func (c *Crafter) ResolveEnvVars(ctx context.Context, attestationID string) erro
 
 // AddMaterialContractFree adds a material to the crafting state without checking the contract schema.
 // This is useful for adding materials that are not defined in the schema.
-// The name of the material is automatically calculated to conform the API contract.
-func (c *Crafter) AddMaterialContractFree(ctx context.Context, attestationID, kind, value string, casBackend *casclient.CASBackend, runtimeAnnotations map[string]string) error {
+// The name of the material is automatically calculated to conform the API contract if not provided.
+func (c *Crafter) AddMaterialContractFree(ctx context.Context, attestationID, kind, name, value string, casBackend *casclient.CASBackend, runtimeAnnotations map[string]string) error {
 	if err := c.requireStateLoaded(); err != nil {
 		return fmt.Errorf("adding materials outisde the contract: %w", err)
 	}
@@ -482,8 +482,12 @@ func (c *Crafter) AddMaterialContractFree(ctx context.Context, attestationID, ki
 		return fmt.Errorf("%q kind not found. Available options are %q", kind, schemaapi.ListAvailableMaterialKind())
 	}
 
-	// 2 - Generate a random name for the material
-	m.Name = fmt.Sprintf("material-%d", time.Now().UnixNano())
+	// 2 - Set the name of the material if provided
+	m.Name = name
+	if m.Name == "" {
+		// 2.1 - Generate a random name for the material since it was not provided
+		m.Name = fmt.Sprintf("material-%d", time.Now().UnixNano())
+	}
 
 	// 3 - Craft resulting material
 	return c.addMaterial(ctx, &m, attestationID, value, casBackend, runtimeAnnotations)
@@ -517,11 +521,26 @@ func (c *Crafter) AddMaterialFromContract(ctx context.Context, attestationID, ke
 	return c.addMaterial(ctx, m, attestationID, value, casBackend, runtimeAnnotations)
 }
 
-// AddMaterialContactFreeAutomatic adds a material to the crafting state checking the incoming material matches any of the
+// IsMaterialInContract checks if the material is in the contract schema
+func (c *Crafter) IsMaterialInContract(key string) bool {
+	if err := c.requireStateLoaded(); err != nil {
+		return false
+	}
+
+	for _, d := range c.CraftingState.InputSchema.Materials {
+		if d.Name == key {
+			return true
+		}
+	}
+
+	return false
+}
+
+// AddMaterialContactFreeWithAutoDetectedKind adds a material to the crafting state checking the incoming material matches any of the
 // supported types in validation order. If the material is not found it will return an error.
-func (c *Crafter) AddMaterialContactFreeAutomatic(ctx context.Context, attestationID, value string, casBackend *casclient.CASBackend, runtimeAnnotations map[string]string) (schemaapi.CraftingSchema_Material_MaterialType, error) {
+func (c *Crafter) AddMaterialContactFreeWithAutoDetectedKind(ctx context.Context, attestationID, name, value string, casBackend *casclient.CASBackend, runtimeAnnotations map[string]string) (schemaapi.CraftingSchema_Material_MaterialType, error) {
 	for _, kind := range schemaapi.CraftingMaterialInValidationOrder {
-		err := c.AddMaterialContractFree(ctx, attestationID, kind.String(), value, casBackend, runtimeAnnotations)
+		err := c.AddMaterialContractFree(ctx, attestationID, kind.String(), name, value, casBackend, runtimeAnnotations)
 		if err == nil {
 			// Successfully added material, return the kind
 			return kind, nil

internal/attestation/crafter/crafter_test.go

@@ -474,6 +474,7 @@ func (s *crafterSuite) TestAddMaterialsAutomatic() {
 	testCases := []struct {
 		name           string
 		materialPath   string
+		materialName   string
 		expectedType   schemaapi.CraftingSchema_Material_MaterialType
 		uploadArtifact bool
 		wantErr        bool
@@ -498,6 +499,12 @@ func (s *crafterSuite) TestAddMaterialsAutomatic() {
 			materialPath: "./materials/testdata/junit.xml",
 			expectedType: schemaapi.CraftingSchema_Material_JUNIT_XML,
 		},
+		{
+			name:         "junit with custom material name",
+			materialName: "custom-junit-material",
+			materialPath: "./materials/testdata/junit.xml",
+			expectedType: schemaapi.CraftingSchema_Material_JUNIT_XML,
+		},
 		{
 			name:         "artifact",
 			materialPath: "./materials/testdata/missing-empty.tgz",
@@ -553,13 +560,18 @@ func (s *crafterSuite) TestAddMaterialsAutomatic() {
 			c, err := newInitializedCrafter(s.T(), contract, &v1.WorkflowMetadata{}, false, "", runner)
 			require.NoError(s.T(), err)
 
-			kind, err := c.AddMaterialContactFreeAutomatic(context.Background(), "random-id", tc.materialPath, backend, nil)
+			kind, err := c.AddMaterialContactFreeWithAutoDetectedKind(context.Background(), "random-id", tc.materialName, tc.materialPath, backend, nil)
 			if tc.wantErr {
 				assert.ErrorIs(s.T(), err, materials.ErrBaseUploadAndCraft)
 			} else {
 				require.NoError(s.T(), err)
 			}
 			assert.Equal(s.T(), tc.expectedType.String(), kind.String())
+			if tc.materialName != "" {
+				attestationMaterials := c.CraftingState.Attestation.Materials
+				_, found := attestationMaterials[tc.materialName]
+				assert.True(s.T(), found)
+			}
 		})
 	}
 }