package pack

import (

"bytes"

"context"

"crypto/sha256"

"encoding/hex"

"fmt"

"io"

"io/ioutil"

"math/rand"

"net/http"

"os"

"path/filepath"

"runtime"

"strings"

"testing"

"time"

"github.com/Masterminds/semver"

"github.com/buildpacks/imgutil"

"github.com/buildpacks/imgutil/fakes"

"github.com/buildpacks/imgutil/local"

"github.com/buildpacks/imgutil/remote"

"github.com/buildpacks/lifecycle/api"

"github.com/docker/docker/client"

"github.com/google/go-containerregistry/pkg/name"

"github.com/heroku/color"

"github.com/onsi/gomega/ghttp"

"github.com/pkg/errors"

"github.com/sclevine/spec"

"github.com/sclevine/spec/report"

"github.com/buildpacks/pack/config"

"github.com/buildpacks/pack/internal/blob"

"github.com/buildpacks/pack/internal/build"

"github.com/buildpacks/pack/internal/builder"

"github.com/buildpacks/pack/internal/buildpackage"

cfg "github.com/buildpacks/pack/internal/config"

"github.com/buildpacks/pack/internal/dist"

ifakes "github.com/buildpacks/pack/internal/fakes"

ilogging "github.com/buildpacks/pack/internal/logging"

rg "github.com/buildpacks/pack/internal/registry"

"github.com/buildpacks/pack/internal/style"

h "github.com/buildpacks/pack/testhelpers"

)

func TestBuild(t *testing.T) {

color.Disable(true)

defer color.Disable(false)

rand.Seed(time.Now().UTC().UnixNano())

spec.Run(t, "build", testBuild, spec.Report(report.Terminal{}))

}

func testBuild(t *testing.T, when spec.G, it spec.S) {

var (

subject *Client

fakeImageFetcher *ifakes.FakeImageFetcher

fakeLifecycle *ifakes.FakeLifecycle

defaultBuilderStackID = "some.stack.id"

defaultWindowsBuilderStackID = "some.windows.stack.id"

defaultBuilderImage *fakes.Image

defaultWindowsBuilderImage *fakes.Image

defaultBuilderName = "example.com/default/builder:tag"

defaultWindowsBuilderName = "example.com/windows-default/builder:tag"

defaultRunImageName = "default/run"

defaultWindowsRunImageName = "default/win-run"

fakeDefaultRunImage *fakes.Image

fakeDefaultWindowsRunImage *fakes.Image

fakeMirror1 *fakes.Image

fakeMirror2 *fakes.Image

tmpDir string

outBuf bytes.Buffer

logger *ilogging.LogWithWriters

fakeLifecycleImage *fakes.Image

)

it.Before(func() {

var err error

fakeImageFetcher = ifakes.NewFakeImageFetcher()

fakeLifecycle = &ifakes.FakeLifecycle{}

tmpDir, err = ioutil.TempDir("", "build-test")

h.AssertNil(t, err)

defaultBuilderImage = newFakeBuilderImage(t, tmpDir, defaultBuilderName, defaultBuilderStackID, defaultRunImageName, builder.DefaultLifecycleVersion, newLinuxImage)

h.AssertNil(t, defaultBuilderImage.SetLabel("io.buildpacks.stack.mixins", `["mixinA", "build:mixinB", "mixinX", "build:mixinY"]`))

fakeImageFetcher.LocalImages[defaultBuilderImage.Name()] = defaultBuilderImage

defaultWindowsBuilderImage = newFakeBuilderImage(t, tmpDir, defaultWindowsBuilderName, defaultWindowsBuilderStackID, defaultWindowsRunImageName, builder.DefaultLifecycleVersion, newWindowsImage)

h.AssertNil(t, defaultWindowsBuilderImage.SetLabel("io.buildpacks.stack.mixins", `["mixinA", "build:mixinB", "mixinX", "build:mixinY"]`))

fakeImageFetcher.LocalImages[defaultWindowsBuilderImage.Name()] = defaultWindowsBuilderImage

fakeDefaultWindowsRunImage = newWindowsImage("default/win-run", "", nil)

h.AssertNil(t, fakeDefaultWindowsRunImage.SetLabel("io.buildpacks.stack.id", defaultWindowsBuilderStackID))

h.AssertNil(t, fakeDefaultWindowsRunImage.SetLabel("io.buildpacks.stack.mixins", `["mixinA", "run:mixinC", "mixinX", "run:mixinZ"]`))

fakeImageFetcher.LocalImages[fakeDefaultWindowsRunImage.Name()] = fakeDefaultWindowsRunImage

fakeDefaultRunImage = newLinuxImage("default/run", "", nil)

h.AssertNil(t, fakeDefaultRunImage.SetLabel("io.buildpacks.stack.id", defaultBuilderStackID))

h.AssertNil(t, fakeDefaultRunImage.SetLabel("io.buildpacks.stack.mixins", `["mixinA", "run:mixinC", "mixinX", "run:mixinZ"]`))

fakeImageFetcher.LocalImages[fakeDefaultRunImage.Name()] = fakeDefaultRunImage

fakeMirror1 = newLinuxImage("registry1.example.com/run/mirror", "", nil)

h.AssertNil(t, fakeMirror1.SetLabel("io.buildpacks.stack.id", defaultBuilderStackID))

h.AssertNil(t, fakeMirror1.SetLabel("io.buildpacks.stack.mixins", `["mixinA", "mixinX", "run:mixinZ"]`))

fakeImageFetcher.LocalImages[fakeMirror1.Name()] = fakeMirror1

fakeMirror2 = newLinuxImage("registry2.example.com/run/mirror", "", nil)

h.AssertNil(t, fakeMirror2.SetLabel("io.buildpacks.stack.id", defaultBuilderStackID))

h.AssertNil(t, fakeMirror2.SetLabel("io.buildpacks.stack.mixins", `["mixinA", "mixinX", "run:mixinZ"]`))

fakeImageFetcher.LocalImages[fakeMirror2.Name()] = fakeMirror2

fakeLifecycleImage = newLinuxImage(fmt.Sprintf("%s:%s", cfg.DefaultLifecycleImageRepo, builder.DefaultLifecycleVersion), "", nil)

fakeImageFetcher.LocalImages[fakeLifecycleImage.Name()] = fakeLifecycleImage

docker, err := client.NewClientWithOpts(client.FromEnv, client.WithVersion("1.38"))

h.AssertNil(t, err)

logger = ilogging.NewLogWithWriters(&outBuf, &outBuf)

dlCacheDir, err := ioutil.TempDir(tmpDir, "dl-cache")

h.AssertNil(t, err)

subject = &Client{

logger: logger,

imageFetcher: fakeImageFetcher,

downloader: blob.NewDownloader(logger, dlCacheDir),

lifecycleExecutor: fakeLifecycle,

docker: docker,

}

})

it.After(func() {

defaultBuilderImage.Cleanup()

fakeDefaultRunImage.Cleanup()

fakeMirror1.Cleanup()

fakeMirror2.Cleanup()

os.RemoveAll(tmpDir)

fakeLifecycleImage.Cleanup()

})

when("#Build", func() {

when("Image option", func() {

it("is required", func() {

h.AssertError(t, subject.Build(context.TODO(), BuildOptions{

Image: "",

Builder: defaultBuilderName,

}),

"invalid image name ''",

)

})

it("must be a valid image reference", func() {

h.AssertError(t, subject.Build(context.TODO(), BuildOptions{

Image: "not@valid",

Builder: defaultBuilderName,

}),

"invalid image name 'not@valid'",

)

})

it("must be a valid tag reference", func() {

h.AssertError(t, subject.Build(context.TODO(), BuildOptions{

Image: "registry.com/my/image@sha256:954e1f01e80ce09d0887ff6ea10b13a812cb01932a0781d6b0cc23f743a874fd",

Builder: defaultBuilderName,

}),

"invalid image name 'registry.com/my/image@sha256:954e1f01e80ce09d0887ff6ea10b13a812cb01932a0781d6b0cc23f743a874fd'",

)

})

it("lifecycle receives resolved reference", func() {

h.AssertNil(t, subject.Build(context.TODO(), BuildOptions{

Builder: defaultBuilderName,

Image: "example.com/some/repo:tag",

}))

h.AssertEq(t, fakeLifecycle.Opts.Image.Context().RegistryStr(), "example.com")

h.AssertEq(t, fakeLifecycle.Opts.Image.Context().RepositoryStr(), "some/repo")

h.AssertEq(t, fakeLifecycle.Opts.Image.Identifier(), "tag")

})

})

when("Quiet mode", func() {

var builtImage *fakes.Image

it.After(func() {

logger.WantQuiet(false)

})

when("publish", func() {

var remoteRunImage, builderWithoutLifecycleImageOrCreator *fakes.Image

it.Before(func() {

remoteRunImage = fakes.NewImage("default/run", "", nil)

h.AssertNil(t, remoteRunImage.SetLabel("io.buildpacks.stack.id", defaultBuilderStackID))

h.AssertNil(t, remoteRunImage.SetLabel("io.buildpacks.stack.mixins", `["mixinA", "mixinX", "run:mixinZ"]`))

fakeImageFetcher.RemoteImages[remoteRunImage.Name()] = remoteRunImage

builderWithoutLifecycleImageOrCreator = newFakeBuilderImage(

t,

tmpDir,

"example.com/supportscreator/builder:tag",

"some.stack.id",

defaultRunImageName,

"0.3.0",

newLinuxImage,

)

h.AssertNil(t, builderWithoutLifecycleImageOrCreator.SetLabel("io.buildpacks.stack.mixins", `["mixinA", "build:mixinB", "mixinX", "build:mixinY"]`))

fakeImageFetcher.LocalImages[builderWithoutLifecycleImageOrCreator.Name()] = builderWithoutLifecycleImageOrCreator

digest, err := name.NewDigest("example.io/some/app@sha256:363c754893f0efe22480b4359a5956cf3bd3ce22742fc576973c61348308c2e4", name.WeakValidation)

h.AssertNil(t, err)

builtImage = fakes.NewImage("example.io/some/app:latest", "", remote.DigestIdentifier{Digest: digest})

fakeImageFetcher.RemoteImages[builtImage.Name()] = builtImage

})

it.After(func() {

remoteRunImage.Cleanup()

builderWithoutLifecycleImageOrCreator.Cleanup()

h.AssertNil(t, builtImage.Cleanup())

})

it("only prints app name and sha", func() {

logger.WantQuiet(true)

h.AssertNil(t, subject.Build(context.TODO(), BuildOptions{

Image: "example.io/some/app",

Builder: defaultBuilderName,

AppPath: filepath.Join("testdata", "some-app"),

Publish: true,

}))

h.AssertEq(t, strings.TrimSpace(outBuf.String()), "example.io/some/app@sha256:363c754893f0efe22480b4359a5956cf3bd3ce22742fc576973c61348308c2e4")

})

})

when("local", func() {

it.Before(func() {

builtImage = fakes.NewImage("index.docker.io/some/app:latest", "", local.IDIdentifier{

ImageID: "363c754893f0efe22480b4359a5956cf3bd3ce22742fc576973c61348308c2e4",

})

fakeImageFetcher.LocalImages[builtImage.Name()] = builtImage

})

it.After(func() {

builtImage.Cleanup()

})

it("only prints app name and sha", func() {

logger.WantQuiet(true)

h.AssertNil(t, subject.Build(context.TODO(), BuildOptions{

Image: "some/app",

Builder: defaultBuilderName,

AppPath: filepath.Join("testdata", "some-app"),

}))

h.AssertEq(t, strings.TrimSpace(outBuf.String()), "some/app@sha256:363c754893f0efe22480b4359a5956cf3bd3ce22742fc576973c61348308c2e4")

})

})

})

when("AppDir option", func() {

it("defaults to the current working directory", func() {

h.AssertNil(t, subject.Build(context.TODO(), BuildOptions{

Image: "some/app",

Builder: defaultBuilderName,

}))

wd, err := os.Getwd()

h.AssertNil(t, err)

resolvedWd, err := filepath.EvalSymlinks(wd)

h.AssertNil(t, err)

h.AssertEq(t, fakeLifecycle.Opts.AppPath, resolvedWd)

})

for fileDesc, appPath := range map[string]string{

"zip": filepath.Join("testdata", "zip-file.zip"),

"jar": filepath.Join("testdata", "jar-file.jar"),

} {

fileDesc := fileDesc

appPath := appPath

it(fmt.Sprintf("supports %s files", fileDesc), func() {

err := subject.Build(context.TODO(), BuildOptions{

Image: "some/app",

Builder: defaultBuilderName,

AppPath: appPath,

})

h.AssertNil(t, err)

})

}

for fileDesc, testData := range map[string][]string{

"non-existent": {"not/exist/path", "does not exist"},

"empty": {filepath.Join("testdata", "empty-file"), "app path must be a directory or zip"},

"non-zip": {filepath.Join("testdata", "non-zip-file"), "app path must be a directory or zip"},

} {

fileDesc := fileDesc

appPath := testData[0]

errMessage := testData[0]

it(fmt.Sprintf("does NOT support %s files", fileDesc), func() {

err := subject.Build(context.TODO(), BuildOptions{

Image: "some/app",

Builder: defaultBuilderName,

AppPath: appPath,

})

h.AssertError(t, err, errMessage)

})

}

it("resolves the absolute path", func() {

h.AssertNil(t, subject.Build(context.TODO(), BuildOptions{

Image: "some/app",

Builder: defaultBuilderName,

AppPath: filepath.Join("testdata", "some-app"),

}))

absPath, err := filepath.Abs(filepath.Join("testdata", "some-app"))

h.AssertNil(t, err)

h.AssertEq(t, fakeLifecycle.Opts.AppPath, absPath)

})

when("appDir is a symlink", func() {

var (

appDirName = "some-app"

absoluteAppDir string

tmpDir string

err error

)

it.Before(func() {

tmpDir, err = ioutil.TempDir("", "build-symlink-test")

h.AssertNil(t, err)

appDirPath := filepath.Join(tmpDir, appDirName)

h.AssertNil(t, os.MkdirAll(filepath.Join(tmpDir, appDirName), 0666))

absoluteAppDir, err = filepath.Abs(appDirPath)

h.AssertNil(t, err)

absoluteAppDir, err = filepath.EvalSymlinks(appDirPath)

h.AssertNil(t, err)

})

it.After(func() {

os.RemoveAll(tmpDir)

})

it("resolves relative symbolic links", func() {

relLink := filepath.Join(tmpDir, "some-app.link")

h.AssertNil(t, os.Symlink(filepath.Join(".", appDirName), relLink))

h.AssertNil(t, subject.Build(context.TODO(), BuildOptions{

Image: "some/app",

Builder: defaultBuilderName,

AppPath: relLink,

}))

h.AssertEq(t, fakeLifecycle.Opts.AppPath, absoluteAppDir)

})

it("resolves absolute symbolic links", func() {

relLink := filepath.Join(tmpDir, "some-app.link")

h.AssertNil(t, os.Symlink(absoluteAppDir, relLink))

h.AssertNil(t, subject.Build(context.TODO(), BuildOptions{

Image: "some/app",

Builder: defaultBuilderName,

AppPath: relLink,

}))

h.AssertEq(t, fakeLifecycle.Opts.AppPath, absoluteAppDir)

})

it("resolves symbolic links recursively", func() {

linkRef1 := absoluteAppDir

absoluteLink1 := filepath.Join(tmpDir, "some-app-abs-1.link")

linkRef2 := "some-app-abs-1.link"

symbolicLink := filepath.Join(tmpDir, "some-app-rel-2.link")

h.AssertNil(t, os.Symlink(linkRef1, absoluteLink1))

h.AssertNil(t, os.Symlink(linkRef2, symbolicLink))

h.AssertNil(t, subject.Build(context.TODO(), BuildOptions{

Image: "some/app",

Builder: defaultBuilderName,

AppPath: symbolicLink,

}))

h.AssertEq(t, fakeLifecycle.Opts.AppPath, absoluteAppDir)

})

})

})

when("Builder option", func() {

it("builder is required", func() {

h.AssertError(t, subject.Build(context.TODO(), BuildOptions{

Image: "some/app",

}),

"invalid builder ''",

)

})

when("the builder name is provided", func() {

var (

customBuilderImage *fakes.Image

fakeRunImage *fakes.Image

)

it.Before(func() {

customBuilderImage = ifakes.NewFakeBuilderImage(t,

tmpDir,

defaultBuilderName,

"some.stack.id",

"1234",

"5678",

builder.Metadata{

Stack: builder.StackMetadata{

RunImage: builder.RunImageMetadata{

Image: "some/run",

},

},

Lifecycle: builder.LifecycleMetadata{

LifecycleInfo: builder.LifecycleInfo{

Version: &builder.Version{

Version: *semver.MustParse(builder.DefaultLifecycleVersion),

},

},

APIs: builder.LifecycleAPIs{

Buildpack: builder.APIVersions{

Supported: builder.APISet{api.MustParse("0.2"), api.MustParse("0.3"), api.MustParse("0.4")},

},

Platform: builder.APIVersions{

Supported: builder.APISet{api.MustParse("0.3"), api.MustParse("0.4")},

},

},

},

},

nil,

nil,

newLinuxImage,

)

fakeImageFetcher.LocalImages[customBuilderImage.Name()] = customBuilderImage

fakeRunImage = fakes.NewImage("some/run", "", nil)

h.AssertNil(t, fakeRunImage.SetLabel("io.buildpacks.stack.id", "some.stack.id"))

fakeImageFetcher.LocalImages[fakeRunImage.Name()] = fakeRunImage

})

it.After(func() {

customBuilderImage.Cleanup()

fakeRunImage.Cleanup()

})

it("it uses the provided builder", func() {

h.AssertNil(t, subject.Build(context.TODO(), BuildOptions{

Image: "some/app",

Builder: defaultBuilderName,

}))

h.AssertEq(t, fakeLifecycle.Opts.Builder.Name(), customBuilderImage.Name())

})

})

})

when("RunImage option", func() {

var (

fakeRunImage *fakes.Image

)

it.Before(func() {

fakeRunImage = fakes.NewImage("custom/run", "", nil)

h.AssertNil(t, fakeRunImage.SetLabel("io.buildpacks.stack.id", defaultBuilderStackID))

h.AssertNil(t, fakeRunImage.SetLabel("io.buildpacks.stack.mixins", `["mixinA", "mixinX", "run:mixinZ"]`))

fakeImageFetcher.LocalImages[fakeRunImage.Name()] = fakeRunImage

})

it.After(func() {

fakeRunImage.Cleanup()

})

when("run image stack matches the builder stack", func() {

it("uses the provided image", func() {

h.AssertNil(t, subject.Build(context.TODO(), BuildOptions{

Image: "some/app",

Builder: defaultBuilderName,

RunImage: "custom/run",

}))

h.AssertEq(t, fakeLifecycle.Opts.RunImage, "custom/run")

})

})

when("run image stack does not match the builder stack", func() {

it.Before(func() {

h.AssertNil(t, fakeRunImage.SetLabel("io.buildpacks.stack.id", "other.stack"))

})

it("errors", func() {

h.AssertError(t, subject.Build(context.TODO(), BuildOptions{

Image: "some/app",

Builder: defaultBuilderName,

RunImage: "custom/run",

}),

"invalid run-image 'custom/run': run-image stack id 'other.stack' does not match builder stack 'some.stack.id'",

)

})

})

when("run image is not supplied", func() {

when("there are no locally configured mirrors", func() {

when("Publish is true", func() {

it("chooses the run image mirror matching the local image", func() {

fakeImageFetcher.RemoteImages[fakeDefaultRunImage.Name()] = fakeDefaultRunImage

h.AssertNil(t, subject.Build(context.TODO(), BuildOptions{

Image: "some/app",

Builder: defaultBuilderName,

Publish: true,

}))

h.AssertEq(t, fakeLifecycle.Opts.RunImage, "default/run")

})

for _, registry := range []string{"registry1.example.com", "registry2.example.com"} {

testRegistry := registry

it("chooses the run image mirror matching the built image", func() {

runImg := testRegistry + "/run/mirror"

fakeImageFetcher.RemoteImages[runImg] = fakeDefaultRunImage

h.AssertNil(t, subject.Build(context.TODO(), BuildOptions{

Image: testRegistry + "/some/app",

Builder: defaultBuilderName,

Publish: true,

}))

h.AssertEq(t, fakeLifecycle.Opts.RunImage, runImg)

})

}

})

when("Publish is false", func() {

for _, img := range []string{"some/app",

"registry1.example.com/some/app",

"registry2.example.com/some/app"} {

testImg := img

it("chooses a mirror on the builder registry", func() {

h.AssertNil(t, subject.Build(context.TODO(), BuildOptions{

Image: testImg,

Builder: defaultBuilderName,

}))

h.AssertEq(t, fakeLifecycle.Opts.RunImage, "default/run")

})

}

})

})

when("there are locally configured mirrors", func() {

var (

fakeLocalMirror *fakes.Image

fakeLocalMirror1 *fakes.Image

mirrors = map[string][]string{

"default/run": {"local/mirror", "registry1.example.com/local/mirror"},

}

)

it.Before(func() {

fakeLocalMirror = fakes.NewImage("local/mirror", "", nil)

h.AssertNil(t, fakeLocalMirror.SetLabel("io.buildpacks.stack.id", defaultBuilderStackID))

h.AssertNil(t, fakeLocalMirror.SetLabel("io.buildpacks.stack.mixins", `["mixinA", "mixinX", "run:mixinZ"]`))

fakeImageFetcher.LocalImages[fakeLocalMirror.Name()] = fakeLocalMirror

fakeLocalMirror1 = fakes.NewImage("registry1.example.com/local/mirror", "", nil)

h.AssertNil(t, fakeLocalMirror1.SetLabel("io.buildpacks.stack.id", defaultBuilderStackID))

h.AssertNil(t, fakeLocalMirror1.SetLabel("io.buildpacks.stack.mixins", `["mixinA", "mixinX", "run:mixinZ"]`))

fakeImageFetcher.LocalImages[fakeLocalMirror1.Name()] = fakeLocalMirror1

})

it.After(func() {

fakeLocalMirror.Cleanup()

fakeLocalMirror1.Cleanup()

})

when("Publish is true", func() {

for _, registry := range []string{"", "registry1.example.com"} {

testRegistry := registry

it("prefers user provided mirrors for registry "+testRegistry, func() {

if testRegistry != "" {

testRegistry += "/"

}

runImg := testRegistry + "local/mirror"

fakeImageFetcher.RemoteImages[runImg] = fakeDefaultRunImage

h.AssertNil(t, subject.Build(context.TODO(), BuildOptions{

Image: testRegistry + "some/app",

Builder: defaultBuilderName,

AdditionalMirrors: mirrors,

Publish: true,

}))

h.AssertEq(t, fakeLifecycle.Opts.RunImage, runImg)

})

}

})

when("Publish is false", func() {

for _, registry := range []string{"", "registry1.example.com", "registry2.example.com"} {

testRegistry := registry

it("prefers user provided mirrors", func() {

h.AssertNil(t, subject.Build(context.TODO(), BuildOptions{

Image: testRegistry + "some/app",

Builder: defaultBuilderName,

AdditionalMirrors: mirrors,

}))

h.AssertEq(t, fakeLifecycle.Opts.RunImage, "local/mirror")

})

}

})

})

})

})

when("ClearCache option", func() {

it("passes it through to lifecycle", func() {

h.AssertNil(t, subject.Build(context.TODO(), BuildOptions{

Image: "some/app",

Builder: defaultBuilderName,

ClearCache: true,

}))

h.AssertEq(t, fakeLifecycle.Opts.ClearCache, true)

})

it("defaults to false", func() {

h.AssertNil(t, subject.Build(context.TODO(), BuildOptions{

Image: "some/app",

Builder: defaultBuilderName,

}))

h.AssertEq(t, fakeLifecycle.Opts.ClearCache, false)

})

})

when("ImageCache option", func() {

it("passes it through to lifecycle", func() {

h.AssertNil(t, subject.Build(context.TODO(), BuildOptions{

Image: "some/app",

Builder: defaultBuilderName,

CacheImage: "some-cache-image",

}))

h.AssertEq(t, fakeLifecycle.Opts.CacheImage, "some-cache-image")

})

it("defaults to false", func() {

h.AssertNil(t, subject.Build(context.TODO(), BuildOptions{

Image: "some/app",

Builder: defaultBuilderName,

}))

h.AssertEq(t, fakeLifecycle.Opts.CacheImage, "")

})

})

when("Buildpacks option", func() {

assertOrderEquals := func(content string) {

t.Helper()

orderLayer, err := defaultBuilderImage.FindLayerWithPath("/cnb/order.toml")

h.AssertNil(t, err)

h.AssertOnTarEntry(t, orderLayer, "/cnb/order.toml", h.ContentEquals(content))

}

it("builder order is overwritten", func() {

additionalBP := ifakes.CreateBuildpackTar(t, tmpDir, dist.BuildpackDescriptor{

API: api.MustParse("0.3"),

Info: dist.BuildpackInfo{

ID: "buildpack.add.1.id",

Version: "buildpack.add.1.version",

},

Stacks: []dist.Stack{{ID: defaultBuilderStackID}},

Order: nil,

})

h.AssertNil(t, subject.Build(context.TODO(), BuildOptions{

Image: "some/app",

Builder: defaultBuilderName,

ClearCache: true,

Buildpacks: []string{additionalBP},

}))

h.AssertEq(t, fakeLifecycle.Opts.Builder.Name(), defaultBuilderImage.Name())

assertOrderEquals(`[[order]]

[[order.group]]

id = "buildpack.add.1.id"

version = "buildpack.add.1.version"

`)

})

when("id - no version is provided", func() {

it("resolves version", func() {

h.AssertNil(t, subject.Build(context.TODO(), BuildOptions{

Image: "some/app",

Builder: defaultBuilderName,

ClearCache: true,

Buildpacks: []string{"buildpack.1.id"},

}))

h.AssertEq(t, fakeLifecycle.Opts.Builder.Name(), defaultBuilderImage.Name())

assertOrderEquals(`[[order]]

[[order.group]]

id = "buildpack.1.id"

version = "buildpack.1.version"

`)

})

})

when("from=builder:id@version", func() {

it("builder order is prepended", func() {

h.AssertNil(t, subject.Build(context.TODO(), BuildOptions{

Image: "some/app",

Builder: defaultBuilderName,

ClearCache: true,

Buildpacks: []string{

"from=builder:[email protected]",

},

}))

h.AssertEq(t, fakeLifecycle.Opts.Builder.Name(), defaultBuilderImage.Name())

assertOrderEquals(`[[order]]

[[order.group]]

id = "buildpack.1.id"

version = "buildpack.1.version"

`)

})

})

when("from=builder is set first", func() {

it("builder order is prepended", func() {

additionalBP1 := ifakes.CreateBuildpackTar(t, tmpDir, dist.BuildpackDescriptor{

API: api.MustParse("0.3"),

Info: dist.BuildpackInfo{

ID: "buildpack.add.1.id",

Version: "buildpack.add.1.version",

},

Stacks: []dist.Stack{{ID: defaultBuilderStackID}},

Order: nil,

})

additionalBP2 := ifakes.CreateBuildpackTar(t, tmpDir, dist.BuildpackDescriptor{

API: api.MustParse("0.3"),

Info: dist.BuildpackInfo{

ID: "buildpack.add.2.id",

Version: "buildpack.add.2.version",

},

Stacks: []dist.Stack{{ID: defaultBuilderStackID}},

Order: nil,

})

h.AssertNil(t, subject.Build(context.TODO(), BuildOptions{

Image: "some/app",

Builder: defaultBuilderName,

ClearCache: true,

Buildpacks: []string{

"from=builder",

additionalBP1,

additionalBP2,

},

}))

assertOrderEquals(`[[order]]

[[order.group]]

id = "buildpack.1.id"

version = "buildpack.1.version"

[[order.group]]

id = "buildpack.add.1.id"

version = "buildpack.add.1.version"

[[order.group]]

id = "buildpack.add.2.id"

version = "buildpack.add.2.version"

[[order]]

[[order.group]]

id = "buildpack.2.id"

version = "buildpack.2.version"

[[order.group]]

id = "buildpack.add.1.id"

version = "buildpack.add.1.version"

[[order.group]]

id = "buildpack.add.2.id"

version = "buildpack.add.2.version"

`)

})

})

when("from=builder is set in middle", func() {

it("builder order is appended", func() {

additionalBP1 := ifakes.CreateBuildpackTar(t, tmpDir, dist.BuildpackDescriptor{

API: api.MustParse("0.3"),

Info: dist.BuildpackInfo{

ID: "buildpack.add.1.id",

Version: "buildpack.add.1.version",

},

Stacks: []dist.Stack{{ID: defaultBuilderStackID}},

Order: nil,

})

additionalBP2 := ifakes.CreateBuildpackTar(t, tmpDir, dist.BuildpackDescriptor{

API: api.MustParse("0.3"),

Info: dist.BuildpackInfo{

ID: "buildpack.add.2.id",

Version: "buildpack.add.2.version",

},

Stacks: []dist.Stack{{ID: defaultBuilderStackID}},

Order: nil,

})

h.AssertNil(t, subject.Build(context.TODO(), BuildOptions{

Image: "some/app",

Builder: defaultBuilderName,

ClearCache: true,

Buildpacks: []string{

additionalBP1,

"from=builder",

additionalBP2,

},

}))

h.AssertEq(t, fakeLifecycle.Opts.Builder.Name(), defaultBuilderImage.Name())

assertOrderEquals(`[[order]]

[[order.group]]

id = "buildpack.add.1.id"

version = "buildpack.add.1.version"

[[order.group]]

id = "buildpack.1.id"

version = "buildpack.1.version"

[[order.group]]

id = "buildpack.add.2.id"

version = "buildpack.add.2.version"

[[order]]

[[order.group]]

id = "buildpack.add.1.id"

version = "buildpack.add.1.version"

[[order.group]]

id = "buildpack.2.id"

version = "buildpack.2.version"

[[order.group]]

id = "buildpack.add.2.id"

version = "buildpack.add.2.version"

`)

})

})

when("from=builder is set last", func() {

it("builder order is appended", func() {

additionalBP1 := ifakes.CreateBuildpackTar(t, tmpDir, dist.BuildpackDescriptor{

API: api.MustParse("0.3"),

Info: dist.BuildpackInfo{

ID: "buildpack.add.1.id",

Version: "buildpack.add.1.version",

},

Stacks: []dist.Stack{{ID: defaultBuilderStackID}},

Order: nil,

})

additionalBP2 := ifakes.CreateBuildpackTar(t, tmpDir, dist.BuildpackDescriptor{

API: api.MustParse("0.3"),

Info: dist.BuildpackInfo{

ID: "buildpack.add.2.id",

Version: "buildpack.add.2.version",

},

Stacks: []dist.Stack{{ID: defaultBuilderStackID}},

Order: nil,

})

h.AssertNil(t, subject.Build(context.TODO(), BuildOptions{

Image: "some/app",

Builder: defaultBuilderName,

ClearCache: true,

Buildpacks: []string{

additionalBP1,

additionalBP2,

"from=builder",

},

}))

h.AssertEq(t, fakeLifecycle.Opts.Builder.Name(), defaultBuilderImage.Name())

assertOrderEquals(`[[order]]

[[order.group]]

id = "buildpack.add.1.id"

version = "buildpack.add.1.version"

[[order.group]]

id = "buildpack.add.2.id"

version = "buildpack.add.2.version"

[[order.group]]

id = "buildpack.1.id"

version = "buildpack.1.version"

[[order]]

[[order.group]]

id = "buildpack.add.1.id"

version = "buildpack.add.1.version"

[[order.group]]

id = "buildpack.add.2.id"

version = "buildpack.add.2.version"

[[order.group]]

id = "buildpack.2.id"

version = "buildpack.2.version"

`)

})

})

when("meta-buildpack is used", func() {

it("resolves buildpack from builder", func() {

buildpackTar := ifakes.CreateBuildpackTar(t, tmpDir, dist.BuildpackDescriptor{

API: api.MustParse("0.3"),

Info: dist.BuildpackInfo{

ID: "metabuildpack.id",

Version: "metabuildpack.version",

},

Stacks: nil,

Order: dist.Order{{

Group: []dist.BuildpackRef{{

BuildpackInfo: dist.BuildpackInfo{

ID: "buildpack.1.id",

Version: "buildpack.1.version",

},

Optional: false,

}, {

BuildpackInfo: dist.BuildpackInfo{

ID: "buildpack.2.id",

Version: "buildpack.2.version",

},

Optional: false,

}},

}},

})

err := subject.Build(context.TODO(), BuildOptions{

Image: "some/app",

Builder: defaultBuilderName,

ClearCache: true,

Buildpacks: []string{buildpackTar},

})

h.AssertNil(t, err)

})

})

when("buildpackage image is used", func() {

var fakePackage *fakes.Image

it.Before(func() {

metaBuildpackTar := ifakes.CreateBuildpackTar(t, tmpDir, dist.BuildpackDescriptor{

API: api.MustParse("0.3"),

Info: dist.BuildpackInfo{

ID: "meta.buildpack.id",

Version: "meta.buildpack.version",

Homepage: "http://meta.buildpack",

},

Stacks: nil,

Order: dist.Order{{

Group: []dist.BuildpackRef{{

BuildpackInfo: dist.BuildpackInfo{

ID: "child.buildpack.id",

Version: "child.buildpack.version",

},

Optional: false,

}},

}},

})

childBuildpackTar := ifakes.CreateBuildpackTar(t, tmpDir, dist.BuildpackDescriptor{

API: api.MustParse("0.3"),

Info: dist.BuildpackInfo{

ID: "child.buildpack.id",

Version: "child.buildpack.version",

Homepage: "http://child.buildpack",

},

Stacks: []dist.Stack{

{ID: defaultBuilderStackID},

},

})