Adding csv2 decl validation (#174)

Author: jf-tech

extensions/omniv21/fileformat/flatfile/csv/validate.go

@@ -0,0 +1,72 @@
+package csv
+
+import (
+	"fmt"
+
+	"github.com/jf-tech/go-corelib/caches"
+	"github.com/jf-tech/go-corelib/strs"
+)
+
+type validateCtx struct {
+	seenTarget bool
+}
+
+func (ctx *validateCtx) validateFileDecl(fileDecl *FileDecl) error {
+	for _, decl := range fileDecl.Records {
+		if err := ctx.validateRecordDecl(decl.Name, decl); err != nil {
+			return err
+		}
+	}
+	if !ctx.seenTarget && len(fileDecl.Records) > 0 {
+		// for easy of use and convenience, if no is_target=true record is specified, then
+		// the first one will be automatically designated as target record.
+		fileDecl.Records[0].IsTarget = true
+	}
+	return nil
+}
+
+func (ctx *validateCtx) validateRecordDecl(fqdn string, decl *RecordDecl) (err error) {
+	decl.fqdn = fqdn
+	if decl.Header != nil {
+		if decl.headerRegexp, err = caches.GetRegex(*decl.Header); err != nil {
+			return fmt.Errorf(
+				"record/record_group '%s' has an invalid 'header' regexp '%s': %s",
+				fqdn, *decl.Header, err.Error())
+		}
+	}
+	if decl.Footer != nil {
+		if decl.footerRegexp, err = caches.GetRegex(*decl.Footer); err != nil {
+			return fmt.Errorf(
+				"record/record_group '%s' has an invalid 'footer' regexp '%s': %s",
+				fqdn, *decl.Footer, err.Error())
+		}
+	}
+	if decl.Group() {
+		if len(decl.Columns) > 0 {
+			return fmt.Errorf("record_group '%s' must not have any columns", fqdn)
+		}
+		if len(decl.Children) <= 0 {
+			return fmt.Errorf(
+				"record_group '%s' must have at least one child record/record_group", fqdn)
+		}
+	}
+	if decl.Target() {
+		if ctx.seenTarget {
+			return fmt.Errorf(
+				"a second record/record_group ('%s') with 'is_target' = true is not allowed",
+				fqdn)
+		}
+		ctx.seenTarget = true
+	}
+	if decl.MinOccurs() > decl.MaxOccurs() {
+		return fmt.Errorf("record/record_group '%s' has 'min' value %d > 'max' value %d",
+			fqdn, decl.MinOccurs(), decl.MaxOccurs())
+	}
+	for _, c := range decl.Children {
+		if err = ctx.validateRecordDecl(strs.BuildFQDN2("/", fqdn, c.Name), c); err != nil {
+			return err
+		}
+	}
+	decl.childRecDecls = toFlatFileRecDecls(decl.Children)
+	return nil
+}

extensions/omniv21/fileformat/flatfile/csv/validate_test.go

@@ -0,0 +1,130 @@
+package csv
+
+import (
+	"testing"
+
+	"github.com/jf-tech/go-corelib/strs"
+	"github.com/jf-tech/go-corelib/testlib"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestValidateFileDecl_AutoTargetFirstRecord(t *testing.T) {
+	decl := &FileDecl{
+		Records: []*RecordDecl{
+			{Name: "A"},
+			{Name: "B"},
+		},
+	}
+	assert.False(t, decl.Records[0].Target())
+	assert.False(t, decl.Records[1].Target())
+	err := (&validateCtx{}).validateFileDecl(decl)
+	assert.NoError(t, err)
+	assert.True(t, decl.Records[0].Target())
+	assert.False(t, decl.Records[1].Target())
+}
+
+func TestValidateFileDecl_InvalidHeaderRegexp(t *testing.T) {
+	err := (&validateCtx{}).validateFileDecl(&FileDecl{
+		Records: []*RecordDecl{
+			{Name: "A", Header: strs.StrPtr("[invalid")},
+		},
+	})
+	assert.Error(t, err)
+	assert.Equal(t,
+		"record/record_group 'A' has an invalid 'header' regexp '[invalid': error parsing regexp: missing closing ]: `[invalid`",
+		err.Error())
+}
+
+func TestValidateFileDecl_InvalidFooterRegexp(t *testing.T) {
+	err := (&validateCtx{}).validateFileDecl(&FileDecl{
+		Records: []*RecordDecl{
+			{Name: "A", Footer: strs.StrPtr("[invalid")},
+		},
+	})
+	assert.Error(t, err)
+	assert.Equal(t,
+		"record/record_group 'A' has an invalid 'footer' regexp '[invalid': error parsing regexp: missing closing ]: `[invalid`",
+		err.Error())
+}
+
+func TestValidateFileDecl_GroupHasColumns(t *testing.T) {
+	err := (&validateCtx{}).validateFileDecl(&FileDecl{
+		Records: []*RecordDecl{
+			{
+				Name:     "A",
+				Type:     strs.StrPtr(typeGroup),
+				Columns:  []*ColumnDecl{{}},
+				Children: []*RecordDecl{{}},
+			},
+		},
+	})
+	assert.Error(t, err)
+	assert.Equal(t, `record_group 'A' must not have any columns`, err.Error())
+}
+
+func TestValidateFileDecl_GroupHasNoChildren(t *testing.T) {
+	err := (&validateCtx{}).validateFileDecl(&FileDecl{
+		Records: []*RecordDecl{
+			{Name: "A", Type: strs.StrPtr(typeGroup), IsTarget: true},
+		},
+	})
+	assert.Error(t, err)
+	assert.Equal(t,
+		`record_group 'A' must have at least one child record/record_group`, err.Error())
+}
+
+func TestValidateFileDecl_TwoIsTarget(t *testing.T) {
+	err := (&validateCtx{}).validateFileDecl(&FileDecl{
+		Records: []*RecordDecl{
+			{Name: "A", IsTarget: true},
+			{Name: "B", Type: strs.StrPtr(typeGroup), Children: []*RecordDecl{
+				{Name: "C", IsTarget: true},
+			}},
+		},
+	})
+	assert.Error(t, err)
+	assert.Equal(t,
+		`a second record/record_group ('B/C') with 'is_target' = true is not allowed`,
+		err.Error())
+}
+
+func TestValidateFileDecl_MinGreaterThanMax(t *testing.T) {
+	err := (&validateCtx{}).validateFileDecl(&FileDecl{
+		Records: []*RecordDecl{
+			{Name: "A", Children: []*RecordDecl{
+				{Name: "B", Min: testlib.IntPtr(2), Max: testlib.IntPtr(1)}}},
+		},
+	})
+	assert.Error(t, err)
+	assert.Equal(t, `record/record_group 'A/B' has 'min' value 2 > 'max' value 1`, err.Error())
+}
+
+func TestValidateFileDecl_Success(t *testing.T) {
+	col1 := &ColumnDecl{Name: "c1"}
+	col2 := &ColumnDecl{Name: "c2"}
+	col3 := &ColumnDecl{Name: "c3"}
+	fd := &FileDecl{
+		Records: []*RecordDecl{
+			{
+				Name:   "A",
+				Header: strs.StrPtr("^A_BEGIN$"),
+				Footer: strs.StrPtr("^A_END$"),
+				Children: []*RecordDecl{
+					{
+						Name: "B", IsTarget: true,
+						Columns: []*ColumnDecl{col1, col2, col3},
+					},
+				},
+			},
+		},
+	}
+	err := (&validateCtx{}).validateFileDecl(fd)
+	assert.NoError(t, err)
+	assert.Equal(t, "A", fd.Records[0].fqdn)
+	assert.True(t, fd.Records[0].matchHeader([]byte("A_BEGIN")))
+	assert.True(t, fd.Records[0].matchFooter([]byte("A_END")))
+	assert.Equal(t, 1, len(fd.Records[0].childRecDecls))
+	assert.Same(t, fd.Records[0].Children[0], fd.Records[0].childRecDecls[0].(*RecordDecl))
+	assert.Equal(t, "A/B", fd.Records[0].Children[0].fqdn)
+	assert.Equal(t, []*ColumnDecl{col1, col2, col3}, fd.Records[0].Children[0].Columns)
+}