github.com/go-playground/validator Custom null.string validator example

nullstring_example.go

// NewNotBlankValidator - given field must be declared as a null.* type. This checks to make sure the
// field value is its zero or null, or filled in but NOT set to empty String
// e.g. {value="", err=false} is not valid.
func NewNotBlankValidator(db *gorm.DB) validator.Func {
	return func(v *validator.Validate, topStruct reflect.Value, currentStruct reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
		switch fieldKind {
		case reflect.String:
			if field.String() == "" && field.IsValid() {
				return false
			}
			return true
		}
		panic(fmt.Sprintf("Unrecognized field type %T for notblank validation", field.Interface()))
	}
}

// ValidateValuer implements validator.CustomTypeFunc
func ValidateValuer(field reflect.Value) interface{} {
	if valuer, ok := field.Interface().(driver.Valuer); ok {
		val, err := valuer.Value()
		if err == nil {
			fmt.Printf("\nVal: %#v, type: %T\n", val, val)
			return val
		}
		fmt.Println("Error in valuer") //Handle Error?
	}
	return nil
}

//************* Test Setup and Test

type testNotBlankStruct struct {
	ID    string
	Token null.String `validate:"notblank"`
}

var _ = Describe("Custom Validations", func() {
	var v *validator.Validate

	BeforeEach(func() {
		config := &validator.Config{TagName: "validate"}
		v = validator.New(config)
		v.RegisterCustomTypeFunc(ValidateValuer, null.String{}, sql.NullString{})
		v.RegisterValidation("notblank", NewNotBlankValidator(Config.DB))
		})

		It("Allows any non-blank string", func() {
			s := testNotBlankStruct{Token: null.StringFrom("An actual string")}
			errs := v.Struct(s)
			Expect(errs).To(BeNil())
		})

		It("Allows nil as a valid value", func() {
			s := testNotBlankStruct{Token: null.StringFromPtr(nil)}
			errs := v.Struct(s)
			fmt.Printf("\nnil Struct: %#v\n", s)
			fmt.Printf("\nErrors: %#v\n", errs)
			Expect(errs).To(BeNil())
		})

		It("returns errors if the value is set to blank string", func() {
			s := testNotBlankStruct{Token: null.StringFrom("")}
			errs := v.Struct(s)
			fmt.Printf("\n Zero Struct: %#v", s)
			fmt.Printf("\nErrors: %#v\n", errs)
			Expect(errs).ToNot(BeNil())
		})