github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-08-11 21:12:07 +00:00
Code Issues Projects Releases Wiki Activity

Refactor tests to be table driven.

Browse Source
This commit is contained in:
Robert Bailey 2014-08-18 00:17:06 -07:00
parent 9ce364d498
commit fecfe23ed1
1 changed files with 60 additions and 85 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

113
pkg/kubelet/config/http_test.go
View File

@ -41,50 +41,54 @@ func TestURLErrorNotExistNoUpdate(t *testing.T) {
func TestExtractFromHttpBadness(t *testing.T) { func TestExtractFromHttpBadness(t *testing.T) {
ch := make(chan interface{}, 1) ch := make(chan interface{}, 1)
c := SourceURL{"http://localhost:49575/_not_found_", ch} c := SourceURL{"http://localhost:49575/_not_found_", ch}
err := c.extractFromURL() if err := c.extractFromURL(); err == nil {
if err == nil {
t.Errorf("Expected error") t.Errorf("Expected error")
} }
expectEmptyChannel(t, ch) expectEmptyChannel(t, ch)
} }
func TestExtractFromHttpSingle(t *testing.T) { func TestExtractFromHTTP(t *testing.T) {
manifests := []api.ContainerManifest{ var testCases = []struct {
{Version: "v1beta1", ID: "foo"}, desc string
} manifests interface{}
// Taking a single-manifest from a URL allows kubelet to be used expected kubelet.PodUpdate
// in the implementation of google's container VM image. }{
data, err := json.Marshal(manifests[0]) {
desc: "Single manifest",
fakeHandler := util.FakeHandler{ manifests: api.ContainerManifest{Version: "v1beta1", ID: "foo"},
StatusCode: 200, expected: CreatePodUpdate(kubelet.SET,
ResponseBody: string(data), kubelet.Pod{
} Name: "foo",
testServer := httptest.NewServer(&fakeHandler) Manifest: api.ContainerManifest{Version: "v1beta1", ID: "foo"},
ch := make(chan interface{}, 1) }),
c := SourceURL{testServer.URL, ch} },
{
err = c.extractFromURL() desc: "Multiple manifests",
if err != nil { manifests: []api.ContainerManifest{
t.Errorf("Unexpected error: %v", err)
}
update := (<-ch).(kubelet.PodUpdate)
expected := CreatePodUpdate(kubelet.SET, kubelet.Pod{Name: "foo", Manifest: manifests[0]})
if !reflect.DeepEqual(expected, update) {
t.Errorf("Expected: %#v, Got: %#v", expected, update)
}
}
func TestExtractFromHttpMultiple(t *testing.T) {
manifests := []api.ContainerManifest{
{Version: "v1beta1", ID: "", Containers: []api.Container{{Name: "1", Image: "foo"}}}, {Version: "v1beta1", ID: "", Containers: []api.Container{{Name: "1", Image: "foo"}}},
{Version: "v1beta1", ID: "bar", Containers: []api.Container{{Name: "1", Image: "foo"}}}, {Version: "v1beta1", ID: "bar", Containers: []api.Container{{Name: "1", Image: "foo"}}},
},
expected: CreatePodUpdate(kubelet.SET,
kubelet.Pod{
Name: "1",
Manifest: api.ContainerManifest{Version: "v1beta1", ID: "", Containers: []api.Container{{Name: "1", Image: "foo"}}},
},
kubelet.Pod{
Name: "bar",
Manifest: api.ContainerManifest{Version: "v1beta1", ID: "bar", Containers: []api.Container{{Name: "1", Image: "foo"}}},
}),
},
{
desc: "Empty Array",
manifests: []api.ContainerManifest{},
expected: CreatePodUpdate(kubelet.SET),
},
} }
data, err := json.Marshal(manifests) for _, testCase := range testCases {
data, err := json.Marshal(testCase.manifests)
if err != nil { if err != nil {
t.Fatalf("Some weird json problem: %v", err) t.Fatalf("%s: Some weird json problem: %v", testCase.desc, err)
} }
fakeHandler := util.FakeHandler{ fakeHandler := util.FakeHandler{
StatusCode: 200, StatusCode: 200,
ResponseBody: string(data), ResponseBody: string(data),
@ -92,46 +96,17 @@ func TestExtractFromHttpMultiple(t *testing.T) {
testServer := httptest.NewServer(&fakeHandler) testServer := httptest.NewServer(&fakeHandler)
ch := make(chan interface{}, 1) ch := make(chan interface{}, 1)
c := SourceURL{testServer.URL, ch} c := SourceURL{testServer.URL, ch}
if err := c.extractFromURL(); err != nil {
err = c.extractFromURL() t.Errorf("%s: Unexpected error: %v", testCase.desc, err)
if err != nil {
t.Errorf("Unexpected error: %v", err)
} }
update := (<-ch).(kubelet.PodUpdate) update := (<-ch).(kubelet.PodUpdate)
expected := CreatePodUpdate(kubelet.SET, kubelet.Pod{Name: "1", Manifest: manifests[0]}, kubelet.Pod{Name: "bar", Manifest: manifests[1]}) if !reflect.DeepEqual(testCase.expected, update) {
if !reflect.DeepEqual(expected, update) { t.Errorf("%s: Expected: %#v, Got: %#v", testCase.desc, testCase.expected, update)
t.Errorf("Expected: %#v, Got: %#v", expected, update)
} }
for i := range update.Pods { for i := range update.Pods {
if errs := kubelet.ValidatePod(&update.Pods[i]); len(errs) != 0 { if errs := kubelet.ValidatePod(&update.Pods[i]); len(errs) != 0 {
t.Errorf("Expected no validation errors on %#v, Got %#v", update.Pods[i], errs) t.Errorf("%s: Expected no validation errors on %#v, Got %#v", testCase.desc, update.Pods[i], errs)
}
} }
} }
} }
func TestExtractFromHttpEmptyArray(t *testing.T) {
manifests := []api.ContainerManifest{}
data, err := json.Marshal(manifests)
if err != nil {
t.Fatalf("Some weird json problem: %v", err)
}
fakeHandler := util.FakeHandler{
StatusCode: 200,
ResponseBody: string(data),
}
testServer := httptest.NewServer(&fakeHandler)
ch := make(chan interface{}, 1)
c := SourceURL{testServer.URL, ch}
err = c.extractFromURL()
if err != nil {
t.Errorf("Unexpected error: %v", err)
}
update := (<-ch).(kubelet.PodUpdate)
expected := CreatePodUpdate(kubelet.SET)
if !reflect.DeepEqual(expected, update) {
t.Errorf("Expected: %#v, Got: %#v", expected, update)
}
}