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
120
121
122
123
124
125
126
127
128
129
130
131
|
package driver
import (
"testing"
"github.com/google/go-cmp/cmp"
"go.mongodb.org/mongo-driver/internal/testutil/assert"
"go.mongodb.org/mongo-driver/x/bsonx/bsoncore"
)
func TestBatches(t *testing.T) {
t.Run("Valid", func(t *testing.T) {
testCases := []struct {
name string
batches *Batches
want bool
}{
{"nil", nil, false},
{"missing identifier", &Batches{}, false},
{"no documents", &Batches{Identifier: "documents"}, false},
{"valid", &Batches{Identifier: "documents", Documents: make([]bsoncore.Document, 5)}, true},
}
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
want := tc.want
got := tc.batches.Valid()
if got != want {
t.Errorf("Did not get expected result from Valid. got %t; want %t", got, want)
}
})
}
})
t.Run("ClearBatch", func(t *testing.T) {
batches := &Batches{Identifier: "documents", Current: make([]bsoncore.Document, 2, 10)}
if len(batches.Current) != 2 {
t.Fatalf("Length of current batch should be 2, but is %d", len(batches.Current))
}
batches.ClearBatch()
if len(batches.Current) != 0 {
t.Fatalf("Length of current batch should be 0, but is %d", len(batches.Current))
}
})
t.Run("AdvanceBatch", func(t *testing.T) {
documents := make([]bsoncore.Document, 0)
for i := 0; i < 5; i++ {
doc := make(bsoncore.Document, 100)
documents = append(documents, doc)
}
testCases := []struct {
name string
batches *Batches
maxCount int
targetBatchSize int
maxDocSize int
err error
want *Batches
}{
{
"current batch non-zero",
&Batches{Current: make([]bsoncore.Document, 2, 10)},
0, 0, 0, nil,
&Batches{Current: make([]bsoncore.Document, 2, 10)},
},
{
// all of the documents in the batch fit in targetBatchSize so the batch is created successfully
"documents fit in targetBatchSize",
&Batches{Documents: documents},
10, 600, 1000, nil,
&Batches{Documents: documents[:0], Current: documents[0:]},
},
{
// the first doc is bigger than targetBatchSize but smaller than maxDocSize so it is taken alone
"first document larger than targetBatchSize, smaller than maxDocSize",
&Batches{Documents: documents},
10, 5, 100, nil,
&Batches{Documents: documents[1:], Current: documents[:1]},
},
}
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
err := tc.batches.AdvanceBatch(tc.maxCount, tc.targetBatchSize, tc.maxDocSize)
if !cmp.Equal(err, tc.err, cmp.Comparer(compareErrors)) {
t.Errorf("Errors do not match. got %v; want %v", err, tc.err)
}
if !cmp.Equal(tc.batches, tc.want) {
t.Errorf("Batches is not in correct state after AdvanceBatch. got %v; want %v", tc.batches, tc.want)
}
})
}
t.Run("middle document larger than targetBatchSize, smaller than maxDocSize", func(t *testing.T) {
// a batch is made but one document is too big, so everything before it is taken.
// on the second call to AdvanceBatch, only the large document is taken
middleLargeDoc := make([]bsoncore.Document, 0)
for i := 0; i < 5; i++ {
doc := make(bsoncore.Document, 100)
middleLargeDoc = append(middleLargeDoc, doc)
}
largeDoc := make(bsoncore.Document, 900)
middleLargeDoc[2] = largeDoc
batches := &Batches{Documents: middleLargeDoc}
maxCount := 10
targetSize := 600
maxDocSize := 1000
// first batch should take first 2 docs (size 100 each)
err := batches.AdvanceBatch(maxCount, targetSize, maxDocSize)
assert.Nil(t, err, "AdvanceBatch error: %v", err)
want := &Batches{Current: middleLargeDoc[:2], Documents: middleLargeDoc[2:]}
assert.Equal(t, want, batches, "expected batches %v, got %v", want, batches)
// second batch should take single large doc (size 900)
batches.ClearBatch()
err = batches.AdvanceBatch(maxCount, targetSize, maxDocSize)
assert.Nil(t, err, "AdvanceBatch error: %v", err)
want = &Batches{Current: middleLargeDoc[2:3], Documents: middleLargeDoc[3:]}
assert.Equal(t, want, batches, "expected batches %v, got %v", want, batches)
// last batch should take last 2 docs (size 100 each)
batches.ClearBatch()
err = batches.AdvanceBatch(maxCount, targetSize, maxDocSize)
assert.Nil(t, err, "AdvanceBatch error: %v", err)
want = &Batches{Current: middleLargeDoc[3:], Documents: middleLargeDoc[:0]}
assert.Equal(t, want, batches, "expected batches %v, got %v", want, batches)
})
})
}
|
