cubefs

1
package proto
2

3
import (
4
	"reflect"
5
	"testing"
6
	"time"
7

8
	"github.com/stretchr/testify/require"
9
)
10

11
func TestGetMaskFromString(t *testing.T) {
12
	cs := []struct {
13
		op  TxOpMask
14
		str string
15
	}{
16
		{TxPause, "pause"},
17
		{TxOpMaskAll, "all"},
18
		{TxOpMaskOff, "off"},
19
		{TxOpMaskCreate, "create"},
20
		{TxOpMaskRename, "rename"},
21
	}
22

23
	for _, c := range cs {
24
		str := GetMaskString(c.op)
25
		require.Equal(t, str, c.str)
26
	}
27
}
28

29
func TestMaskContains(t *testing.T) {
30
	cs := []struct {
31
		total  TxOpMask
32
		sub    TxOpMask
33
		result bool
34
	}{
35
		{TxOpMaskOff, TxOpMaskOff, true},
36
		{TxOpMaskOff, TxOpMaskRemove, false},
37
		{TxOpMaskRemove | TxOpMaskRename, TxOpMaskRename, true},
38
		{TxOpMaskAll, TxPause, false},
39
		{TxOpMaskAll, TxOpMaskRename, true},
40
		{TxPause, TxPause, true},
41
	}
42
	for _, c := range cs {
43
		got := MaskContains(c.total, c.sub)
44
		require.Equal(t, c.result, got)
45
	}
46
}
47

48
func TestTxInodeInfoMarshal(t *testing.T) {
49
	ifo := &TxInodeInfo{
50
		Ino:        101,
51
		MpMembers:  "m1,m2,m3",
52
		MpID:       11,
53
		CreateTime: 10110,
54
		Timeout:    112,
55
		// TxID:       "tx123",
56
	}
57

58
	bs, err := ifo.Marshal()
59
	require.NoError(t, err)
60

61
	nIfo := &TxInodeInfo{}
62
	err = nIfo.Unmarshal(bs)
63
	require.NoError(t, err)
64

65
	require.True(t, reflect.DeepEqual(ifo, nIfo))
66

67
	nIfo.TxID = "txId1"
68
	require.False(t, reflect.DeepEqual(ifo, nIfo))
69
}
70

71
func TestTxDentryInfoMarshal(t *testing.T) {
72
	ifo := &TxDentryInfo{
73
		ParentId:   101,
74
		Name:       "dir1",
75
		MpMembers:  "m1,m2,m3",
76
		MpID:       11,
77
		CreateTime: 10110,
78
		Timeout:    112,
79
		// TxID:       "tx123",
80
	}
81

82
	bs, err := ifo.Marshal()
83
	require.NoError(t, err)
84

85
	nIfo := &TxDentryInfo{}
86
	err = nIfo.Unmarshal(bs)
87
	require.NoError(t, err)
88

89
	require.True(t, reflect.DeepEqual(ifo, nIfo))
90

91
	nIfo.TxID = "txId1"
92
	require.False(t, reflect.DeepEqual(ifo, nIfo))
93
}
94

95
func TestTransactionInfo_Marshal(t *testing.T) {
96
	tx := NewTransactionInfo(1, TxTypeRename)
97
	tx.RMFinish = true
98
	tx.DoneTime = 1012
99
	tx.CreateTime = 101
100
	tx.State = TxStateRollbackDone
101

102
	require.False(t, tx.IsInitialized())
103

104
	inoIfo := &TxInodeInfo{
105
		Ino:  10,
106
		TxID: "tx_11",
107
	}
108
	tx.TxInodeInfos[inoIfo.GetKey()] = inoIfo
109

110
	dIfo := &TxDentryInfo{
111
		ParentId: 10,
112
		Name:     "na1",
113
		TxID:     "tx_11",
114
	}
115
	tx.TxDentryInfos[dIfo.GetKey()] = dIfo
116

117
	bs, err := tx.Marshal()
118
	require.NoError(t, err)
119

120
	ntx := NewTransactionInfo(2, TxTypeLink)
121
	err = ntx.Unmarshal(bs)
122
	require.NoError(t, err)
123
	require.True(t, reflect.DeepEqual(tx, ntx))
124

125
	tx.TxID = "txId_1"
126
	require.False(t, reflect.DeepEqual(tx, ntx))
127

128
	cpTx := tx.Copy().(*TransactionInfo)
129
	require.True(t, reflect.DeepEqual(tx, cpTx))
130
}
131

132
func TestTransactionInfo_SetCreateInodeId(t *testing.T) {
133
	tx := NewTransactionInfo(1, TxTypeRename)
134
	inoIfo := &TxInodeInfo{
135
		TxID: "tx_11",
136
	}
137
	tx.TxInodeInfos[inoIfo.GetKey()] = inoIfo
138

139
	ino := uint64(11)
140
	tx.SetCreateInodeId(ino)
141

142
	nifo := tx.TxInodeInfos[ino]
143
	require.True(t, reflect.DeepEqual(nifo, inoIfo))
144
	require.True(t, len(tx.TxInodeInfos) == 1)
145
}
146

147
func TestTransactionInfo_Less(t *testing.T) {
148
	tx := &TransactionInfo{
149
		TxID: "10_11",
150
	}
151
	tx2 := &TransactionInfo{
152
		TxID: "11_10",
153
	}
154
	require.True(t, tx.Less(tx2))
155
}
156

157
func TestTransactionInfo_GroupByMp(t *testing.T) {
158
	mp1, mp2 := uint64(1), uint64(2)
159
	addr1, addr2 := "m1,m1", "m2,m2"
160

161
	ino1 := &TxInodeInfo{
162
		Ino:       1,
163
		MpID:      mp1,
164
		MpMembers: addr1,
165
	}
166
	ino2 := &TxInodeInfo{
167
		Ino:       2,
168
		MpID:      mp2,
169
		MpMembers: addr2,
170
	}
171
	d1 := &TxDentryInfo{
172
		ParentId:  1,
173
		MpID:      mp1,
174
		MpMembers: addr1,
175
	}
176
	d2 := &TxDentryInfo{
177
		ParentId:  2,
178
		MpID:      mp2,
179
		MpMembers: addr2,
180
	}
181

182
	tx := NewTransactionInfo(0, TxTypeRename)
183
	tx.TxInodeInfos[ino1.GetKey()] = ino1
184
	tx.TxInodeInfos[ino2.GetKey()] = ino2
185
	tx.TxDentryInfos[d1.GetKey()] = d1
186
	tx.TxDentryInfos[d2.GetKey()] = d2
187

188
	mps := tx.GroupByMp()
189
	require.True(t, len(mps) == 2)
190
	for id, mp := range mps {
191
		if id == mp1 {
192
			require.Equal(t, addr1, mp.Members)
193
		} else {
194
			require.Equal(t, addr2, mp.Members)
195
		}
196
		require.Equal(t, len(mp.TxDentryInfos), 1)
197
		require.Equal(t, len(mp.TxInodeInfos), 1)
198
	}
199
}
200

201
func TestTxFunc(t *testing.T) {
202
	tx := NewTransactionInfo(1, TxTypeRename)
203

204
	require.False(t, tx.IsDone())
205
	tx.State = TxStateRollbackDone
206
	require.True(t, tx.IsDone())
207
	tx.State = TxStateCommitDone
208
	require.True(t, tx.IsDone())
209

210
	// can finish
211
	tx.RMFinish = true
212
	tx.DoneTime = time.Now().Unix() - 130
213
	require.True(t, tx.CanDelete())
214

215
	tx.DoneTime = time.Now().Unix() - 61
216
	require.True(t, tx.IsExpired())
217
}
218