120 lines
3.6 KiB
Go
120 lines
3.6 KiB
Go
package hw3test
|
|
|
|
import (
|
|
"math/rand"
|
|
"reflect"
|
|
"testing"
|
|
)
|
|
|
|
func TestLargePutPlansKeepBoundaryWritesAndQueries(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
runSeeds []int64
|
|
count int
|
|
largeSeed int64
|
|
allHeaders bool
|
|
compression bool
|
|
}{
|
|
{"G6", []int64{7824, 1671, 3793, 272, 2715, 1436}, 25, 3793, false, false},
|
|
{"G7", []int64{3224, 7507, 4172, 7777, 6666, 6094, 6442}, 30, 3224, true, true},
|
|
}
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
context := NewTestContext(t)
|
|
envGen := &EnvGen{
|
|
MaxDepth: 1,
|
|
MaxDirs: 6,
|
|
MaxFiles: 6,
|
|
MaxFileSizeKB: 192 * 1024,
|
|
FilenameGen: SimpleFilenameGenerator(16),
|
|
}
|
|
policy := &LargePutPolicy{
|
|
RunSeed: test.largeSeed,
|
|
LargeSizes: []int64{160 << 20, 191 << 20},
|
|
OtherMaxBytes: 8 << 20,
|
|
}
|
|
options := RunOpts{ServerDomain: "localhost"}
|
|
largePosts := 0
|
|
largeGets := 0
|
|
largeGzipGets := 0
|
|
for _, runSeed := range test.runSeeds {
|
|
env, err := envGen.Generate(runSeed)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
r := rand.New(rand.NewSource(runSeed))
|
|
seeds := make([]int64, test.count)
|
|
for i := range seeds {
|
|
seeds[i] = r.Int63n(100000)
|
|
}
|
|
generator := &QueriesGen{
|
|
Count: test.count, GetFile: true, GetDirectory: true,
|
|
Post: true, Put: true, Delete: true,
|
|
Compression: test.compression, AllHeaders: test.allHeaders,
|
|
LargePuts: policy,
|
|
}
|
|
queries := generator.Generate(context, env, envGen, seeds, options, runSeed)
|
|
generator.LargePuts = nil
|
|
baseline := generator.Generate(context, env, envGen, seeds, options, runSeed)
|
|
if len(queries) != len(baseline) {
|
|
t.Fatalf("run %d changed query count", runSeed)
|
|
}
|
|
state := env.Clone()
|
|
var largePutSizes []int64
|
|
for i, query := range queries {
|
|
if query.Method == "PUT" {
|
|
baseline[i].FileContent.Size = query.FileContent.Size
|
|
}
|
|
if !reflect.DeepEqual(query, baseline[i]) {
|
|
t.Fatalf("run %d changed query %d beyond PUT body size", runSeed, i)
|
|
}
|
|
action := query.Action(state, &options)
|
|
if query.Path == "" && query.Method != "GET" {
|
|
t.Fatal("generated a modifying request to the working directory")
|
|
}
|
|
if get, ok := action.(GetFileAction); ok && get.File.Size > 128<<20 {
|
|
largeGets++
|
|
if get.Compression {
|
|
largeGzipGets++
|
|
}
|
|
}
|
|
if query.Method == "PUT" {
|
|
if query.FileContent.Size > 128<<20 {
|
|
if _, ok := action.(ReplaceFileAction); !ok {
|
|
t.Fatalf("run %d has a large PUT that cannot update a file", runSeed)
|
|
}
|
|
largePutSizes = append(largePutSizes, query.FileContent.Size)
|
|
} else if query.FileContent.Size > policy.OtherMaxBytes {
|
|
t.Fatalf("run %d has an unbounded PUT", runSeed)
|
|
}
|
|
}
|
|
if query.Method == "POST" && query.FileContent != nil && query.FileContent.Size > 128<<20 {
|
|
if _, ok := action.(CreateFileAction); ok {
|
|
largePosts++
|
|
}
|
|
}
|
|
if action != nil {
|
|
action.ApplyEnv(context, state)
|
|
}
|
|
}
|
|
if runSeed == test.largeSeed {
|
|
if !reflect.DeepEqual(largePutSizes, policy.LargeSizes) {
|
|
t.Fatalf("run %d large PUT sizes: got %v, want %v", runSeed, largePutSizes, policy.LargeSizes)
|
|
}
|
|
} else if len(largePutSizes) != 0 {
|
|
t.Fatalf("run %d has unexpected large PUTs", runSeed)
|
|
}
|
|
}
|
|
if largePosts == 0 {
|
|
t.Fatal("no successful POST larger than the solution memory limit")
|
|
}
|
|
if largeGets == 0 {
|
|
t.Fatal("no successful GET larger than the solution memory limit")
|
|
}
|
|
if test.compression && largeGzipGets == 0 {
|
|
t.Fatal("no gzip GET larger than the solution memory limit")
|
|
}
|
|
})
|
|
}
|
|
}
|