github.com/zhouyu0/docker-note@v0.0.0-20190722021225-b8d3825084db/client/image_pull_test.go (about)

     1  package client // import "github.com/docker/docker/client"
     2  
     3  import (
     4  	"bytes"
     5  	"context"
     6  	"fmt"
     7  	"io/ioutil"
     8  	"net/http"
     9  	"strings"
    10  	"testing"
    11  
    12  	"github.com/docker/docker/api/types"
    13  )
    14  
    15  func TestImagePullReferenceParseError(t *testing.T) {
    16  	client := &Client{
    17  		client: newMockClient(func(req *http.Request) (*http.Response, error) {
    18  			return nil, nil
    19  		}),
    20  	}
    21  	// An empty reference is an invalid reference
    22  	_, err := client.ImagePull(context.Background(), "", types.ImagePullOptions{})
    23  	if err == nil || !strings.Contains(err.Error(), "invalid reference format") {
    24  		t.Fatalf("expected an error, got %v", err)
    25  	}
    26  }
    27  
    28  func TestImagePullAnyError(t *testing.T) {
    29  	client := &Client{
    30  		client: newMockClient(errorMock(http.StatusInternalServerError, "Server error")),
    31  	}
    32  	_, err := client.ImagePull(context.Background(), "myimage", types.ImagePullOptions{})
    33  	if err == nil || err.Error() != "Error response from daemon: Server error" {
    34  		t.Fatalf("expected a Server Error, got %v", err)
    35  	}
    36  }
    37  
    38  func TestImagePullStatusUnauthorizedError(t *testing.T) {
    39  	client := &Client{
    40  		client: newMockClient(errorMock(http.StatusUnauthorized, "Unauthorized error")),
    41  	}
    42  	_, err := client.ImagePull(context.Background(), "myimage", types.ImagePullOptions{})
    43  	if err == nil || err.Error() != "Error response from daemon: Unauthorized error" {
    44  		t.Fatalf("expected an Unauthorized Error, got %v", err)
    45  	}
    46  }
    47  
    48  func TestImagePullWithUnauthorizedErrorAndPrivilegeFuncError(t *testing.T) {
    49  	client := &Client{
    50  		client: newMockClient(errorMock(http.StatusUnauthorized, "Unauthorized error")),
    51  	}
    52  	privilegeFunc := func() (string, error) {
    53  		return "", fmt.Errorf("Error requesting privilege")
    54  	}
    55  	_, err := client.ImagePull(context.Background(), "myimage", types.ImagePullOptions{
    56  		PrivilegeFunc: privilegeFunc,
    57  	})
    58  	if err == nil || err.Error() != "Error requesting privilege" {
    59  		t.Fatalf("expected an error requesting privilege, got %v", err)
    60  	}
    61  }
    62  
    63  func TestImagePullWithUnauthorizedErrorAndAnotherUnauthorizedError(t *testing.T) {
    64  	client := &Client{
    65  		client: newMockClient(errorMock(http.StatusUnauthorized, "Unauthorized error")),
    66  	}
    67  	privilegeFunc := func() (string, error) {
    68  		return "a-auth-header", nil
    69  	}
    70  	_, err := client.ImagePull(context.Background(), "myimage", types.ImagePullOptions{
    71  		PrivilegeFunc: privilegeFunc,
    72  	})
    73  	if err == nil || err.Error() != "Error response from daemon: Unauthorized error" {
    74  		t.Fatalf("expected an Unauthorized Error, got %v", err)
    75  	}
    76  }
    77  
    78  func TestImagePullWithPrivilegedFuncNoError(t *testing.T) {
    79  	expectedURL := "/images/create"
    80  	client := &Client{
    81  		client: newMockClient(func(req *http.Request) (*http.Response, error) {
    82  			if !strings.HasPrefix(req.URL.Path, expectedURL) {
    83  				return nil, fmt.Errorf("Expected URL '%s', got '%s'", expectedURL, req.URL)
    84  			}
    85  			auth := req.Header.Get("X-Registry-Auth")
    86  			if auth == "NotValid" {
    87  				return &http.Response{
    88  					StatusCode: http.StatusUnauthorized,
    89  					Body:       ioutil.NopCloser(bytes.NewReader([]byte("Invalid credentials"))),
    90  				}, nil
    91  			}
    92  			if auth != "IAmValid" {
    93  				return nil, fmt.Errorf("Invalid auth header : expected %s, got %s", "IAmValid", auth)
    94  			}
    95  			query := req.URL.Query()
    96  			fromImage := query.Get("fromImage")
    97  			if fromImage != "myimage" {
    98  				return nil, fmt.Errorf("fromimage not set in URL query properly. Expected '%s', got %s", "myimage", fromImage)
    99  			}
   100  			tag := query.Get("tag")
   101  			if tag != "latest" {
   102  				return nil, fmt.Errorf("tag not set in URL query properly. Expected '%s', got %s", "latest", tag)
   103  			}
   104  			return &http.Response{
   105  				StatusCode: http.StatusOK,
   106  				Body:       ioutil.NopCloser(bytes.NewReader([]byte("hello world"))),
   107  			}, nil
   108  		}),
   109  	}
   110  	privilegeFunc := func() (string, error) {
   111  		return "IAmValid", nil
   112  	}
   113  	resp, err := client.ImagePull(context.Background(), "myimage", types.ImagePullOptions{
   114  		RegistryAuth:  "NotValid",
   115  		PrivilegeFunc: privilegeFunc,
   116  	})
   117  	if err != nil {
   118  		t.Fatal(err)
   119  	}
   120  	body, err := ioutil.ReadAll(resp)
   121  	if err != nil {
   122  		t.Fatal(err)
   123  	}
   124  	if string(body) != "hello world" {
   125  		t.Fatalf("expected 'hello world', got %s", string(body))
   126  	}
   127  }
   128  
   129  func TestImagePullWithoutErrors(t *testing.T) {
   130  	expectedURL := "/images/create"
   131  	expectedOutput := "hello world"
   132  	pullCases := []struct {
   133  		all           bool
   134  		reference     string
   135  		expectedImage string
   136  		expectedTag   string
   137  	}{
   138  		{
   139  			all:           false,
   140  			reference:     "myimage",
   141  			expectedImage: "myimage",
   142  			expectedTag:   "latest",
   143  		},
   144  		{
   145  			all:           false,
   146  			reference:     "myimage:tag",
   147  			expectedImage: "myimage",
   148  			expectedTag:   "tag",
   149  		},
   150  		{
   151  			all:           true,
   152  			reference:     "myimage",
   153  			expectedImage: "myimage",
   154  			expectedTag:   "",
   155  		},
   156  		{
   157  			all:           true,
   158  			reference:     "myimage:anything",
   159  			expectedImage: "myimage",
   160  			expectedTag:   "",
   161  		},
   162  	}
   163  	for _, pullCase := range pullCases {
   164  		client := &Client{
   165  			client: newMockClient(func(req *http.Request) (*http.Response, error) {
   166  				if !strings.HasPrefix(req.URL.Path, expectedURL) {
   167  					return nil, fmt.Errorf("Expected URL '%s', got '%s'", expectedURL, req.URL)
   168  				}
   169  				query := req.URL.Query()
   170  				fromImage := query.Get("fromImage")
   171  				if fromImage != pullCase.expectedImage {
   172  					return nil, fmt.Errorf("fromimage not set in URL query properly. Expected '%s', got %s", pullCase.expectedImage, fromImage)
   173  				}
   174  				tag := query.Get("tag")
   175  				if tag != pullCase.expectedTag {
   176  					return nil, fmt.Errorf("tag not set in URL query properly. Expected '%s', got %s", pullCase.expectedTag, tag)
   177  				}
   178  				return &http.Response{
   179  					StatusCode: http.StatusOK,
   180  					Body:       ioutil.NopCloser(bytes.NewReader([]byte(expectedOutput))),
   181  				}, nil
   182  			}),
   183  		}
   184  		resp, err := client.ImagePull(context.Background(), pullCase.reference, types.ImagePullOptions{
   185  			All: pullCase.all,
   186  		})
   187  		if err != nil {
   188  			t.Fatal(err)
   189  		}
   190  		body, err := ioutil.ReadAll(resp)
   191  		if err != nil {
   192  			t.Fatal(err)
   193  		}
   194  		if string(body) != expectedOutput {
   195  			t.Fatalf("expected '%s', got %s", expectedOutput, string(body))
   196  		}
   197  	}
   198  }