Function TestPullingForeignLayer

pkg/v1/remote/image_test.go:562–689

(t *testing.T)

}

func TestPullingForeignLayer(t *testing.T) {
	// For that sweet, sweet coverage in options.
	var b bytes.Buffer
	logs.Debug.SetOutput(&b)

	img := randomImage(t)
	expectedRepo := "foo/bar"
	foreignPath := "/foreign/path"

	foreignLayer, err := random.Layer(1024, types.DockerForeignLayer)
	if err != nil {
		t.Fatal(err)
	}

	foreignServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch r.URL.Path {
		case foreignPath:
			compressed, err := foreignLayer.Compressed()
			if err != nil {
				t.Fatal(err)
			}
			if _, err := io.Copy(w, compressed); err != nil {
				t.Fatal(err)
			}
			w.WriteHeader(http.StatusOK)
		default:
			t.Fatalf("Unexpected path: %v", r.URL.Path)
		}
	}))
	defer foreignServer.Close()
	fu, err := url.Parse(foreignServer.URL)
	if err != nil {
		t.Fatalf("url.Parse(%v) = %v", foreignServer.URL, err)
	}

	// Use "localhost" (not "127.0.0.1") so the hostname is not an IP literal
	// and is not rejected by validateForeignURL's private-address check.
	// DNS-based SSRF is explicitly out of scope for this validation.
	img, err = mutate.Append(img, mutate.Addendum{
		Layer: foreignLayer,
		URLs: []string{
			"http://localhost:" + fu.Port() + foreignPath,
		},
	})
	if err != nil {
		t.Fatal(err)
	}

	// Set up a fake registry that will respond 404 to the foreign layer,
	// but serve everything else correctly.
	configPath := fmt.Sprintf("/v2/%s/blobs/%s", expectedRepo, mustConfigName(t, img))
	manifestPath := fmt.Sprintf("/v2/%s/manifests/latest", expectedRepo)
	foreignLayerDigest := mustManifest(t, img).Layers[1].Digest
	foreignLayerPath := fmt.Sprintf("/v2/%s/blobs/%s", expectedRepo, foreignLayerDigest)
	layerDigest := mustManifest(t, img).Layers[0].Digest
	layerPath := fmt.Sprintf("/v2/%s/blobs/%s", expectedRepo, layerDigest)

	layer, err := img.LayerByDigest(layerDigest)