github.com/flavio/docker@v0.1.3-0.20170117145210-f63d1a6eec47/pkg/httputils/httputils_test.go (about)

     1  package httputils
     2  
     3  import (
     4  	"fmt"
     5  	"io/ioutil"
     6  	"net/http"
     7  	"net/http/httptest"
     8  	"strings"
     9  	"testing"
    10  )
    11  
    12  func TestDownload(t *testing.T) {
    13  	expected := "Hello, docker !"
    14  	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    15  		fmt.Fprintf(w, expected)
    16  	}))
    17  	defer ts.Close()
    18  	response, err := Download(ts.URL)
    19  	if err != nil {
    20  		t.Fatal(err)
    21  	}
    22  
    23  	actual, err := ioutil.ReadAll(response.Body)
    24  	response.Body.Close()
    25  
    26  	if err != nil || string(actual) != expected {
    27  		t.Fatalf("Expected the response %q, got err:%q, response:%q, actual:%q", expected, err, response, string(actual))
    28  	}
    29  }
    30  
    31  func TestDownload400Errors(t *testing.T) {
    32  	expectedError := "Got HTTP status code >= 400: 403 Forbidden"
    33  	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    34  		// 403
    35  		http.Error(w, "something failed (forbidden)", http.StatusForbidden)
    36  	}))
    37  	defer ts.Close()
    38  	// Expected status code = 403
    39  	if _, err := Download(ts.URL); err == nil || err.Error() != expectedError {
    40  		t.Fatalf("Expected the error %q, got %q", expectedError, err)
    41  	}
    42  }
    43  
    44  func TestDownloadOtherErrors(t *testing.T) {
    45  	if _, err := Download("I'm not an url.."); err == nil || !strings.Contains(err.Error(), "unsupported protocol scheme") {
    46  		t.Fatalf("Expected an error with 'unsupported protocol scheme', got %q", err)
    47  	}
    48  }
    49  
    50  func TestNewHTTPRequestError(t *testing.T) {
    51  	errorMessage := "Some error message"
    52  	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    53  		// 403
    54  		http.Error(w, errorMessage, http.StatusForbidden)
    55  	}))
    56  	defer ts.Close()
    57  	httpResponse, err := http.Get(ts.URL)
    58  	if err != nil {
    59  		t.Fatal(err)
    60  	}
    61  	if err := NewHTTPRequestError(errorMessage, httpResponse); err.Error() != errorMessage {
    62  		t.Fatalf("Expected err to be %q, got %q", errorMessage, err)
    63  	}
    64  }
    65  
    66  func TestParseServerHeader(t *testing.T) {
    67  	inputs := map[string][]string{
    68  		"bad header":           {"error"},
    69  		"(bad header)":         {"error"},
    70  		"(without/spaces)":     {"error"},
    71  		"(header/with spaces)": {"error"},
    72  		"foo/bar (baz)":        {"foo", "bar", "baz"},
    73  		"foo/bar":              {"error"},
    74  		"foo":                  {"error"},
    75  		"foo/bar (baz space)":           {"foo", "bar", "baz space"},
    76  		"  f  f  /  b  b  (  b  s  )  ": {"f  f", "b  b", "b  s"},
    77  		"foo/bar (baz) ignore":          {"foo", "bar", "baz"},
    78  		"foo/bar ()":                    {"error"},
    79  		"foo/bar()":                     {"error"},
    80  		"foo/bar(baz)":                  {"foo", "bar", "baz"},
    81  		"foo/bar/zzz(baz)":              {"foo/bar", "zzz", "baz"},
    82  		"foo/bar(baz/abc)":              {"foo", "bar", "baz/abc"},
    83  		"foo/bar(baz (abc))":            {"foo", "bar", "baz (abc)"},
    84  	}
    85  
    86  	for header, values := range inputs {
    87  		serverHeader, err := ParseServerHeader(header)
    88  		if err != nil {
    89  			if err != errInvalidHeader {
    90  				t.Fatalf("Failed to parse %q, and got some unexpected error: %q", header, err)
    91  			}
    92  			if values[0] == "error" {
    93  				continue
    94  			}
    95  			t.Fatalf("Header %q failed to parse when it shouldn't have", header)
    96  		}
    97  		if values[0] == "error" {
    98  			t.Fatalf("Header %q parsed ok when it should have failed(%q).", header, serverHeader)
    99  		}
   100  
   101  		if serverHeader.App != values[0] {
   102  			t.Fatalf("Expected serverHeader.App for %q to equal %q, got %q", header, values[0], serverHeader.App)
   103  		}
   104  
   105  		if serverHeader.Ver != values[1] {
   106  			t.Fatalf("Expected serverHeader.Ver for %q to equal %q, got %q", header, values[1], serverHeader.Ver)
   107  		}
   108  
   109  		if serverHeader.OS != values[2] {
   110  			t.Fatalf("Expected serverHeader.OS for %q to equal %q, got %q", header, values[2], serverHeader.OS)
   111  		}
   112  
   113  	}
   114  
   115  }