149 lines
2.5 KiB
Go
149 lines
2.5 KiB
Go
package snowflake
|
|
|
|
import (
|
|
"flag"
|
|
"os"
|
|
"reflect"
|
|
"testing"
|
|
"time"
|
|
|
|
"go.uber.org/goleak"
|
|
)
|
|
|
|
func TestMain(m *testing.M) {
|
|
leak := flag.Bool("leak", false, "use leak detector")
|
|
flag.Parse()
|
|
|
|
if *leak {
|
|
goleak.VerifyTestMain(m)
|
|
|
|
return
|
|
}
|
|
|
|
os.Exit(m.Run())
|
|
}
|
|
|
|
func TestSnowflake(t *testing.T) {
|
|
st, err := GetNowDate()
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
t.Parallel()
|
|
|
|
type args struct {
|
|
machineNodeID int64
|
|
startTime time.Time
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
args args
|
|
want *Snowflake
|
|
|
|
wantDeepEqualErr bool
|
|
wantNewNodeErr bool
|
|
}{
|
|
{
|
|
name: "success",
|
|
args: args{
|
|
machineNodeID: 10,
|
|
startTime: st,
|
|
},
|
|
want: &Snowflake{
|
|
machineNodeID: 10,
|
|
startTime: st,
|
|
},
|
|
wantDeepEqualErr: false,
|
|
wantNewNodeErr: false,
|
|
},
|
|
{
|
|
name: "failed machine node ID negative number",
|
|
args: args{
|
|
machineNodeID: -1,
|
|
startTime: time.Time{},
|
|
},
|
|
want: &Snowflake{
|
|
machineNodeID: -1,
|
|
startTime: time.Time{},
|
|
},
|
|
wantDeepEqualErr: false,
|
|
wantNewNodeErr: true,
|
|
},
|
|
{
|
|
name: "failed snowflake struct field by machine node ID",
|
|
args: args{
|
|
machineNodeID: 10,
|
|
startTime: st,
|
|
},
|
|
want: &Snowflake{
|
|
machineNodeID: 2,
|
|
startTime: st,
|
|
},
|
|
wantDeepEqualErr: true,
|
|
wantNewNodeErr: false,
|
|
},
|
|
{
|
|
name: "failed snowflake struct field by startTime",
|
|
args: args{
|
|
machineNodeID: 2,
|
|
startTime: st,
|
|
},
|
|
want: &Snowflake{
|
|
machineNodeID: 2,
|
|
startTime: time.Time{},
|
|
},
|
|
wantDeepEqualErr: true,
|
|
wantNewNodeErr: false,
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
tt := tt
|
|
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
got := New(
|
|
WithMachineNodeID(tt.args.machineNodeID),
|
|
WithStartTime(tt.args.startTime),
|
|
)
|
|
|
|
if !reflect.DeepEqual(got, tt.want) != tt.wantDeepEqualErr {
|
|
t.Errorf("Snowflake.New() = %v, want %v", got, tt.want)
|
|
}
|
|
|
|
node, err := got.NewNode()
|
|
if (err != nil) != tt.wantNewNodeErr {
|
|
t.Errorf("NewNode() = %v, want %v", err != nil, tt.wantNewNodeErr)
|
|
}
|
|
|
|
if err == nil {
|
|
id := node.Generate().Int64()
|
|
if id <= 0 {
|
|
t.Errorf("node.Generate().Int64() = %v, want %s", id, "id > 0")
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func BenchmarkSnowflake(b *testing.B) {
|
|
st, err := GetNowDate()
|
|
if err != nil {
|
|
b.Error(err)
|
|
}
|
|
|
|
snowflake := New(
|
|
WithMachineNodeID(1),
|
|
WithStartTime(st),
|
|
)
|
|
|
|
node, err := snowflake.NewNode()
|
|
if err != nil {
|
|
b.Error(err)
|
|
}
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
node.Generate().Int64()
|
|
}
|
|
}
|