github.com/gogf/gf@v1.16.9/util/gconv/gconv_z_unit_scan_test.go (about)

     1  // Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
     2  //
     3  // This Source Code Form is subject to the terms of the MIT License.
     4  // If a copy of the MIT was not distributed with this file,
     5  // You can obtain one at https://github.com/gogf/gf.
     6  
     7  package gconv_test
     8  
     9  import (
    10  	"github.com/gogf/gf/frame/g"
    11  	"github.com/gogf/gf/test/gtest"
    12  	"github.com/gogf/gf/util/gconv"
    13  	"testing"
    14  )
    15  
    16  func Test_Scan_StructStructs(t *testing.T) {
    17  	type User struct {
    18  		Uid   int
    19  		Name  string
    20  		Pass1 string `gconv:"password1"`
    21  		Pass2 string `gconv:"password2"`
    22  	}
    23  	gtest.C(t, func(t *gtest.T) {
    24  		var (
    25  			user   = new(User)
    26  			params = g.Map{
    27  				"uid":   1,
    28  				"name":  "john",
    29  				"PASS1": "123",
    30  				"PASS2": "456",
    31  			}
    32  		)
    33  		err := gconv.Scan(params, user)
    34  		t.Assert(err, nil)
    35  		t.Assert(user, &User{
    36  			Uid:   1,
    37  			Name:  "john",
    38  			Pass1: "123",
    39  			Pass2: "456",
    40  		})
    41  	})
    42  	gtest.C(t, func(t *gtest.T) {
    43  		var (
    44  			users  []User
    45  			params = g.Slice{
    46  				g.Map{
    47  					"uid":   1,
    48  					"name":  "john1",
    49  					"PASS1": "111",
    50  					"PASS2": "222",
    51  				},
    52  				g.Map{
    53  					"uid":   2,
    54  					"name":  "john2",
    55  					"PASS1": "333",
    56  					"PASS2": "444",
    57  				},
    58  			}
    59  		)
    60  		err := gconv.Scan(params, &users)
    61  		t.AssertNil(err)
    62  		t.Assert(users, g.Slice{
    63  			&User{
    64  				Uid:   1,
    65  				Name:  "john1",
    66  				Pass1: "111",
    67  				Pass2: "222",
    68  			},
    69  			&User{
    70  				Uid:   2,
    71  				Name:  "john2",
    72  				Pass1: "333",
    73  				Pass2: "444",
    74  			},
    75  		})
    76  	})
    77  }
    78  
    79  func Test_Scan_StructStr(t *testing.T) {
    80  	type User struct {
    81  		Uid   int
    82  		Name  string
    83  		Pass1 string `gconv:"password1"`
    84  		Pass2 string `gconv:"password2"`
    85  	}
    86  	gtest.C(t, func(t *gtest.T) {
    87  		var (
    88  			user   = new(User)
    89  			params = `{"uid":1,"name":"john", "pass1":"123","pass2":"456"}`
    90  		)
    91  		err := gconv.Scan(params, user)
    92  		t.Assert(err, nil)
    93  		t.Assert(user, &User{
    94  			Uid:   1,
    95  			Name:  "john",
    96  			Pass1: "123",
    97  			Pass2: "456",
    98  		})
    99  	})
   100  	gtest.C(t, func(t *gtest.T) {
   101  		var (
   102  			users  []User
   103  			params = `[
   104  {"uid":1,"name":"john1", "pass1":"111","pass2":"222"},
   105  {"uid":2,"name":"john2", "pass1":"333","pass2":"444"}
   106  ]`
   107  		)
   108  		err := gconv.Scan(params, &users)
   109  		t.Assert(err, nil)
   110  		t.Assert(users, g.Slice{
   111  			&User{
   112  				Uid:   1,
   113  				Name:  "john1",
   114  				Pass1: "111",
   115  				Pass2: "222",
   116  			},
   117  			&User{
   118  				Uid:   2,
   119  				Name:  "john2",
   120  				Pass1: "333",
   121  				Pass2: "444",
   122  			},
   123  		})
   124  	})
   125  }
   126  
   127  func Test_Scan_Map(t *testing.T) {
   128  	gtest.C(t, func(t *gtest.T) {
   129  		var m map[string]string
   130  		data := g.Map{
   131  			"k1": "v1",
   132  			"k2": "v2",
   133  		}
   134  		err := gconv.Scan(data, &m)
   135  		t.AssertNil(err)
   136  		t.Assert(data, m)
   137  	})
   138  	gtest.C(t, func(t *gtest.T) {
   139  		var m map[int]int
   140  		data := g.Map{
   141  			"1": "11",
   142  			"2": "22",
   143  		}
   144  		err := gconv.Scan(data, &m)
   145  		t.AssertNil(err)
   146  		t.Assert(data, m)
   147  	})
   148  	// json string parameter.
   149  	gtest.C(t, func(t *gtest.T) {
   150  		var m map[string]string
   151  		data := `{"k1":"v1","k2":"v2"}`
   152  		err := gconv.Scan(data, &m)
   153  		t.AssertNil(err)
   154  		t.Assert(m, g.Map{
   155  			"k1": "v1",
   156  			"k2": "v2",
   157  		})
   158  	})
   159  }
   160  
   161  func Test_Scan_Maps(t *testing.T) {
   162  	gtest.C(t, func(t *gtest.T) {
   163  		var maps []map[string]string
   164  		data := g.Slice{
   165  			g.Map{
   166  				"k1": "v1",
   167  				"k2": "v2",
   168  			},
   169  			g.Map{
   170  				"k3": "v3",
   171  				"k4": "v4",
   172  			},
   173  		}
   174  		err := gconv.Scan(data, &maps)
   175  		t.AssertNil(err)
   176  		t.Assert(data, maps)
   177  	})
   178  	// json string parameter.
   179  	gtest.C(t, func(t *gtest.T) {
   180  		var maps []map[string]string
   181  		data := `[{"k1":"v1","k2":"v2"},{"k3":"v3","k4":"v4"}]`
   182  		err := gconv.Scan(data, &maps)
   183  		t.AssertNil(err)
   184  		t.Assert(maps, g.Slice{
   185  			g.Map{
   186  				"k1": "v1",
   187  				"k2": "v2",
   188  			},
   189  			g.Map{
   190  				"k3": "v3",
   191  				"k4": "v4",
   192  			},
   193  		})
   194  	})
   195  }