Add metadata validation per filter and unit tests

Author: blva

tools/cli/internal/openapi/filter/extension.go

@@ -29,6 +29,10 @@ const (
 	format                = "2006-01-02T15:04:05Z07:00"
 )
 
+func (f *ExtensionFilter) ValidateMetadata() error {
+	return validateMetadata(f.metadata)
+}
+
 func (f *ExtensionFilter) Apply() error {
 	for _, pathItem := range f.oas.Paths.Map() {
 		if pathItem == nil {

tools/cli/internal/openapi/filter/filter.go

@@ -17,6 +17,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	reflect "reflect"
 
 	"github.com/getkin/kin-openapi/openapi3"
 	"github.com/mongodb/openapi/tools/cli/internal/apiversion"
@@ -25,6 +26,7 @@ import (
 //go:generate mockgen -destination=../filter/mock_filter.go -package=filter github.com/mongodb/openapi/tools/cli/internal/openapi/filter Filter
 type Filter interface {
 	Apply() error
+	ValidateMetadata() error
 }
 
 type Metadata struct {
@@ -39,11 +41,29 @@ func NewMetadata(targetVersion *apiversion.APIVersion, targetEnv string) *Metada
 	}
 }
 
+// validateMetadata validates the metadata object, ensuring its not nil and has a target env.
 func validateMetadata(metadata *Metadata) error {
 	if metadata == nil {
 		return errors.New("metadata is nil")
 	}
 
+	if metadata.targetEnv == "" {
+		return errors.New("target environment is empty")
+	}
+
+	return nil
+}
+
+// validateMetadataWithVersion validates the metadata object, ensuring its not nil and has a target version.
+func validateMetadataWithVersion(metadata *Metadata) error {
+	if err := validateMetadata(metadata); err != nil {
+		return err
+	}
+
+	if metadata.targetVersion == nil {
+		return errors.New("target version is nil")
+	}
+
 	return nil
 }
 
@@ -81,17 +101,17 @@ func ApplyFilters(doc *openapi3.T, metadata *Metadata, filters func(oas *openapi
 		return nil, errors.New("openapi document is nil")
 	}
 
-	if err := validateMetadata(metadata); err != nil {
-		return nil, err
-	}
-
 	// make a copy of the oas to avoid modifying the original document when applying filters
 	oas, err := duplicateOas(doc)
 	if err != nil {
 		return nil, err
 	}
 
 	for _, filter := range filters(oas, metadata) {
+		if err := filter.ValidateMetadata(); err != nil {
+			s := reflect.TypeOf(filter)
+			return nil, fmt.Errorf("failed to validate metadata for filter %s with: %w", s, err)
+		}
 		if err := filter.Apply(); err != nil {
 			return nil, err
 		}

tools/cli/internal/openapi/filter/filter_test.go

@@ -12,3 +12,122 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 package filter
+
+import (
+	"testing"
+
+	"github.com/getkin/kin-openapi/openapi3"
+	"github.com/mongodb/openapi/tools/cli/internal/apiversion"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewMetadata(t *testing.T) {
+	version := &apiversion.APIVersion{}
+	env := "test-env"
+	metadata := NewMetadata(version, env)
+
+	assert.Equal(t, version, metadata.targetVersion)
+	assert.Equal(t, env, metadata.targetEnv)
+}
+
+func TestValidateMetadata(t *testing.T) {
+	t.Run("Valid metadata", func(t *testing.T) {
+		metadata := &Metadata{}
+		err := validateMetadata(metadata)
+		assert.NoError(t, err)
+	})
+
+	t.Run("Nil metadata", func(t *testing.T) {
+		err := validateMetadata(nil)
+		assert.Error(t, err)
+		assert.Equal(t, "metadata is nil", err.Error())
+	})
+}
+
+func TestDuplicateOas(t *testing.T) {
+	doc := &openapi3.T{
+		Info: &openapi3.Info{
+			Title:   "Test API",
+			Version: "1.0.0",
+		},
+	}
+
+	duplicateDoc, err := duplicateOas(doc)
+	require.NoError(t, err)
+	require.NotNil(t, duplicateDoc)
+	assert.Equal(t, doc.Info.Title, duplicateDoc.Info.Title)
+	assert.Equal(t, doc.Info.Version, duplicateDoc.Info.Version)
+}
+
+func TestApplyFilters(t *testing.T) {
+	doc := &openapi3.T{
+		Info: &openapi3.Info{
+			Title:   "Test API",
+			Version: "1.0.0",
+		},
+	}
+	metadata := &Metadata{}
+
+	t.Run("Nil document", func(t *testing.T) {
+		_, err := ApplyFilters(nil, metadata, DefaultFilters)
+		assert.Error(t, err)
+		assert.Equal(t, "openapi document is nil", err.Error())
+	})
+
+	t.Run("Nil metadata", func(t *testing.T) {
+		_, err := ApplyFilters(doc, nil, DefaultFilters)
+		assert.Error(t, err)
+		assert.Equal(t, "metadata is nil", err.Error())
+	})
+
+	t.Run("Invalid metadata", func(t *testing.T) {
+		_, err := ApplyFilters(doc, metadata, DefaultFilters)
+		assert.Equal(t, "target environment is empty", err.Error())
+	})
+
+	t.Run("Missing versioning metadata", func(t *testing.T) {
+		metadata := &Metadata{
+			targetEnv: "dev",
+		}
+		_, err := ApplyFilters(doc, metadata, DefaultFilters)
+		assert.Equal(t, "failed to validate metadata for filter *filter.VersioningExtensionFilter with: target version is nil", err.Error())
+	})
+
+	t.Run("Valid metadata for default filters", func(t *testing.T) {
+		version, err := apiversion.New(apiversion.WithVersion("2023-11-15"))
+		require.NoError(t, err)
+		metadata := &Metadata{
+			targetEnv:     "dev",
+			targetVersion: version,
+		}
+
+		filteredDoc, err := ApplyFilters(doc, metadata, DefaultFilters)
+		require.NoError(t, err)
+		assert.NotNil(t, filteredDoc)
+	})
+}
+
+func TestDefaultFilters(t *testing.T) {
+	doc := &openapi3.T{}
+	metadata := &Metadata{}
+	filters := DefaultFilters(doc, metadata)
+
+	assert.Len(t, filters, 7)
+}
+
+func TestFiltersWithoutVersioning(t *testing.T) {
+	doc := &openapi3.T{}
+	metadata := &Metadata{}
+	filters := FiltersWithoutVersioning(doc, metadata)
+
+	assert.Len(t, filters, 5)
+}
+
+func TestFiltersToGetVersions(t *testing.T) {
+	doc := &openapi3.T{}
+	metadata := &Metadata{}
+	filters := FiltersToGetVersions(doc, metadata)
+
+	assert.Len(t, filters, 1)
+}

tools/cli/internal/openapi/filter/hidden_envs.go

@@ -32,6 +32,10 @@ type HiddenEnvsFilter struct {
 	metadata *Metadata
 }
 
+func (f *HiddenEnvsFilter) ValidateMetadata() error {
+	return validateMetadata(f.metadata)
+}
+
 func (f *HiddenEnvsFilter) Apply() error {
 	// delete hidden paths first before processing
 	for pathName, pathItem := range f.oas.Paths.Map() {

tools/cli/internal/openapi/filter/info.go

@@ -26,6 +26,10 @@ type InfoVersioningFilter struct {
 	metadata *Metadata
 }
 
+func (f *InfoVersioningFilter) ValidateMetadata() error {
+	return validateMetadataWithVersion(f.metadata)
+}
+
 func (f *InfoVersioningFilter) Apply() error {
 	if f.oas.Info == nil {
 		return nil

tools/cli/internal/openapi/filter/operations.go

@@ -23,6 +23,10 @@ type OperationsFilter struct {
 	oas *openapi3.T
 }
 
+func (f *OperationsFilter) ValidateMetadata() error {
+	return nil
+}
+
 func (f *OperationsFilter) Apply() error {
 	if f.oas.Paths == nil {
 		return nil

tools/cli/internal/openapi/filter/tags.go

@@ -25,6 +25,10 @@ type TagsFilter struct {
 	oas *openapi3.T
 }
 
+func (f *TagsFilter) ValidateMetadata() error {
+	return nil
+}
+
 func (f *TagsFilter) Apply() error {
 	if f.oas.Tags == nil {
 		return nil

tools/cli/internal/openapi/filter/versioning.go

@@ -57,7 +57,15 @@ func newOperationConfig(op *openapi3.Operation) *OperationConfig {
 	}
 }
 
+func (f *VersioningFilter) ValidateMetadata() error {
+	return validateMetadataWithVersion(f.metadata)
+}
+
 func (f *VersioningFilter) Apply() error {
+	if f.oas.Paths == nil {
+		return nil
+	}
+
 	newPaths := &openapi3.Paths{
 		Extensions: f.oas.Paths.Extensions,
 	}

tools/cli/internal/openapi/filter/versioning_extension.go

@@ -35,6 +35,10 @@ const (
 	xGenExtension   = "x-xgen-version"
 )
 
+func (f *VersioningExtensionFilter) ValidateMetadata() error {
+	return validateMetadataWithVersion(f.metadata)
+}
+
 func (f *VersioningExtensionFilter) Apply() error {
 	for _, pathItem := range f.oas.Paths.Map() {
 		if pathItem == nil {