github.com/snowflakedb/gosnowflake@v1.9.0/location_test.go (about)

     1  // Copyright (c) 2017-2022 Snowflake Computing Inc. All rights reserved.
     2  
     3  package gosnowflake
     4  
     5  import (
     6  	"errors"
     7  	"fmt"
     8  	"reflect"
     9  	"testing"
    10  	"time"
    11  )
    12  
    13  type tcLocation struct {
    14  	ss  string
    15  	tt  string
    16  	err error
    17  }
    18  
    19  func TestWithOffsetString(t *testing.T) {
    20  	testcases := []tcLocation{
    21  		{
    22  			ss:  "+0700",
    23  			tt:  "+0700",
    24  			err: nil,
    25  		},
    26  		{
    27  			ss:  "-1200",
    28  			tt:  "-1200",
    29  			err: nil,
    30  		},
    31  		{
    32  			ss:  "+0710",
    33  			tt:  "+0710",
    34  			err: nil,
    35  		},
    36  		{
    37  			ss: "1200",
    38  			tt: "",
    39  			err: &SnowflakeError{
    40  				Number:      ErrInvalidOffsetStr,
    41  				Message:     errMsgInvalidOffsetStr,
    42  				MessageArgs: []interface{}{"1200"},
    43  			},
    44  		},
    45  		{
    46  			ss: "x1200",
    47  			tt: "",
    48  			err: &SnowflakeError{
    49  				Number:      ErrInvalidOffsetStr,
    50  				Message:     errMsgInvalidOffsetStr,
    51  				MessageArgs: []interface{}{"x1200"},
    52  			},
    53  		},
    54  		{
    55  			ss: "+12001",
    56  			tt: "",
    57  			err: &SnowflakeError{
    58  				Number:      ErrInvalidOffsetStr,
    59  				Message:     errMsgInvalidOffsetStr,
    60  				MessageArgs: []interface{}{"+12001"},
    61  			},
    62  		},
    63  		{
    64  			ss: "x12001",
    65  			tt: "",
    66  			err: &SnowflakeError{
    67  				Number:      ErrInvalidOffsetStr,
    68  				Message:     errMsgInvalidOffsetStr,
    69  				MessageArgs: []interface{}{"x12001"},
    70  			},
    71  		},
    72  		{
    73  			ss:  "-12CD",
    74  			tt:  "",
    75  			err: errors.New("parse int error"), // can this be more specific?
    76  		},
    77  		{
    78  			ss:  "+ABCD",
    79  			tt:  "",
    80  			err: errors.New("parse int error"), // can this be more specific?
    81  		},
    82  	}
    83  	for _, t0 := range testcases {
    84  		t.Run(t0.ss, func(t *testing.T) {
    85  			loc, err := LocationWithOffsetString(t0.ss)
    86  			if t0.err != nil {
    87  				if t0.err != err {
    88  					driverError1, ok1 := t0.err.(*SnowflakeError)
    89  					driverError2, ok2 := err.(*SnowflakeError)
    90  					if ok1 && ok2 && driverError1.Number != driverError2.Number {
    91  						t.Fatalf("error expected: %v, got: %v", t0.err, err)
    92  					}
    93  				}
    94  			} else {
    95  				if err != nil {
    96  					t.Fatalf("%v", err)
    97  				}
    98  				if t0.tt != loc.String() {
    99  					t.Fatalf("location string didn't match. expected: %v, got: %v", t0.tt, loc)
   100  				}
   101  			}
   102  		})
   103  	}
   104  }
   105  
   106  func TestGetCurrentLocation(t *testing.T) {
   107  	specificTz := "Pacific/Honolulu"
   108  	specificLoc, err := time.LoadLocation(specificTz)
   109  	if err != nil {
   110  		t.Fatalf("Cannot initialize specific timezone location")
   111  	}
   112  	incorrectTz := "Not/exists"
   113  	testcases := []struct {
   114  		params map[string]*string
   115  		loc    *time.Location
   116  	}{
   117  		{
   118  			params: map[string]*string{},
   119  			loc:    time.Now().Location(),
   120  		},
   121  		{
   122  			params: map[string]*string{
   123  				"timezone": nil,
   124  			},
   125  			loc: time.Now().Location(),
   126  		},
   127  		{
   128  			params: map[string]*string{
   129  				"timezone": &specificTz,
   130  			},
   131  			loc: specificLoc,
   132  		},
   133  		{
   134  			params: map[string]*string{
   135  				"timezone": &incorrectTz,
   136  			},
   137  			loc: time.Now().Location(),
   138  		},
   139  	}
   140  	for _, tc := range testcases {
   141  		t.Run(fmt.Sprintf("%v", tc.loc), func(t *testing.T) {
   142  			loc := getCurrentLocation(tc.params)
   143  			if !reflect.DeepEqual(*loc, *tc.loc) {
   144  				t.Fatalf("location mismatch. expected: %v, got: %v", tc.loc, loc)
   145  			}
   146  		})
   147  	}
   148  }