git.zd.zone/hrpc/hrpc@v0.0.12/types/timestamp_test.go (about)

     1  package types
     2  
     3  import (
     4  	"encoding/json"
     5  	"reflect"
     6  	"testing"
     7  	"time"
     8  
     9  	"go.mongodb.org/mongo-driver/bson"
    10  )
    11  
    12  type temp struct {
    13  	Create Timestamp
    14  	Name   string
    15  }
    16  
    17  func TestTimestamp_MarshalJSON(t *testing.T) {
    18  	type fields struct {
    19  		Time time.Time
    20  	}
    21  	tests := []struct {
    22  		name    string
    23  		fields  fields
    24  		want    []byte
    25  		wantErr bool
    26  	}{
    27  		{
    28  			name:    "Test1",
    29  			fields:  fields{Time: time.Unix(1643549328, 0)},
    30  			want:    []byte(`{"Create":1643549328,"Name":"test1"}`),
    31  			wantErr: false,
    32  		},
    33  	}
    34  	for _, tt := range tests {
    35  		t.Run(tt.name, func(t *testing.T) {
    36  			tr := temp{
    37  				Create: Timestamp{tt.fields.Time},
    38  				Name:   "test1",
    39  			}
    40  
    41  			got, err := json.Marshal(tr)
    42  			if (err != nil) != tt.wantErr {
    43  				t.Errorf("Timestamp.MarshalJSON() error = %v, wantErr %v", err, tt.wantErr)
    44  				return
    45  			}
    46  			if !reflect.DeepEqual(got, tt.want) {
    47  				t.Errorf("Timestamp.MarshalJSON() = %v, want %v", string(got), tt.want)
    48  			}
    49  		})
    50  	}
    51  }
    52  
    53  func TestTimestamp_MarshalBSON(t *testing.T) {
    54  	tests := []struct {
    55  		name    string
    56  		fields  time.Time
    57  		want    []byte
    58  		wantErr bool
    59  	}{
    60  		{
    61  			name:    "Test1",
    62  			fields:  time.Unix(1643549328, 0),
    63  			wantErr: false,
    64  		},
    65  	}
    66  	for _, tt := range tests {
    67  		t.Run(tt.name, func(t *testing.T) {
    68  			tr := temp{
    69  				Create: Timestamp{tt.fields},
    70  				Name:   "test1",
    71  			}
    72  			got, err := bson.Marshal(tr)
    73  			if (err != nil) != tt.wantErr {
    74  				t.Errorf("Timestamp.MarshalJSON() error = %v, wantErr %v", err, tt.wantErr)
    75  				return
    76  			}
    77  			model := struct {
    78  				Create time.Time
    79  				Name   string
    80  			}{
    81  				Create: time.Unix(1643549328, 0),
    82  				Name:   "test1",
    83  			}
    84  			tt.want, err = bson.Marshal(&model)
    85  			if (err != nil) != tt.wantErr {
    86  				t.Errorf("Time.MarshalJSON() error = %v, wantErr %v", err, tt.wantErr)
    87  				return
    88  			}
    89  			if !reflect.DeepEqual(got, tt.want) {
    90  				t.Errorf("Timestamp.MarshalJSON() = %v, want %v", string(got), tt.want)
    91  			}
    92  		})
    93  	}
    94  }
    95  
    96  func TestTimestamp_UnmarshalBSON(t *testing.T) {
    97  	tests := []struct {
    98  		name    string
    99  		fields  time.Time
   100  		want    time.Time
   101  		wantErr bool
   102  	}{
   103  		{
   104  			name:    "Test1",
   105  			fields:  time.Unix(1643549328, 0),
   106  			want:    time.Unix(1643549328, 0),
   107  			wantErr: false,
   108  		},
   109  	}
   110  	for _, tt := range tests {
   111  		t.Run(tt.name, func(t *testing.T) {
   112  			tr := temp{
   113  				Create: Timestamp{tt.fields},
   114  				Name:   "test1",
   115  			}
   116  			marshalled, err := bson.Marshal(tr)
   117  			if (err != nil) != tt.wantErr {
   118  				t.Errorf("Timestamp.MarshalJSON() error = %v, wantErr %v", err, tt.wantErr)
   119  				return
   120  			}
   121  			var unmarshalled temp
   122  			err = bson.Unmarshal(marshalled, &unmarshalled)
   123  			if (err != nil) != tt.wantErr {
   124  				t.Errorf("Timestamp.UnmarshalJSON() error = %v, wantErr %v", err, tt.wantErr)
   125  				return
   126  			}
   127  			if !unmarshalled.Create.Time.Equal(tt.want) {
   128  				t.Errorf("Timestamp.MarshalJSON() = %v, want %v", unmarshalled.Create.Time, tt.want)
   129  			}
   130  		})
   131  	}
   132  }
   133  
   134  func TestTimestamp_Scan(t *testing.T) {
   135  	type args struct {
   136  		src interface{}
   137  	}
   138  	tests := []struct {
   139  		name    string
   140  		args    args
   141  		wantErr bool
   142  	}{
   143  		{
   144  			name:    "Test1",
   145  			args:    args{src: []byte("1643549035")},
   146  			wantErr: false,
   147  		},
   148  	}
   149  	for _, tt := range tests {
   150  		t.Run(tt.name, func(t *testing.T) {
   151  			tr := Timestamp{}
   152  			if err := tr.Scan(tt.args.src); (err != nil) != tt.wantErr {
   153  				t.Errorf("Timestamp.Scan() error = %v, wantErr %v", err, tt.wantErr)
   154  			}
   155  		})
   156  	}
   157  }