github.com/seeker-insurance/kit@v0.0.13/db/null/zero/string_test.go (about)

     1  package zero
     2  
     3  import (
     4  	"encoding/json"
     5  	"testing"
     6  )
     7  
     8  var (
     9  	stringJSON      = []byte(`"test"`)
    10  	blankStringJSON = []byte(`""`)
    11  	nullStringJSON  = []byte(`{"String":"test","Valid":true}`)
    12  
    13  	nullJSON    = []byte(`null`)
    14  	invalidJSON = []byte(`:)`)
    15  )
    16  
    17  type stringInStruct struct {
    18  	Test String `json:"test,omitempty"`
    19  }
    20  
    21  func TestStringFrom(t *testing.T) {
    22  	str := StringFrom("test")
    23  	assertStr(t, str, "StringFrom() string")
    24  
    25  	null := StringFrom("")
    26  	assertNullStr(t, null, "StringFrom() empty string")
    27  }
    28  
    29  func TestUnmarshalString(t *testing.T) {
    30  	var str String
    31  	err := json.Unmarshal(stringJSON, &str)
    32  	maybePanic(err)
    33  	assertStr(t, str, "string json")
    34  
    35  	var ns String
    36  	err = json.Unmarshal(nullStringJSON, &ns)
    37  	maybePanic(err)
    38  	assertStr(t, ns, "sql.NullString json")
    39  
    40  	var blank String
    41  	err = json.Unmarshal(blankStringJSON, &blank)
    42  	maybePanic(err)
    43  	assertNullStr(t, blank, "blank string json")
    44  
    45  	var null String
    46  	err = json.Unmarshal(nullJSON, &null)
    47  	maybePanic(err)
    48  	assertNullStr(t, null, "null json")
    49  
    50  	var badType String
    51  	err = json.Unmarshal(boolJSON, &badType)
    52  	if err == nil {
    53  		panic("err should not be nil")
    54  	}
    55  	assertNullStr(t, badType, "wrong type json")
    56  
    57  	var invalid String
    58  	err = invalid.UnmarshalJSON(invalidJSON)
    59  	if _, ok := err.(*json.SyntaxError); !ok {
    60  		t.Errorf("expected json.SyntaxError, not %T", err)
    61  	}
    62  	assertNullStr(t, invalid, "invalid json")
    63  }
    64  
    65  func TestTextUnmarshalString(t *testing.T) {
    66  	var str String
    67  	err := str.UnmarshalText([]byte("test"))
    68  	maybePanic(err)
    69  	assertStr(t, str, "UnmarshalText() string")
    70  
    71  	var null String
    72  	err = null.UnmarshalText([]byte(""))
    73  	maybePanic(err)
    74  	assertNullStr(t, null, "UnmarshalText() empty string")
    75  }
    76  
    77  func TestMarshalString(t *testing.T) {
    78  	str := StringFrom("test")
    79  	data, err := json.Marshal(str)
    80  	maybePanic(err)
    81  	assertJSONEquals(t, data, `"test"`, "non-empty json marshal")
    82  
    83  	// invalid values should be encoded as an empty string
    84  	null := StringFrom("")
    85  	data, err = json.Marshal(null)
    86  	maybePanic(err)
    87  	assertJSONEquals(t, data, `""`, "empty json marshal")
    88  }
    89  
    90  // Tests omitempty... broken until Go 1.4
    91  // func TestMarshalStringInStruct(t *testing.T) {
    92  // 	obj := stringInStruct{Test: StringFrom("")}
    93  // 	data, err := json.Marshal(obj)
    94  // 	maybePanic(err)
    95  // 	assertJSONEquals(t, data, `{}`, "null string in struct")
    96  // }
    97  
    98  func TestStringPointer(t *testing.T) {
    99  	str := StringFrom("test")
   100  	ptr := str.Ptr()
   101  	if *ptr != "test" {
   102  		t.Errorf("bad %s string: %#v ≠ %s\n", "pointer", ptr, "test")
   103  	}
   104  
   105  	null := StringFrom("")
   106  	ptr = null.Ptr()
   107  	if ptr != nil {
   108  		t.Errorf("bad %s string: %#v ≠ %s\n", "nil pointer", ptr, "nil")
   109  	}
   110  }
   111  
   112  func TestStringFromPointer(t *testing.T) {
   113  	test := "test"
   114  	testptr := &test
   115  	str := StringFromPtr(testptr)
   116  	assertStr(t, str, "StringFromPtr()")
   117  
   118  	testptr = nil
   119  	null := StringFromPtr(testptr)
   120  	assertNullStr(t, null, "StringFromPtr()")
   121  
   122  	ptr := null.Ptr()
   123  	if ptr != nil {
   124  		t.Errorf("bad %s string: %#v ≠ %s\n", "nil pointer", ptr, "nil")
   125  	}
   126  }
   127  
   128  func TestStringIsZero(t *testing.T) {
   129  	str := StringFrom("test")
   130  	if str.IsZero() {
   131  		t.Errorf("IsZero() should be false")
   132  	}
   133  
   134  	null := StringFrom("")
   135  	if !null.IsZero() {
   136  		t.Errorf("IsZero() should be true")
   137  	}
   138  
   139  	empty := NewString("", true)
   140  	if !empty.IsZero() {
   141  		t.Errorf("IsZero() should be true")
   142  	}
   143  }
   144  
   145  func TestStringScan(t *testing.T) {
   146  	var str String
   147  	err := str.Scan("test")
   148  	maybePanic(err)
   149  	assertStr(t, str, "scanned string")
   150  
   151  	var null String
   152  	err = null.Scan(nil)
   153  	maybePanic(err)
   154  	assertNullStr(t, null, "scanned null")
   155  }
   156  
   157  func TestStringSetValid(t *testing.T) {
   158  	change := NewString("", false)
   159  	assertNullStr(t, change, "SetValid()")
   160  	change.SetValid("test")
   161  	assertStr(t, change, "SetValid()")
   162  }
   163  
   164  func maybePanic(err error) {
   165  	if err != nil {
   166  		panic(err)
   167  	}
   168  }
   169  
   170  func assertStr(t *testing.T, s String, from string) {
   171  	if s.String != "test" {
   172  		t.Errorf("bad %s string: %s ≠ %s\n", from, s.String, "test")
   173  	}
   174  	if !s.Valid {
   175  		t.Error(from, "is invalid, but should be valid")
   176  	}
   177  }
   178  
   179  func assertNullStr(t *testing.T, s String, from string) {
   180  	if s.Valid {
   181  		t.Error(from, "is valid, but should be invalid")
   182  	}
   183  }
   184  
   185  func assertJSONEquals(t *testing.T, data []byte, cmp string, from string) {
   186  	if string(data) != cmp {
   187  		t.Errorf("bad %s data: %s ≠ %s\n", from, data, cmp)
   188  	}
   189  }