github.com/System-Glitch/goyave/v3@v3.6.1-0.20210226143142-ac2fe42ee80e/validation/dates_test.go (about)

     1  package validation
     2  
     3  import (
     4  	"testing"
     5  	"time"
     6  
     7  	"github.com/stretchr/testify/assert"
     8  )
     9  
    10  func createDate(date string) time.Time {
    11  	t, err := time.Parse("2006-01-02", date)
    12  	if err != nil {
    13  		panic(err)
    14  	}
    15  	return t
    16  }
    17  
    18  func createDateTime(date string) time.Time {
    19  	t, err := time.Parse("2006-01-02T15:04:05", date)
    20  	if err != nil {
    21  		panic(err)
    22  	}
    23  	return t
    24  }
    25  
    26  func TestValidateDate(t *testing.T) {
    27  	assert.True(t, validateDate("field", "2019-11-02", []string{}, map[string]interface{}{}))
    28  	assert.False(t, validateDate("field", "2019-13-02", []string{}, map[string]interface{}{}))
    29  	assert.False(t, validateDate("field", "2019-12-32", []string{}, map[string]interface{}{}))
    30  
    31  	assert.True(t, validateDate("field", "2019-11-02 11:07:42", []string{"2006-01-02 03:04:05"}, map[string]interface{}{}))
    32  	assert.False(t, validateDate("field", "2019-11-02 24:07:42", []string{"2006-01-02 03:04:05"}, map[string]interface{}{}))
    33  	assert.False(t, validateDate("field", "2019-11-02 11:61:42", []string{"2006-01-02 03:04:05"}, map[string]interface{}{}))
    34  	assert.False(t, validateDate("field", "2019-11-02 11:61:61", []string{"2006-01-02 03:04:05"}, map[string]interface{}{}))
    35  	assert.False(t, validateDate("field", "hello", []string{}, map[string]interface{}{}))
    36  	assert.False(t, validateDate("field", 1, []string{"2006-01-02 03:04:05"}, map[string]interface{}{}))
    37  	assert.False(t, validateDate("field", 1.0, []string{"2006-01-02 03:04:05"}, map[string]interface{}{}))
    38  	assert.False(t, validateDate("field", true, []string{"2006-01-02 03:04:05"}, map[string]interface{}{}))
    39  	assert.False(t, validateDate("field", []string{}, []string{"2006-01-02 03:04:05"}, map[string]interface{}{}))
    40  }
    41  
    42  func TestValidateBefore(t *testing.T) {
    43  	assert.True(t, validateBefore("field", createDate("2019-11-02"), []string{"2019-11-02T12:00:00"}, map[string]interface{}{}))
    44  	assert.True(t, validateBefore("field", createDateTime("2019-11-02T11:00:00"), []string{"2019-11-02T12:00:00"}, map[string]interface{}{}))
    45  	assert.False(t, validateBefore("field", createDate("2019-11-03"), []string{"2019-11-02T12:00:00"}, map[string]interface{}{}))
    46  	assert.False(t, validateBefore("field", createDateTime("2019-11-02T12:00:00"), []string{"2019-11-02T12:00:00"}, map[string]interface{}{}))
    47  	assert.False(t, validateBefore("field", createDateTime("2019-11-02T13:00:00"), []string{"2019-11-02T12:00:00"}, map[string]interface{}{}))
    48  
    49  	assert.False(t, validateBefore("field", "hello", []string{"2019-11-02T12:00:00"}, map[string]interface{}{}))
    50  	assert.False(t, validateBefore("field", 1.0, []string{"2019-11-02T12:00:00"}, map[string]interface{}{}))
    51  
    52  	assert.Panics(t, func() {
    53  		validateBefore("field", createDate("2019-11-02"), []string{"invalid date and field doesn't exist"}, map[string]interface{}{})
    54  	})
    55  
    56  	assert.True(t, validateBefore("field", createDate("2019-11-02"), []string{"other"}, map[string]interface{}{"other": "2019-11-03"}))
    57  	assert.True(t, validateBefore("field", createDate("2019-11-02"), []string{"other"}, map[string]interface{}{"other": createDate("2019-11-03")}))
    58  	assert.False(t, validateBefore("field", createDate("2019-11-02"), []string{"other"}, map[string]interface{}{"other": createDate("2019-11-02")}))
    59  	assert.False(t, validateBefore("field", createDate("2019-11-02"), []string{"other"}, map[string]interface{}{"other": "hello"}))
    60  
    61  	assert.Panics(t, func() {
    62  		field := &Field{
    63  			Rules: []*Rule{
    64  				{Name: "before"},
    65  			},
    66  		}
    67  		field.check()
    68  	})
    69  }
    70  
    71  func TestValidateBeforeEqual(t *testing.T) {
    72  	assert.True(t, validateBeforeEqual("field", createDate("2019-11-02"), []string{"2019-11-02T12:00:00"}, map[string]interface{}{}))
    73  	assert.True(t, validateBeforeEqual("field", createDateTime("2019-11-02T11:00:00"), []string{"2019-11-02T12:00:00"}, map[string]interface{}{}))
    74  	assert.True(t, validateBeforeEqual("field", createDateTime("2019-11-02T12:00:00"), []string{"2019-11-02T12:00:00"}, map[string]interface{}{}))
    75  	assert.False(t, validateBeforeEqual("field", createDate("2019-11-03"), []string{"2019-11-02T12:00:00"}, map[string]interface{}{}))
    76  	assert.False(t, validateBeforeEqual("field", createDateTime("2019-11-02T13:00:00"), []string{"2019-11-02T12:00:00"}, map[string]interface{}{}))
    77  
    78  	assert.False(t, validateBeforeEqual("field", "hello", []string{"2019-11-02T12:00:00"}, map[string]interface{}{}))
    79  	assert.False(t, validateBeforeEqual("field", 1.0, []string{"2019-11-02T12:00:00"}, map[string]interface{}{}))
    80  
    81  	assert.Panics(t, func() {
    82  		validateBeforeEqual("field", createDate("2019-11-02"), []string{"invalid date and field doesn't exist"}, map[string]interface{}{})
    83  	})
    84  
    85  	assert.True(t, validateBeforeEqual("field", createDate("2019-11-02"), []string{"other"}, map[string]interface{}{"other": "2019-11-03"}))
    86  	assert.True(t, validateBeforeEqual("field", createDate("2019-11-02"), []string{"other"}, map[string]interface{}{"other": createDate("2019-11-03")}))
    87  	assert.True(t, validateBeforeEqual("field", createDate("2019-11-02"), []string{"other"}, map[string]interface{}{"other": createDate("2019-11-02")}))
    88  	assert.False(t, validateBeforeEqual("field", createDate("2019-11-02"), []string{"other"}, map[string]interface{}{"other": "hello"}))
    89  
    90  	assert.Panics(t, func() {
    91  		field := &Field{
    92  			Rules: []*Rule{
    93  				{Name: "before_equal"},
    94  			},
    95  		}
    96  		field.check()
    97  	})
    98  }
    99  
   100  func TestValidateAfter(t *testing.T) {
   101  	assert.False(t, validateAfter("field", createDate("2019-11-02"), []string{"2019-11-02T12:00:00"}, map[string]interface{}{}))
   102  	assert.False(t, validateAfter("field", createDateTime("2019-11-02T11:00:00"), []string{"2019-11-02T12:00:00"}, map[string]interface{}{}))
   103  	assert.False(t, validateAfter("field", createDateTime("2019-11-02T12:00:00"), []string{"2019-11-02T12:00:00"}, map[string]interface{}{}))
   104  	assert.True(t, validateAfter("field", createDate("2019-11-03"), []string{"2019-11-02T12:00:00"}, map[string]interface{}{}))
   105  	assert.True(t, validateAfter("field", createDateTime("2019-11-02T13:00:00"), []string{"2019-11-02T12:00:00"}, map[string]interface{}{}))
   106  
   107  	assert.False(t, validateAfter("field", "hello", []string{"2019-11-02T12:00:00"}, map[string]interface{}{}))
   108  	assert.False(t, validateAfter("field", 1.0, []string{"2019-11-02T12:00:00"}, map[string]interface{}{}))
   109  
   110  	assert.Panics(t, func() {
   111  		validateAfter("field", createDate("2019-11-02"), []string{"invalid date and field doesn't exist"}, map[string]interface{}{})
   112  	})
   113  
   114  	assert.False(t, validateAfter("field", createDate("2019-11-02"), []string{"other"}, map[string]interface{}{"other": "2019-11-03"}))
   115  	assert.True(t, validateAfter("field", createDate("2019-11-02"), []string{"other"}, map[string]interface{}{"other": "2019-11-01"}))
   116  	assert.True(t, validateAfter("field", createDate("2019-11-04"), []string{"other"}, map[string]interface{}{"other": createDate("2019-11-03")}))
   117  	assert.False(t, validateAfter("field", createDate("2019-11-02"), []string{"other"}, map[string]interface{}{"other": createDate("2019-11-02")}))
   118  	assert.False(t, validateAfter("field", createDate("2019-11-02"), []string{"other"}, map[string]interface{}{"other": "hello"}))
   119  
   120  	assert.Panics(t, func() {
   121  		field := &Field{
   122  			Rules: []*Rule{
   123  				{Name: "after"},
   124  			},
   125  		}
   126  		field.check()
   127  	})
   128  }
   129  
   130  func TestValidateAfterEqual(t *testing.T) {
   131  	assert.False(t, validateAfterEqual("field", createDate("2019-11-02"), []string{"2019-11-02T12:00:00"}, map[string]interface{}{}))
   132  	assert.False(t, validateAfterEqual("field", createDateTime("2019-11-02T11:00:00"), []string{"2019-11-02T12:00:00"}, map[string]interface{}{}))
   133  	assert.True(t, validateAfterEqual("field", createDateTime("2019-11-02T12:00:00"), []string{"2019-11-02T12:00:00"}, map[string]interface{}{}))
   134  	assert.True(t, validateAfterEqual("field", createDate("2019-11-03"), []string{"2019-11-02T12:00:00"}, map[string]interface{}{}))
   135  	assert.True(t, validateAfterEqual("field", createDateTime("2019-11-02T13:00:00"), []string{"2019-11-02T12:00:00"}, map[string]interface{}{}))
   136  
   137  	assert.False(t, validateAfterEqual("field", "hello", []string{"2019-11-02T12:00:00"}, map[string]interface{}{}))
   138  	assert.False(t, validateAfterEqual("field", 1.0, []string{"2019-11-02T12:00:00"}, map[string]interface{}{}))
   139  
   140  	assert.Panics(t, func() {
   141  		validateAfterEqual("field", createDate("2019-11-02"), []string{"invalid date and field doesn't exist"}, map[string]interface{}{})
   142  	})
   143  
   144  	assert.False(t, validateAfterEqual("field", createDate("2019-11-02"), []string{"other"}, map[string]interface{}{"other": "2019-11-03"}))
   145  	assert.True(t, validateAfterEqual("field", createDate("2019-11-02"), []string{"other"}, map[string]interface{}{"other": "2019-11-01"}))
   146  	assert.False(t, validateAfterEqual("field", createDate("2019-11-02"), []string{"other"}, map[string]interface{}{"other": createDate("2019-11-03")}))
   147  	assert.True(t, validateAfterEqual("field", createDate("2019-11-02"), []string{"other"}, map[string]interface{}{"other": createDate("2019-11-02")}))
   148  	assert.False(t, validateAfterEqual("field", createDate("2019-11-02"), []string{"other"}, map[string]interface{}{"other": "hello"}))
   149  
   150  	assert.Panics(t, func() {
   151  		field := &Field{
   152  			Rules: []*Rule{
   153  				{Name: "after_equal"},
   154  			},
   155  		}
   156  		field.check()
   157  	})
   158  }
   159  
   160  func TestValidateDateEquals(t *testing.T) {
   161  	assert.True(t, validateDateEquals("field", createDate("2019-11-02"), []string{"2019-11-02T00:00:00"}, map[string]interface{}{}))
   162  	assert.False(t, validateDateEquals("field", createDate("2019-11-02"), []string{"2019-11-02T12:00:00"}, map[string]interface{}{}))
   163  
   164  	assert.False(t, validateDateEquals("field", "hello", []string{"2019-11-02T12:00:00"}, map[string]interface{}{}))
   165  	assert.False(t, validateDateEquals("field", 1.0, []string{"2019-11-02T12:00:00"}, map[string]interface{}{}))
   166  
   167  	assert.Panics(t, func() {
   168  		validateDateEquals("field", createDate("2019-11-02"), []string{"invalid date and field doesn't exist"}, map[string]interface{}{})
   169  	})
   170  
   171  	assert.True(t, validateDateEquals("field", createDate("2019-11-02"), []string{"other"}, map[string]interface{}{"other": "2019-11-02"}))
   172  	assert.True(t, validateDateEquals("field", createDateTime("2019-11-02T13:14:15"), []string{"other"}, map[string]interface{}{"other": createDateTime("2019-11-02T13:14:15")}))
   173  	assert.False(t, validateDateEquals("field", createDate("2019-11-03"), []string{"other"}, map[string]interface{}{"other": createDateTime("2019-11-02T13:14:16")}))
   174  	assert.False(t, validateDateEquals("field", createDateTime("2019-11-02T13:14:15"), []string{"other"}, map[string]interface{}{"other": createDateTime("2019-11-02T13:14:16")}))
   175  	assert.False(t, validateDateEquals("field", createDate("2019-11-02"), []string{"other"}, map[string]interface{}{"other": "hello"}))
   176  
   177  	assert.Panics(t, func() {
   178  		field := &Field{
   179  			Rules: []*Rule{
   180  				{Name: "date_equals"},
   181  			},
   182  		}
   183  		field.check()
   184  	})
   185  }
   186  
   187  func TestValidateDateBetween(t *testing.T) {
   188  	assert.True(t, validateDateBetween("field", createDate("2019-11-02"), []string{"2019-11-01T00:00:00", "2019-11-03T00:00:00"}, map[string]interface{}{}))
   189  	assert.True(t, validateDateBetween("field", createDate("2019-11-02"), []string{"2019-11-02T00:00:00", "2019-11-03T00:00:00"}, map[string]interface{}{}))
   190  	assert.False(t, validateDateBetween("field", createDate("2019-11-04"), []string{"2019-11-02T00:00:00", "2019-11-03T00:00:00"}, map[string]interface{}{}))
   191  	assert.False(t, validateDateBetween("field", createDate("2019-11-01"), []string{"2019-11-02T00:00:00", "2019-11-03T00:00:00"}, map[string]interface{}{}))
   192  
   193  	assert.True(t, validateDateBetween("field", createDateTime("2019-11-02T13:14:15"), []string{"min", "max"}, map[string]interface{}{"min": createDateTime("2019-11-02T13:14:00"), "max": createDateTime("2019-11-02T14:14:00")}))
   194  	assert.True(t, validateDateBetween("field", createDateTime("2019-11-02T13:14:15"), []string{"min", "2019-11-03T00:00:00"}, map[string]interface{}{"min": createDateTime("2019-11-02T13:14:00")}))
   195  
   196  	assert.Panics(t, func() {
   197  		field := &Field{
   198  			Rules: []*Rule{
   199  				{Name: "date_between"},
   200  			},
   201  		}
   202  		field.check()
   203  	})
   204  
   205  	assert.Panics(t, func() {
   206  		field := &Field{
   207  			Rules: []*Rule{
   208  				{Name: "date_between", Params: []string{"2019-11-03T00:00:00"}},
   209  			},
   210  		}
   211  		field.check()
   212  	})
   213  }