github.com/codingeasygo/util@v0.0.0-20231206062002-1ce2f004b7d9/attrscan/attrscan_test.go (about)

     1  package attrscan
     2  
     3  import (
     4  	"reflect"
     5  	"strings"
     6  	"testing"
     7  
     8  	"github.com/codingeasygo/util/converter"
     9  )
    10  
    11  type IsNilArray []string
    12  
    13  type IsZeroArray []string
    14  
    15  func (s *IsNilArray) IsNil() bool {
    16  	return s == nil
    17  }
    18  
    19  func (s *IsZeroArray) IsZero() bool {
    20  	return s == nil || len(*s) < 1
    21  }
    22  
    23  type Simple struct {
    24  	_  string       `json:"-"`
    25  	A0 int64        `json:"a0"`
    26  	A1 *int64       `json:"a1"`
    27  	AX int64        `json:"ax"`
    28  	B0 string       `json:"b0"`
    29  	B1 *string      `json:"b1"`
    30  	BX string       `json:"bx"`
    31  	C0 float64      `json:"c0"`
    32  	C1 *float64     `json:"c1"`
    33  	CX float64      `json:"cx" filter:"#all"`
    34  	D0 IsNilArray   `json:"d0"`
    35  	D1 IsZeroArray  `json:"d1"`
    36  	D2 *IsNilArray  `json:"d2"`
    37  	D3 *IsZeroArray `json:"d3"`
    38  	XX string       `json:"-"`
    39  }
    40  
    41  func TestFilterField(t *testing.T) {
    42  	var fields []string
    43  	simple := &Simple{
    44  		A0: 100,
    45  		A1: converter.Int64Ptr(100),
    46  		B0: "100",
    47  		B1: converter.StringPtr("100"),
    48  		C0: 100,
    49  		C1: converter.Float64Ptr(100),
    50  	}
    51  	{
    52  		if !CheckValue(reflect.ValueOf(nil), true, true) {
    53  			t.Error("error")
    54  			return
    55  		}
    56  		var intPtr *int
    57  		if CheckValue(reflect.ValueOf(intPtr), false, false) {
    58  			t.Error("error")
    59  			return
    60  		}
    61  	}
    62  	{
    63  		fields = nil
    64  		FilterFieldCall("test", simple, "", func(fieldName, fieldFunc string, field reflect.StructField, value interface{}) {
    65  			fields = append(fields, fieldName)
    66  		})
    67  		if strings.Join(fields, ",") != "a0,a1,b0,b1,c0,c1,cx" {
    68  			t.Errorf("%v", fields)
    69  			return
    70  		}
    71  	}
    72  	{
    73  		fields = nil
    74  		FilterFieldCall("test", simple, "#all", func(fieldName, fieldFunc string, field reflect.StructField, value interface{}) {
    75  			fields = append(fields, fieldName)
    76  		})
    77  		if strings.Join(fields, ",") != "a0,a1,ax,b0,b1,bx,c0,c1,cx,d0,d1,d2,d3" {
    78  			t.Errorf("%v", fields)
    79  			return
    80  		}
    81  	}
    82  	{
    83  		fields = nil
    84  		FilterFieldCall("test", simple, "a0,a1,ax#all", func(fieldName, fieldFunc string, field reflect.StructField, value interface{}) {
    85  			fields = append(fields, fieldName)
    86  		})
    87  		if strings.Join(fields, ",") != "a0,a1,ax" {
    88  			t.Errorf("%v", fields)
    89  			return
    90  		}
    91  	}
    92  	{
    93  		fields = nil
    94  		FilterFieldCall("test", simple, "a0,a1|ax#all", func(fieldName, fieldFunc string, field reflect.StructField, value interface{}) {
    95  			fields = append(fields, fieldName)
    96  		})
    97  		if strings.Join(fields, ",") != "a0,a1,ax" {
    98  			t.Errorf("%v", fields)
    99  			return
   100  		}
   101  	}
   102  	{
   103  		fields = nil
   104  		FilterFieldCall("test", simple, "^a0,a1,ax#all", func(fieldName, fieldFunc string, field reflect.StructField, value interface{}) {
   105  			fields = append(fields, fieldName)
   106  		})
   107  		if strings.Join(fields, ",") != "b0,b1,bx,c0,c1,cx,d0,d1,d2,d3" {
   108  			t.Errorf("%v", fields)
   109  			return
   110  		}
   111  	}
   112  	{
   113  		fields = nil
   114  		FilterFieldCall("test", simple, "count(a0),count(a1),ax#all", func(fieldName, fieldFunc string, field reflect.StructField, value interface{}) {
   115  			fields = append(fields, fieldName)
   116  		})
   117  		if strings.Join(fields, ",") != "a0,a1,ax" {
   118  			t.Errorf("%v", fields)
   119  			return
   120  		}
   121  	}
   122  	{
   123  		fields = nil
   124  		FilterFieldCall("test", simple, "t.a0,a1,ax#all", func(fieldName, fieldFunc string, field reflect.StructField, value interface{}) {
   125  			fields = append(fields, fieldName)
   126  		})
   127  		if strings.Join(fields, ",") != "t.a0,t.a1,t.ax" {
   128  			t.Errorf("%v", fields)
   129  			return
   130  		}
   131  	}
   132  	{
   133  		object := struct {
   134  			A0     int64 `json:"a0" valid:"a0,r|i,r:0"`
   135  			Simple `filter:"inline"`
   136  		}{
   137  			A0: 100,
   138  		}
   139  		fields = nil
   140  		FilterFieldCall("test", &object, "a0,a1,ax#all", func(fieldName, fieldFunc string, field reflect.StructField, value interface{}) {
   141  			fields = append(fields, fieldName)
   142  		})
   143  		if strings.Join(fields, ",") != "a0,a0,a1,ax" {
   144  			t.Errorf("%v", fields)
   145  			return
   146  		}
   147  	}
   148  }