cubefs

1
// Copyright 2018 The CubeFS Authors.
2
//
3
// Licensed under the Apache License, Version 2.0 (the "License");
4
// you may not use this file except in compliance with the License.
5
// You may obtain a copy of the License at
6
//
7
//     http://www.apache.org/licenses/LICENSE-2.0
8
//
9
// Unless required by applicable law or agreed to in writing, software
10
// distributed under the License is distributed on an "AS IS" BASIS,
11
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
12
// implied. See the License for the specific language governing
13
// permissions and limitations under the License.
14

15
package metanode
16

17
import (
18
	"math/rand"
19
	"reflect"
20
	"testing"
21
	"time"
22

23
	"github.com/cubefs/cubefs/util"
24
)
25

26
func TestMUPart_Bytes(t *testing.T) {
27
	var (
28
		id         uint16 = 1
29
		uploadTime        = time.Now().Local()
30
		md5               = util.RandomString(16, util.UpperLetter|util.Numeric)
31
		size       uint64 = 65536
32
		inode      uint64 = 12345
33
		err        error
34
	)
35
	part1 := &Part{
36
		ID:         id,
37
		UploadTime: uploadTime,
38
		MD5:        md5,
39
		Size:       size,
40
		Inode:      inode,
41
	}
42
	var partBytes []byte
43
	if partBytes, err = part1.Bytes(); err != nil {
44
		t.Fatalf("get bytes of part fail cause: %v", err)
45
	}
46
	part2 := PartFromBytes(partBytes)
47
	if !reflect.DeepEqual(part1, part2) {
48
		t.Fatalf("result mismatch:\n\tpart1:%v\n\tpart2:%v", part1, part2)
49
	}
50
	t.Logf("encoded length: %v", len(partBytes))
51
}
52

53
func TestMUParts_Bytes(t *testing.T) {
54
	var err error
55
	random := rand.New(rand.NewSource(time.Now().UnixNano()))
56
	parts1 := PartsFromBytes(nil)
57
	for i := 0; i < 100; i++ {
58
		part := &Part{
59
			ID:         uint16(i),
60
			UploadTime: time.Now().Local(),
61
			MD5:        util.RandomString(16, util.UpperLetter|util.Numeric),
62
			Size:       random.Uint64(),
63
			Inode:      random.Uint64(),
64
		}
65
		parts1.Insert(part, false)
66
	}
67
	var partsBytes []byte
68
	partsBytes, err = parts1.Bytes()
69
	if partsBytes, err = parts1.Bytes(); err != nil {
70
		t.Fatalf("get bytes of part fail cause: %v", err)
71
	}
72
	parts2 := PartsFromBytes(partsBytes)
73
	if !reflect.DeepEqual(parts1, parts2) {
74
		t.Fatalf("result mismatch:\n\tpart1:%v\n\tpart2:%v", parts1, parts2)
75
	}
76
	t.Logf("encoded length: %v", len(partsBytes))
77
}
78

79
func TestMUParts_Modify(t *testing.T) {
80
	random := rand.New(rand.NewSource(time.Now().UnixNano()))
81
	parts := PartsFromBytes(nil)
82
	for i := 0; i < 100; i++ {
83
		part := &Part{
84
			ID:         uint16(i),
85
			UploadTime: time.Now().Local(),
86
			MD5:        util.RandomString(16, util.UpperLetter|util.Numeric),
87
			Size:       random.Uint64(),
88
			Inode:      random.Uint64(),
89
		}
90
		parts.Insert(part, false)
91
	}
92
	if parts.Len() != 100 {
93
		t.Fatalf("parts length mismatch: except 100 actual %v", parts.Len())
94
	}
95
	// validate before modify
96
	if _, found := parts.Search(0); !found {
97
		t.Fatalf("part id[0] not found before modify")
98
	}
99
	if _, found := parts.Search(50); !found {
100
		t.Fatalf("part id[50] not found before modify")
101
	}
102
	if _, found := parts.Search(99); !found {
103
		t.Fatalf("part id[99] not found before modify")
104
	}
105
	// modify
106
	parts.Remove(0)
107
	parts.Remove(50)
108
	parts.Remove(99)
109
	if parts.Len() != 97 {
110
		t.Fatalf("parts length mismatch: expect 97 actual %v", parts.Len())
111
	}
112
	// validate after modify
113
	if _, found := parts.Search(0); found {
114
		t.Fatalf("part id[0] not found before modify")
115
	}
116
	if _, found := parts.Search(50); found {
117
		t.Fatalf("part id[50] not found before modify")
118
	}
119
	if _, found := parts.Search(99); found {
120
		t.Fatalf("part id[99] not found before modify")
121
	}
122
}
123

124
func TestMUSession_Bytes(t *testing.T) {
125
	var err error
126
	random := rand.New(rand.NewSource(time.Now().UnixNano()))
127
	session1 := MultipartFromBytes(nil)
128

129
	me := NewMultipartExtend()
130
	me["oss::tag"] = "name=123&age456"
131
	me["oss::disposition"] = "attachment=file.txt"
132
	session1.extend = me
133
	for i := 0; i < 100; i++ {
134
		id := uint16(i)
135
		md5 := util.RandomString(16, util.UpperLetter|util.Numeric)
136
		size := random.Uint64()
137
		inode := random.Uint64()
138
		session1.InsertPart(&Part{
139
			ID:         id,
140
			MD5:        md5,
141
			Size:       size,
142
			Inode:      inode,
143
			UploadTime: time.Now().Local(),
144
		}, false)
145
	}
146
	var sessionBytes []byte
147
	sessionBytes, err = session1.Bytes()
148
	if err != nil {
149
		t.Fatalf("encode session to bytes fail caue: %v", err)
150
	}
151
	session2 := MultipartFromBytes(sessionBytes)
152
	if !reflect.DeepEqual(session1, session2) {
153
		t.Fatalf("result mismatch:\n\tsession1:%v\n\tsession2:%v", session1, session2)
154
	}
155
	t.Logf("encoded session length: %v", len(sessionBytes))
156
}
157

158
func TestMultipartExtend_Bytes(t *testing.T) {
159
	me := NewMultipartExtend()
160
	me["oss::tag"] = "name=123&age456"
161
	me["oss::disposition"] = "attachment=file.txt"
162
	bytes, err := me.Bytes()
163
	if err != nil {
164
		t.Errorf("Encode multipart extend fail cause : %v", err)
165
	}
166
	me2 := MultipartExtendFromBytes(bytes)
167
	if !reflect.DeepEqual(me, me2) {
168
		t.Fatalf("result mismatch:\n\tme1:%v\n\tme2:%v", me, me2)
169
	}
170
}
171