github.com/altipla-consulting/ravendb-go-client@v0.1.3/reflect_test.go (about)

     1  package ravendb
     2  
     3  import (
     4  	"bytes"
     5  	"fmt"
     6  	"reflect"
     7  	"testing"
     8  
     9  	"github.com/stretchr/testify/assert"
    10  )
    11  
    12  type FooStruct struct {
    13  	S string
    14  	N int
    15  }
    16  
    17  func TestTypeName(t *testing.T) {
    18  	v := FooStruct{}
    19  	name := getFullTypeName(v)
    20  	assert.Equal(t, "ravendb.FooStruct", name)
    21  	name = getFullTypeName(&v)
    22  	assert.Equal(t, "ravendb.FooStruct", name)
    23  	name = getShortTypeNameForEntity(v)
    24  	assert.Equal(t, "FooStruct", name)
    25  	name = getShortTypeNameForEntity(&v)
    26  	assert.Equal(t, "FooStruct", name)
    27  }
    28  
    29  func TestMakeStructFromJSONMap(t *testing.T) {
    30  	s := &FooStruct{
    31  		S: "str",
    32  		N: 5,
    33  	}
    34  	jsmap := structToJSONMap(s)
    35  	vd, err := jsonMarshal(s)
    36  	assert.NoError(t, err)
    37  	typ := reflect.TypeOf(s)
    38  	v2, err := makeStructFromJSONMap(typ, jsmap)
    39  
    40  	assert.NoError(t, err)
    41  	vTyp := fmt.Sprintf("%T", s)
    42  	v2Typ := fmt.Sprintf("%T", v2)
    43  	assert.Equal(t, vTyp, v2Typ)
    44  	v2d, err := jsonMarshal(v2)
    45  	assert.NoError(t, err)
    46  	if !bytes.Equal(vd, v2d) {
    47  		t.Fatalf("'%s' != '%s'", string(vd), string(v2d))
    48  	}
    49  
    50  	{
    51  		s2 := v2.(*FooStruct)
    52  		assert.Equal(t, s.S, s2.S)
    53  		assert.Equal(t, s.N, s2.N)
    54  	}
    55  }
    56  
    57  func TestIsStructy(t *testing.T) {
    58  	v := FooStruct{}
    59  	typ, ok := getStructTypeOfValue(v)
    60  	assert.True(t, ok && typ.Kind() == reflect.Struct)
    61  	typ, ok = getStructTypeOfValue(&v)
    62  	assert.True(t, ok && typ.Kind() == reflect.Struct)
    63  	v2 := "str"
    64  	_, ok = getStructTypeOfValue(v2)
    65  	assert.False(t, ok)
    66  }
    67  
    68  func TestIsMapStringToPtrStruct(t *testing.T) {
    69  	{
    70  		v := map[string]*User{}
    71  		tp, ok := isMapStringToPtrStruct(reflect.TypeOf(v))
    72  		assert.True(t, ok)
    73  		assert.Equal(t, reflect.TypeOf(&User{}), tp)
    74  	}
    75  	vals := []interface{}{
    76  		1, true, 3.8, "string", []*User{}, map[string]User{}, map[int]*User{}, User{}, &User{},
    77  	}
    78  	for _, v := range vals {
    79  		_, ok := isMapStringToPtrStruct(reflect.TypeOf(v))
    80  		assert.False(t, ok)
    81  	}
    82  }
    83  
    84  func TestGetIdentityProperty(t *testing.T) {
    85  	got := getIdentityProperty(reflect.TypeOf(""))
    86  	assert.Equal(t, "", got)
    87  	got = getIdentityProperty(reflect.TypeOf(User{}))
    88  	assert.Equal(t, "ID", got)
    89  	got = getIdentityProperty(reflect.TypeOf(&User{}))
    90  	assert.Equal(t, "ID", got)
    91  
    92  	{
    93  		// field not named ID
    94  		v := struct {
    95  			Id string
    96  		}{}
    97  		got = getIdentityProperty(reflect.TypeOf(v))
    98  		assert.Equal(t, "", got)
    99  	}
   100  
   101  	{
   102  		// field named ID but not stringa
   103  		v := struct {
   104  			ID int
   105  		}{}
   106  		got = getIdentityProperty(reflect.TypeOf(v))
   107  		assert.Equal(t, "", got)
   108  	}
   109  
   110  }