add discrete tests for initialize step (#618)

Author: lucix-aws

middleware/shared_test.go

@@ -2,6 +2,7 @@ package middleware
 
 import (
 	"context"
+	"reflect"
 	"testing"
 )
 
@@ -72,3 +73,24 @@ func mockDeserializeMiddleware(id string) DeserializeMiddleware {
 			return next.HandleDeserialize(ctx, in)
 		})
 }
+
+func expectID(t *testing.T, m ider, expect string) {
+	t.Helper()
+	if m == nil {
+		t.Error("expect is nil")
+		return
+	}
+	if actual := m.ID(); expect != actual {
+		t.Errorf("expect %q, got %q", expect, actual)
+	}
+}
+
+func expectIDList(t *testing.T, expect, actual []string) {
+	t.Helper()
+	if len(expect) == 0 && len(actual) == 0 {
+		return
+	}
+	if !reflect.DeepEqual(expect, actual) {
+		t.Errorf("%v !=\n%v", expect, actual)
+	}
+}

middleware/step_initialize_test.go

@@ -0,0 +1,150 @@
+package middleware
+
+import (
+	"testing"
+)
+
+func TestInitializeStep_Get(t *testing.T) {
+	step := NewInitializeStep()
+	step.Add(mockInitializeMiddleware("A"), After)
+	step.Add(mockInitializeMiddleware("B"), After)
+
+	got, _ := step.Get("A")
+	expectID(t, got, "A")
+	got, _ = step.Get("B")
+	expectID(t, got, "B")
+
+	if _, ok := step.Get("NOT REAL"); ok {
+		t.Errorf("shouldn't get fake middleware from list but you did")
+	}
+
+	// empty
+	step = NewInitializeStep()
+	if _, ok := step.Get("A"); ok {
+		t.Errorf("shouldn't get something from nothing but you did")
+	}
+}
+
+func TestInitializeStep_Add(t *testing.T) {
+	step := NewInitializeStep()
+
+	step.Add(mockInitializeMiddleware("A"), After)
+	expectIDList(t, []string{"A"}, step.List())
+
+	step.Add(mockInitializeMiddleware("B"), After)
+	expectIDList(t, []string{"A", "B"}, step.List())
+
+	step.Add(mockInitializeMiddleware("C"), Before)
+	expectIDList(t, []string{"C", "A", "B"}, step.List())
+}
+
+func TestInitializeStep_Insert(t *testing.T) {
+	step := NewInitializeStep()
+	step.Add(mockInitializeMiddleware("A"), After)
+	step.Add(mockInitializeMiddleware("B"), After)
+	step.Add(mockInitializeMiddleware("C"), After)
+
+	// before + at the front
+	err := step.Insert(mockInitializeMiddleware("D"), "A", Before)
+	noError(t, err)
+	expectIDList(t, []string{"D", "A", "B", "C"}, step.List())
+
+	// after + at the end
+	err = step.Insert(mockInitializeMiddleware("E"), "C", After)
+	noError(t, err)
+	expectIDList(t, []string{"D", "A", "B", "C", "E"}, step.List())
+
+	// before + somewhere in the middle
+	err = step.Insert(mockInitializeMiddleware("F"), "B", Before)
+	noError(t, err)
+	expectIDList(t, []string{"D", "A", "F", "B", "C", "E"}, step.List())
+
+	// after + somewhere in the middleware
+	err = step.Insert(mockInitializeMiddleware("G"), "F", After)
+	noError(t, err)
+	expectIDList(t, []string{"D", "A", "F", "G", "B", "C", "E"}, step.List())
+
+	// not found
+	err = step.Insert(mockInitializeMiddleware("H"), "FALSE", Before)
+	if err == nil {
+		t.Error("expect err, got none")
+	}
+
+	// empty
+	step = NewInitializeStep()
+	if err := step.Insert(mockInitializeMiddleware("B"), "A", After); err == nil {
+		t.Error("expect err, got none")
+	}
+}
+
+func TestInitializeStep_Swap(t *testing.T) {
+	step := NewInitializeStep()
+	step.Add(mockInitializeMiddleware("A"), After)
+	step.Add(mockInitializeMiddleware("B"), After)
+	step.Add(mockInitializeMiddleware("C"), After)
+
+	swapped, err := step.Swap("B", mockInitializeMiddleware("D"))
+	noError(t, err)
+	expectID(t, swapped, "B")
+	expectIDList(t, []string{"A", "D", "C"}, step.List())
+
+	// not found
+	if _, err := step.Swap("LIES", mockInitializeMiddleware("G")); err == nil {
+		t.Error("expect err, got none")
+	}
+}
+
+func TestInitializeStep_Remove(t *testing.T) {
+	step := NewInitializeStep()
+	step.Add(mockInitializeMiddleware("A"), After)
+	step.Add(mockInitializeMiddleware("B"), After)
+	step.Add(mockInitializeMiddleware("C"), After)
+	step.Add(mockInitializeMiddleware("D"), After)
+	step.Add(mockInitializeMiddleware("E"), After)
+
+	// not found
+	if _, err := step.Remove("DECEIT"); err == nil {
+		t.Error("expect err, got none")
+	}
+
+	// at the front
+	removed, err := step.Remove("A")
+	noError(t, err)
+	expectID(t, removed, "A")
+	expectIDList(t, []string{"B", "C", "D", "E"}, step.List())
+
+	// at the end
+	removed, err = step.Remove("E")
+	noError(t, err)
+	expectID(t, removed, "E")
+	expectIDList(t, []string{"B", "C", "D"}, step.List())
+
+	// somewhere in the middle
+	removed, err = step.Remove("C")
+	noError(t, err)
+	expectID(t, removed, "C")
+	expectIDList(t, []string{"B", "D"}, step.List())
+
+	// it's the only one (have to remove two to get there)
+	step.Remove("B")
+	removed, err = step.Remove("D")
+	noError(t, err)
+	expectID(t, removed, "D")
+	expectIDList(t, nil, step.List())
+
+	// empty
+	if _, err := step.Remove("ILLUSION"); err == nil {
+		t.Error("expect err, got none")
+	}
+}
+
+func TestInitializeStep_Clear(t *testing.T) {
+	step := NewInitializeStep()
+	step.Add(mockInitializeMiddleware("A"), After)
+	step.Add(mockInitializeMiddleware("B"), After)
+	step.Add(mockInitializeMiddleware("C"), After)
+
+	expectIDList(t, []string{"A", "B", "C"}, step.List())
+	step.Clear()
+	expectIDList(t, nil, step.List())
+}