pipenv-install/detect_test.go at main · paketo-buildpacks/pipenv-install · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
package pipenvinstall_test

import (
	"os"
	"path/filepath"
	"testing"

	"github.com/paketo-buildpacks/packit/v2"
	pipenvinstall "github.com/paketo-buildpacks/pipenv-install"
	"github.com/paketo-buildpacks/pipenv-install/fakes"
	"github.com/sclevine/spec"

	. "github.com/onsi/gomega"
)

func testDetect(t *testing.T, context spec.G, it spec.S) {
	var (
		Expect        = NewWithT(t).Expect
		detect        packit.DetectFunc
		lockParser    *fakes.Parser
		pipfileParser *fakes.Parser
		workingDir    string
	)

	it.Before(func() {
		var err error
		workingDir, err = os.MkdirTemp("", "working-dir")
		Expect(err).NotTo(HaveOccurred())

		err = os.WriteFile(filepath.Join(workingDir, "Pipfile"), []byte{}, 0644)
		Expect(err).NotTo(HaveOccurred())

		pipfileParser = &fakes.Parser{}
		lockParser = &fakes.Parser{}

		detect = pipenvinstall.Detect(pipfileParser, lockParser)
	})

	context("detection", func() {
		it("returns a build plan that provides site-packages", func() {
			result, err := detect(packit.DetectContext{
				WorkingDir: workingDir,
			})
			Expect(err).NotTo(HaveOccurred())

			Expect(result.Plan).To(Equal(packit.BuildPlan{
				Provides: []packit.BuildPlanProvision{
					{Name: pipenvinstall.SitePackages},
				},
				Requires: []packit.BuildPlanRequirement{
					{
						Name: pipenvinstall.CPython,
						Metadata: pipenvinstall.BuildPlanMetadata{
							Build: true,
						},
					},
					{
						Name: pipenvinstall.Pipenv,
						Metadata: pipenvinstall.BuildPlanMetadata{
							Build: true,
						},
					},
				},
			}))
			Expect(pipfileParser.ParseVersionCall.Receives.Path).To(Equal(workingDir))
		})

		context("when there is no Pipfile", func() {
			it.Before(func() {
				Expect(os.Remove(filepath.Join(workingDir, "Pipfile"))).To(Succeed())
			})

			it("fails detection", func() {
				_, err := detect(packit.DetectContext{
					WorkingDir: workingDir,
				})
				Expect(err).To(MatchError(packit.Fail.WithMessage("no 'Pipfile' found")))
			})
		})

		context("when there is a Pipfile.lock", func() {
			it.Before(func() {
				err := os.WriteFile(filepath.Join(workingDir, "Pipfile.lock"), []byte{}, 0644)
				Expect(err).NotTo(HaveOccurred())
			})

			it.After(func() {
				Expect(os.Remove(filepath.Join(workingDir, "Pipfile.lock"))).To(Succeed())
			})

			it("calls Pipfile lock parser", func() {
				_, err := detect(packit.DetectContext{
					WorkingDir: workingDir,
				})
				Expect(err).NotTo(HaveOccurred())
				Expect(lockParser.ParseVersionCall.Receives.Path).To(Equal(workingDir))
			})
		})

		context("failure cases", func() {
			context("when the Pipfile cannot be read", func() {
				it.Before(func() {
					Expect(os.Chmod(workingDir, 0000)).To(Succeed())
				})

				it.After(func() {
					Expect(os.Chmod(workingDir, os.ModePerm)).To(Succeed())
				})

				it("returns an error", func() {
					_, err := detect(packit.DetectContext{
						WorkingDir: workingDir,
					})
					Expect(err).To(MatchError(ContainSubstring("permission denied")))
				})
			})
		})
	})
}