func deployerSuccessHandler(w http.ResponseWriter, r *http.Request) { valid := &Configuration{} err := yaml.Unmarshal(validConfigurationTestCaseData, valid) if err != nil { status := fmt.Sprintf("cannot unmarshal test case data:%s", err) http.Error(w, status, http.StatusInternalServerError) return } defer r.Body.Close() body, err := ioutil.ReadAll(r.Body) if err != nil { status := fmt.Sprintf("cannot read request body:%s", err) http.Error(w, status, http.StatusInternalServerError) return } result := &Configuration{} if err := yaml.Unmarshal(body, result); err != nil { status := fmt.Sprintf("cannot unmarshal request body:%s", err) http.Error(w, status, http.StatusInternalServerError) return } if !reflect.DeepEqual(valid, result) { status := fmt.Sprintf("error in http handler:\nwant:%s\nhave:%s\n", util.ToYAMLOrError(valid), util.ToYAMLOrError(result)) http.Error(w, status, http.StatusInternalServerError) return } w.WriteHeader(http.StatusOK) }
func TestGetConfiguration(t *testing.T) { valid := getValidConfiguration(t) tests := []DeployerTestCase{ { "expect success for GetConfiguration", "", func(w http.ResponseWriter, r *http.Request) { // Get name from path, find in valid, and return its properties. rtype := path.Base(path.Dir(r.URL.Path)) rname := path.Base(r.URL.Path) for _, resource := range valid.Resources { if resource.Type == rtype && resource.Name == rname { util.LogHandlerExitWithYAML("resourcifier: get configuration", w, resource.Properties, http.StatusOK) return } } status := fmt.Sprintf("resource %s of type %s not found", rname, rtype) http.Error(w, status, http.StatusInternalServerError) }, }, { "expect error for GetConfiguration", "cannot get configuration", deployerErrorHandler, }, } for _, dtc := range tests { ts := httptest.NewServer(http.HandlerFunc(dtc.Handler)) defer ts.Close() deployer := NewDeployer(ts.URL) result, err := deployer.GetConfiguration(valid) if err != nil { message := err.Error() if !strings.Contains(message, dtc.Error) { t.Errorf("error in test case:%s:%s\n", dtc.Description, message) } } else { if dtc.Error != "" { t.Errorf("expected error:%s\ndid not occur in test case:%s\n", dtc.Error, dtc.Description) } if !reflect.DeepEqual(valid, result) { t.Errorf("error in test case:%s:\nwant:%s\nhave:%s\n", dtc.Description, util.ToYAMLOrError(valid), util.ToYAMLOrError(result)) } } } }
func TestServiceWrapper(t *testing.T) { backend := expander.NewExpander("../expansion/expansion.py") wrapper := NewService(NewExpansionHandler(backend)) container := restful.NewContainer() container.ServeMux = http.NewServeMux() wrapper.Register(container) handlerTester := util.NewHandlerTester(container) for _, swtc := range ServiceWrapperTestCases { reader := GetTemplateReader(t, swtc.Description, inputFileName) w, err := handlerTester(swtc.HTTPMethod, swtc.ServiceURLPath, swtc.ContentType, reader) if err != nil { t.Errorf("error in test case '%s': %s\n", swtc.Description, err) } if w.Code != http.StatusOK { if w.Code != swtc.StatusCode { message := fmt.Sprintf("test returned code:%d, status: %s", w.Code, w.Body.String()) t.Errorf("error in test case '%s': %s\n", swtc.Description, message) } } else { if swtc.StatusCode != http.StatusOK { t.Errorf("expected error did not occur in test case '%s': want: %d have: %d\n", swtc.Description, swtc.StatusCode, w.Code) } body := w.Body.Bytes() actualResponse := &expander.ExpansionResponse{} if err := json.Unmarshal(body, actualResponse); err != nil { t.Errorf("error in test case '%s': %s\n", swtc.Description, err) } actualResult, err := actualResponse.Unmarshal() if err != nil { t.Errorf("error in test case '%s': %s\n", swtc.Description, err) } expectedOutput := GetOutputString(t, swtc.Description) expectedResult := expandOutputOrDie(t, expectedOutput, swtc.Description) if !reflect.DeepEqual(expectedResult, actualResult) { message := fmt.Sprintf("want: %s\nhave: %s\n", util.ToYAMLOrError(expectedResult), util.ToYAMLOrError(actualResult)) t.Errorf("error in test case '%s':\n%s\n", swtc.Description, message) } } } }
func TestExpandTemplate(t *testing.T) { roundTripResponse := &ExpandedTemplate{} if err := yaml.Unmarshal([]byte(finalExpanded), roundTripResponse); err != nil { panic(err) } tests := []ExpanderTestCase{ { "expect success for ExpandTemplate", "", expanderSuccessHandler, &mockResolver{}, getValidResponse(t, "expect success for ExpandTemplate"), }, { "expect error for ExpandTemplate", "cannot expand template", expanderErrorHandler, &mockResolver{}, nil, }, { "expect success for ExpandTemplate with two expansions", "", roundTripHandler, &mockResolver{[][]*ImportFile{ {}, {&ImportFile{Name: "test"}}, }, t}, roundTripResponse, }, } for _, etc := range tests { ts := httptest.NewServer(http.HandlerFunc(etc.Handler)) defer ts.Close() expander := NewExpander(ts.URL, etc.Resolver) actualResponse, err := expander.ExpandTemplate(validTemplateTestCaseData) if err != nil { message := err.Error() if etc.Error == "" { t.Errorf("Error in test case %s when there should not be.", etc.Description) } if !strings.Contains(message, etc.Error) { t.Errorf("error in test case:%s:%s\n", etc.Description, message) } } else { if etc.Error != "" { t.Errorf("expected error:%s\ndid not occur in test case:%s\n", etc.Error, etc.Description) } expectedResponse := etc.ValidResponse if !reflect.DeepEqual(expectedResponse, actualResponse) { t.Errorf("error in test case:%s:\nwant:%s\nhave:%s\n", etc.Description, util.ToYAMLOrError(expectedResponse), util.ToYAMLOrError(actualResponse)) } } } }