dove/option_test.go at main · camry/dove · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
package dove

import (
    "context"
    "log"
    "os"
    "reflect"
    "testing"
    "time"

    "github.com/camry/g/v2/glog"
)

func TestID(t *testing.T) {
    o := &option{}
    v := "123"
    ID(v)(o)
    if !reflect.DeepEqual(v, o.id) {
        t.Fatalf("o.id:%s is not equal to v:%s", o.id, v)
    }
}

func TestName(t *testing.T) {
    o := &option{}
    v := "abc"
    Name(v)(o)
    if !reflect.DeepEqual(v, o.name) {
        t.Fatalf("o.name:%s is not equal to v:%s", o.name, v)
    }
}

func TestVersion(t *testing.T) {
    o := &option{}
    v := "123"
    Version(v)(o)
    if !reflect.DeepEqual(v, o.version) {
        t.Fatalf("o.version:%s is not equal to v:%s", o.version, v)
    }
}

func TestContext(t *testing.T) {
    type ctxKey = struct{}
    o := &option{}
    v := context.WithValue(context.TODO(), ctxKey{}, "b")
    Context(v)(o)
    if !reflect.DeepEqual(v, o.ctx) {
        t.Fatalf("o.ctx:%s is not equal to v:%s", o.ctx, v)
    }
}

func TestLogger(t *testing.T) {
    o := &option{}
    v := glog.NewStdLogger(log.Writer())
    Logger(v)(o)
    if !reflect.DeepEqual(v, o.logger) {
        t.Fatalf("o.logger:%v is not equal to xlog.NewHelper(v):%v", o.logger, glog.NewHelper(v))
    }
}

type mockSignal struct{}

func (m *mockSignal) String() string { return "sig" }
func (m *mockSignal) Signal()        {}

func TestSignal(t *testing.T) {
    o := &option{}
    v := []os.Signal{
        &mockSignal{}, &mockSignal{},
    }
    Signal(v...)(o)
    if !reflect.DeepEqual(v, o.sigs) {
        t.Fatal("o.sigs is not equal to v")
    }
}

func TestStopTimeout(t *testing.T) {
    o := &option{}
    v := time.Duration(123)
    StopTimeout(v)(o)
    if !reflect.DeepEqual(v, o.stopTimeout) {
        t.Fatal("o.stopTimeout is not equal to v")
    }
}

func TestBeforeStart(t *testing.T) {
    o := &option{}
    v := func(_ context.Context) error {
        t.Log("BeforeStart...")
        return nil
    }
    BeforeStart(v)(o)
}

func TestBeforeStop(t *testing.T) {
    o := &option{}
    v := func(_ context.Context) error {
        t.Log("BeforeStop...")
        return nil
    }
    BeforeStop(v)(o)
}

func TestAfterStart(t *testing.T) {
    o := &option{}
    v := func(_ context.Context) error {
        t.Log("AfterStart...")
        return nil
    }
    AfterStart(v)(o)
}

func TestAfterStop(t *testing.T) {
    o := &option{}
    v := func(_ context.Context) error {
        t.Log("AfterStop...")
        return nil
    }
    AfterStop(v)(o)
}