github.com/hanks177/podman/v4@v4.1.3-0.20220613032544-16d90015bc83/pkg/api/handlers/utils/handler_test.go (about)

     1  package utils
     2  
     3  import (
     4  	"errors"
     5  	"fmt"
     6  	"net/http"
     7  	"net/http/httptest"
     8  	"testing"
     9  
    10  	"github.com/hanks177/podman/v4/version"
    11  	"github.com/gorilla/mux"
    12  )
    13  
    14  func TestSupportedVersion(t *testing.T) {
    15  	req, err := http.NewRequest("GET",
    16  		fmt.Sprintf("/v%s/libpod/testing/versions", version.APIVersion[version.Libpod][version.CurrentAPI]),
    17  		nil)
    18  	if err != nil {
    19  		t.Fatal(err)
    20  	}
    21  	req = mux.SetURLVars(req, map[string]string{"version": version.APIVersion[version.Libpod][version.CurrentAPI].String()})
    22  
    23  	rr := httptest.NewRecorder()
    24  	handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    25  		_, err := SupportedVersionWithDefaults(r)
    26  		switch {
    27  		case errors.Is(err, ErrVersionNotGiven): // for compat endpoints version optional
    28  			w.WriteHeader(http.StatusInternalServerError)
    29  			fmt.Fprint(w, err.Error())
    30  		case errors.Is(err, ErrVersionNotSupported): // version given but not supported
    31  			w.WriteHeader(http.StatusBadRequest)
    32  			fmt.Fprint(w, err.Error())
    33  		case err != nil:
    34  			w.WriteHeader(http.StatusInternalServerError)
    35  			fmt.Fprint(w, err.Error())
    36  		default: // all good
    37  			w.WriteHeader(http.StatusOK)
    38  			fmt.Fprint(w, "OK")
    39  		}
    40  	})
    41  	handler.ServeHTTP(rr, req)
    42  
    43  	if status := rr.Code; status != http.StatusOK {
    44  		t.Errorf("handler returned wrong status code: got %v want %v",
    45  			status, http.StatusOK)
    46  	}
    47  
    48  	// Check the response body is what we expect.
    49  	expected := `OK`
    50  	if rr.Body.String() != expected {
    51  		t.Errorf("handler returned unexpected body: got %q want %q",
    52  			rr.Body.String(), expected)
    53  	}
    54  }
    55  
    56  func TestUnsupportedVersion(t *testing.T) {
    57  	version := "999.999.999"
    58  	req, err := http.NewRequest("GET",
    59  		fmt.Sprintf("/v%s/libpod/testing/versions", version),
    60  		nil)
    61  	if err != nil {
    62  		t.Fatal(err)
    63  	}
    64  	req = mux.SetURLVars(req, map[string]string{"version": version})
    65  
    66  	rr := httptest.NewRecorder()
    67  	handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    68  		_, err := SupportedVersionWithDefaults(r)
    69  		switch {
    70  		case errors.Is(err, ErrVersionNotGiven): // for compat endpoints version optional
    71  			w.WriteHeader(http.StatusInternalServerError)
    72  			fmt.Fprint(w, err.Error())
    73  		case errors.Is(err, ErrVersionNotSupported): // version given but not supported
    74  			w.WriteHeader(http.StatusBadRequest)
    75  			fmt.Fprint(w, err.Error())
    76  		case err != nil:
    77  			w.WriteHeader(http.StatusInternalServerError)
    78  			fmt.Fprint(w, err.Error())
    79  		default: // all good
    80  			w.WriteHeader(http.StatusOK)
    81  			fmt.Fprint(w, "OK")
    82  		}
    83  	})
    84  	handler.ServeHTTP(rr, req)
    85  
    86  	if status := rr.Code; status != http.StatusBadRequest {
    87  		t.Errorf("handler returned wrong status code: got %v want %v",
    88  			status, http.StatusBadRequest)
    89  	}
    90  
    91  	// Check the response body is what we expect.
    92  	expected := ErrVersionNotSupported.Error()
    93  	if rr.Body.String() != expected {
    94  		t.Errorf("handler returned unexpected body: got %q want %q",
    95  			rr.Body.String(), expected)
    96  	}
    97  }
    98  
    99  func TestEqualVersion(t *testing.T) {
   100  	version := "1.30.0"
   101  	req, err := http.NewRequest("GET",
   102  		fmt.Sprintf("/v%s/libpod/testing/versions", version),
   103  		nil)
   104  	if err != nil {
   105  		t.Fatal(err)
   106  	}
   107  	req = mux.SetURLVars(req, map[string]string{"version": version})
   108  
   109  	rr := httptest.NewRecorder()
   110  	handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   111  		_, err := SupportedVersion(r, "=="+version)
   112  		switch {
   113  		case errors.Is(err, ErrVersionNotGiven): // for compat endpoints version optional
   114  			w.WriteHeader(http.StatusInternalServerError)
   115  			fmt.Fprint(w, err.Error())
   116  		case errors.Is(err, ErrVersionNotSupported): // version given but not supported
   117  			w.WriteHeader(http.StatusBadRequest)
   118  			fmt.Fprint(w, err.Error())
   119  		case err != nil:
   120  			w.WriteHeader(http.StatusInternalServerError)
   121  			fmt.Fprint(w, err.Error())
   122  		default: // all good
   123  			w.WriteHeader(http.StatusOK)
   124  			fmt.Fprint(w, "OK")
   125  		}
   126  	})
   127  	handler.ServeHTTP(rr, req)
   128  
   129  	if status := rr.Code; status != http.StatusOK {
   130  		t.Errorf("handler returned wrong status code: got %v want %v",
   131  			status, http.StatusOK)
   132  	}
   133  
   134  	// Check the response body is what we expect.
   135  	expected := http.StatusText(http.StatusOK)
   136  	if rr.Body.String() != expected {
   137  		t.Errorf("handler returned unexpected body: got %q want %q",
   138  			rr.Body.String(), expected)
   139  	}
   140  }
   141  
   142  func TestErrorEncoderFuncOmit(t *testing.T) {
   143  	data, err := json.Marshal(struct {
   144  		Err  error   `json:"err,omitempty"`
   145  		Errs []error `json:"errs,omitempty"`
   146  	}{})
   147  	if err != nil {
   148  		t.Fatal(err)
   149  	}
   150  
   151  	dataAsMap := make(map[string]interface{})
   152  	err = json.Unmarshal(data, &dataAsMap)
   153  	if err != nil {
   154  		t.Fatal(err)
   155  	}
   156  
   157  	_, ok := dataAsMap["err"]
   158  	if ok {
   159  		t.Errorf("the `err` field should have been omitted")
   160  	}
   161  	_, ok = dataAsMap["errs"]
   162  	if ok {
   163  		t.Errorf("the `errs` field should have been omitted")
   164  	}
   165  
   166  	dataAsMap = make(map[string]interface{})
   167  	data, err = json.Marshal(struct {
   168  		Err  error   `json:"err"`
   169  		Errs []error `json:"errs"`
   170  	}{})
   171  	if err != nil {
   172  		t.Fatal(err)
   173  	}
   174  
   175  	err = json.Unmarshal(data, &dataAsMap)
   176  	if err != nil {
   177  		t.Fatal(err)
   178  	}
   179  
   180  	_, ok = dataAsMap["err"]
   181  	if !ok {
   182  		t.Errorf("the `err` field shouldn't have been omitted")
   183  	}
   184  	_, ok = dataAsMap["errs"]
   185  	if !ok {
   186  		t.Errorf("the `errs` field shouldn't have been omitted")
   187  	}
   188  }