kairos/luet
1
0
Fork 0
mirror of https://github.com/mudler/luet.git synced 2025-09-01 15:18:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

Adapt tests and fixup races in spinner

Browse Source 
Signed-off-by: Ettore Di Giacinto <mudler@gentoo.org>
This commit is contained in:
Ettore Di Giacinto
2019-11-16 11:27:24 +01:00
parent b2060c82e3
commit 3e850e9607
7 changed files with 100 additions and 62 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
pkg/compiler/compiler_test.go
View File

@@ -102,7 +102,7 @@ var _ = Describe("Compiler", func() {
spec.SetOutputPath(tmpdir)
spec2.SetOutputPath(tmpdir)
artifacts, errs := compiler.CompileParallel(2, false, NewLuetCompilationspecs(spec, spec2))
Expect(len(errs)).To(Equal(0))
Expect(errs).To(BeNil())
for _, artifact := range artifacts {
Expect(helpers.Exists(artifact.GetPath())).To(BeTrue())
Expect(helpers.Untar(artifact.GetPath(), tmpdir, false)).ToNot(HaveOccurred())

42
pkg/logger/logger.go
View File

@@ -3,7 +3,6 @@ package logger
import (
"fmt"
"os"
"sync"
"time"
. "github.com/logrusorgru/aurora"
@@ -11,42 +10,30 @@ import (
"github.com/briandowns/spinner"
)
var s *spinner.Spinner
var m = &sync.Mutex{}
var enabled = false
var s *spinner.Spinner = spinner.New(spinner.CharSets[22], 100*time.Millisecond)
func Spinner(i int) {
m.Lock()
defer m.Unlock()
if i > 43 {
i = 43
}
if s == nil {
s = spinner.New(spinner.CharSets[i], 100*time.Millisecond) // Build our new spinner
if !s.Active() {
// s.UpdateCharSet(spinner.CharSets[i])
s.Start() // Start the spinner
}
s.UpdateCharSet(spinner.CharSets[i])
enabled = true
s.Start() // Start the spinner
}
func SpinnerText(suffix, prefix string) {
m.Lock()
defer m.Unlock()
if s == nil {
s = spinner.New(spinner.CharSets[22], 100*time.Millisecond) // Build our new spinner
}
s.Lock()
defer s.Unlock()
s.Suffix = Bold(Magenta(suffix)).BgBlack().String()
s.Prefix = Bold(Cyan(prefix)).String()
}
func SpinnerStop() {
m.Lock()
defer m.Unlock()
if s != nil {
s.Stop()
}
enabled = false
s.Stop()
}
func msg(level string, msg ...interface{}) {
@@ -67,17 +54,16 @@ func msg(level string, msg ...interface{}) {
levelMsg = Bold(Red("💣 " + message + "🔥")).BgBlack().String()
}
if enabled {
SpinnerText(levelMsg, "")
return
}
//if s.Active() {
// SpinnerText(levelMsg, "")
// return
// }
cmd := []interface{}{}
for _, f := range msg {
cmd = append(cmd, f)
}
m.Lock()
defer m.Unlock()
fmt.Println(levelMsg)
//fmt.Println(cmd...)
}

13
pkg/package/package_test.go
View File

@@ -81,15 +81,16 @@ var _ = Describe("Package", func() {
})
Context("Encoding", func() {
db := NewInMemoryDatabase(false)
a1 := NewPackage("A", "1.0", []*DefaultPackage{}, []*DefaultPackage{})
a11 := NewPackage("A", "1.1", []*DefaultPackage{}, []*DefaultPackage{})
a := NewPackage("A", ">=1.0", []*DefaultPackage{a1}, []*DefaultPackage{a11})
It("decodes and encodes correctly", func() {
ID, err := a.Encode()
ID, err := a.Encode(db)
Expect(err).ToNot(HaveOccurred())
p, err := DecodePackage(ID)
p, err := DecodePackage(ID, db)
Expect(err).ToNot(HaveOccurred())
Expect(p.GetVersion()).To(Equal(a.GetVersion()))
@@ -109,18 +110,22 @@ var _ = Describe("Package", func() {
Context("BuildFormula", func() {
It("builds empty constraints", func() {
db := NewInMemoryDatabase(false)
a1 := NewPackage("A", "1.0", []*DefaultPackage{}, []*DefaultPackage{})
f, err := a1.BuildFormula()
f, err := a1.BuildFormula(db)
Expect(err).ToNot(HaveOccurred())
Expect(f).To(BeNil())
})
It("builds constraints correctly", func() {
db := NewInMemoryDatabase(false)
a11 := NewPackage("A", "1.1", []*DefaultPackage{}, []*DefaultPackage{})
a21 := NewPackage("A", "1.2", []*DefaultPackage{}, []*DefaultPackage{})
a1 := NewPackage("A", "1.0", []*DefaultPackage{}, []*DefaultPackage{})
a1.Requires([]*DefaultPackage{a11})
a1.Conflicts([]*DefaultPackage{a21})
f, err := a1.BuildFormula()
f, err := a1.BuildFormula(db)
Expect(err).ToNot(HaveOccurred())
Expect(len(f)).To(Equal(2))
Expect(f[0].String()).To(Equal("or(not(c31f5842), a4910f77)"))

15
pkg/solver/decoder_test.go
View File

@@ -30,6 +30,8 @@ var _ = Describe("Decoder", func() {
eq := 0
for index := 0; index < 300; index++ { // Just to make sure we don't have false positives
It("Orders them correctly #"+strconv.Itoa(index), func() {
db := pkg.NewInMemoryDatabase(false)
C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
E := pkg.NewPackage("E", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
F := pkg.NewPackage("F", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
@@ -39,7 +41,7 @@ var _ = Describe("Decoder", func() {
B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{D}, []*pkg.DefaultPackage{})
A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{B}, []*pkg.DefaultPackage{})
s := NewSolver([]pkg.Package{C}, []pkg.Package{A, B, C, D, E, F, G})
s := NewSolver([]pkg.Package{C}, []pkg.Package{A, B, C, D, E, F, G}, db)
solution, err := s.Install([]pkg.Package{A})
Expect(solution).To(ContainElement(PackageAssert{Package: A.IsFlagged(true), Value: true}))
@@ -71,6 +73,8 @@ var _ = Describe("Decoder", func() {
equality := 0
for index := 0; index < 300; index++ { // Just to make sure we don't have false positives
It("Doesn't order them correctly otherwise #"+strconv.Itoa(index), func() {
db := pkg.NewInMemoryDatabase(false)
C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
E := pkg.NewPackage("E", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
F := pkg.NewPackage("F", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
@@ -80,7 +84,7 @@ var _ = Describe("Decoder", func() {
B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{D}, []*pkg.DefaultPackage{})
A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{B}, []*pkg.DefaultPackage{})
s := NewSolver([]pkg.Package{C}, []pkg.Package{A, B, C, D, E, F, G})
s := NewSolver([]pkg.Package{C}, []pkg.Package{A, B, C, D, E, F, G}, db)
solution, err := s.Install([]pkg.Package{A})
Expect(solution).To(ContainElement(PackageAssert{Package: A.IsFlagged(true), Value: true}))
@@ -128,6 +132,8 @@ var _ = Describe("Decoder", func() {
Context("Assertion hashing", func() {
It("Hashes them, and could be used for comparison", func() {
db := pkg.NewInMemoryDatabase(false)
C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
E := pkg.NewPackage("E", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
F := pkg.NewPackage("F", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
@@ -137,7 +143,7 @@ var _ = Describe("Decoder", func() {
B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{D}, []*pkg.DefaultPackage{})
A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{B}, []*pkg.DefaultPackage{})
s := NewSolver([]pkg.Package{C}, []pkg.Package{A, B, C, D, E, F, G})
s := NewSolver([]pkg.Package{C}, []pkg.Package{A, B, C, D, E, F, G}, db)
solution, err := s.Install([]pkg.Package{A})
Expect(solution).To(ContainElement(PackageAssert{Package: A.IsFlagged(true), Value: true}))
@@ -182,11 +188,12 @@ var _ = Describe("Decoder", func() {
Expect(hash).ToNot(Equal(""))
Expect(hash2).ToNot(Equal(""))
Expect(hash != hash2).To(BeTrue())
db2 := pkg.NewInMemoryDatabase(false)
X := pkg.NewPackage("X", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
Y := pkg.NewPackage("Y", "", []*pkg.DefaultPackage{X}, []*pkg.DefaultPackage{})
Z := pkg.NewPackage("Z", "", []*pkg.DefaultPackage{X}, []*pkg.DefaultPackage{})
s = NewSolver([]pkg.Package{}, []pkg.Package{X, Y, Z})
s = NewSolver([]pkg.Package{}, []pkg.Package{X, Y, Z}, db2)
solution, err = s.Install([]pkg.Package{Y})
Expect(err).ToNot(HaveOccurred())

75
pkg/solver/solver_test.go
View File

@@ -27,11 +27,13 @@ var _ = Describe("Solver", func() {
Context("Simple set", func() {
It("Solves correctly if the selected package has no requirements or conflicts and we have nothing installed yet", func() {
db := pkg.NewInMemoryDatabase(false)
B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
s := NewSolver([]pkg.Package{}, []pkg.Package{A, B, C})
s := NewSolver([]pkg.Package{}, []pkg.Package{A, B, C}, db)
solution, err := s.Install([]pkg.Package{A})
Expect(err).ToNot(HaveOccurred())
Expect(solution).To(ContainElement(PackageAssert{Package: A.IsFlagged(true), Value: true}))
@@ -39,11 +41,13 @@ var _ = Describe("Solver", func() {
})
It("Solves correctly if the selected package has no requirements or conflicts and we have installed one package", func() {
db := pkg.NewInMemoryDatabase(false)
B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
s := NewSolver([]pkg.Package{C}, []pkg.Package{A, B, C})
s := NewSolver([]pkg.Package{C}, []pkg.Package{A, B, C}, db)
solution, err := s.Install([]pkg.Package{B})
Expect(err).ToNot(HaveOccurred())
Expect(solution).To(ContainElement(PackageAssert{Package: B.IsFlagged(true), Value: true}))
@@ -52,13 +56,15 @@ var _ = Describe("Solver", func() {
})
It("Solves correctly if the selected package to install has no requirement or conflicts, but in the world there is one with a requirement", func() {
db := pkg.NewInMemoryDatabase(false)
B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
D := pkg.NewPackage("D", "", []*pkg.DefaultPackage{B}, []*pkg.DefaultPackage{})
E := pkg.NewPackage("E", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
s := NewSolver([]pkg.Package{E, C}, []pkg.Package{A, B, C, D, E})
s := NewSolver([]pkg.Package{E, C}, []pkg.Package{A, B, C, D, E}, db)
solution, err := s.Install([]pkg.Package{A})
Expect(err).ToNot(HaveOccurred())
Expect(solution).To(ContainElement(PackageAssert{Package: A.IsFlagged(true), Value: true}))
@@ -71,12 +77,14 @@ var _ = Describe("Solver", func() {
})
It("Solves correctly if the selected package to install has requirements", func() {
db := pkg.NewInMemoryDatabase(false)
B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
D := pkg.NewPackage("D", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{D}, []*pkg.DefaultPackage{})
s := NewSolver([]pkg.Package{C}, []pkg.Package{A, B, C, D})
s := NewSolver([]pkg.Package{C}, []pkg.Package{A, B, C, D}, db)
solution, err := s.Install([]pkg.Package{A})
Expect(err).ToNot(HaveOccurred())
Expect(solution).To(ContainElement(PackageAssert{Package: A.IsFlagged(true), Value: true}))
@@ -87,11 +95,13 @@ var _ = Describe("Solver", func() {
})
It("Solves correctly", func() {
db := pkg.NewInMemoryDatabase(false)
B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{B}, []*pkg.DefaultPackage{})
C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
s := NewSolver([]pkg.Package{C}, []pkg.Package{A, B, C})
s := NewSolver([]pkg.Package{C}, []pkg.Package{A, B, C}, db)
solution, err := s.Install([]pkg.Package{A})
Expect(err).ToNot(HaveOccurred())
Expect(solution).To(ContainElement(PackageAssert{Package: A.IsFlagged(true), Value: true}))
@@ -100,12 +110,14 @@ var _ = Describe("Solver", func() {
Expect(len(solution)).To(Equal(3))
})
It("Solves correctly more complex ones", func() {
db := pkg.NewInMemoryDatabase(false)
C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
D := pkg.NewPackage("D", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{D}, []*pkg.DefaultPackage{})
A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{B}, []*pkg.DefaultPackage{})
s := NewSolver([]pkg.Package{C}, []pkg.Package{A, B, C, D})
s := NewSolver([]pkg.Package{C}, []pkg.Package{A, B, C, D}, db)
solution, err := s.Install([]pkg.Package{A})
Expect(solution).To(ContainElement(PackageAssert{Package: A.IsFlagged(true), Value: true}))
@@ -117,13 +129,15 @@ var _ = Describe("Solver", func() {
})
It("Solves correctly more complex ones", func() {
db := pkg.NewInMemoryDatabase(false)
E := pkg.NewPackage("E", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
D := pkg.NewPackage("D", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{D}, []*pkg.DefaultPackage{})
A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{B}, []*pkg.DefaultPackage{})
s := NewSolver([]pkg.Package{}, []pkg.Package{A, B, C, D, E})
s := NewSolver([]pkg.Package{}, []pkg.Package{A, B, C, D, E}, db)
solution, err := s.Install([]pkg.Package{A})
Expect(solution).To(ContainElement(PackageAssert{Package: A.IsFlagged(true), Value: true}))
@@ -134,12 +148,14 @@ var _ = Describe("Solver", func() {
})
It("Uninstalls simple package correctly", func() {
db := pkg.NewInMemoryDatabase(false)
C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
D := pkg.NewPackage("D", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
s := NewSolver([]pkg.Package{A, B, C, D}, []pkg.Package{A, B, C, D})
s := NewSolver([]pkg.Package{A, B, C, D}, []pkg.Package{A, B, C, D}, db)
solution, err := s.Uninstall(A)
Expect(err).ToNot(HaveOccurred())
@@ -151,6 +167,7 @@ var _ = Describe("Solver", func() {
})
It("Find conflicts", func() {
db := pkg.NewInMemoryDatabase(false)
C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
D := pkg.NewPackage("D", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
@@ -158,7 +175,7 @@ var _ = Describe("Solver", func() {
B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{A}, []*pkg.DefaultPackage{})
s := NewSolver([]pkg.Package{A, B, C, D}, []pkg.Package{A, B, C, D})
s := NewSolver([]pkg.Package{A, B, C, D}, []pkg.Package{A, B, C, D}, db)
val, err := s.ConflictsWithInstalled(A)
Expect(err).ToNot(HaveOccurred())
Expect(val).To(BeTrue())
@@ -166,50 +183,58 @@ var _ = Describe("Solver", func() {
})
It("Find nested conflicts", func() {
db := pkg.NewInMemoryDatabase(false)
C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
D := pkg.NewPackage("D", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{D}, []*pkg.DefaultPackage{})
B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{A}, []*pkg.DefaultPackage{})
s := NewSolver([]pkg.Package{A, B, C, D}, []pkg.Package{A, B, C, D})
s := NewSolver([]pkg.Package{A, B, C, D}, []pkg.Package{A, B, C, D}, db)
val, err := s.ConflictsWithInstalled(D)
Expect(err).ToNot(HaveOccurred())
Expect(val).To(BeTrue())
})
It("Doesn't find nested conflicts", func() {
db := pkg.NewInMemoryDatabase(false)
C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
D := pkg.NewPackage("D", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{D}, []*pkg.DefaultPackage{})
B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{A}, []*pkg.DefaultPackage{})
s := NewSolver([]pkg.Package{A, B, C, D}, []pkg.Package{A, B, C, D})
s := NewSolver([]pkg.Package{A, B, C, D}, []pkg.Package{A, B, C, D}, db)
val, err := s.ConflictsWithInstalled(C)
Expect(err).ToNot(HaveOccurred())
Expect(val).ToNot(BeTrue())
})
It("Doesn't find conflicts", func() {
db := pkg.NewInMemoryDatabase(false)
C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
D := pkg.NewPackage("D", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
s := NewSolver([]pkg.Package{A, B, C, D}, []pkg.Package{A, B, C, D})
s := NewSolver([]pkg.Package{A, B, C, D}, []pkg.Package{A, B, C, D}, db)
val, err := s.ConflictsWithInstalled(C)
Expect(err).ToNot(HaveOccurred())
Expect(val).ToNot(BeTrue())
})
It("Uninstalls simple packages not in world correctly", func() {
db := pkg.NewInMemoryDatabase(false)
C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
D := pkg.NewPackage("D", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
s := NewSolver([]pkg.Package{A, B, C, D}, []pkg.Package{B, C, D})
s := NewSolver([]pkg.Package{A, B, C, D}, []pkg.Package{B, C, D}, db)
solution, err := s.Uninstall(A)
Expect(err).ToNot(HaveOccurred())
@@ -221,12 +246,14 @@ var _ = Describe("Solver", func() {
})
It("Uninstalls complex packages not in world correctly", func() {
db := pkg.NewInMemoryDatabase(false)
C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
D := pkg.NewPackage("D", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{B}, []*pkg.DefaultPackage{})
s := NewSolver([]pkg.Package{A, B, C, D}, []pkg.Package{B, C, D})
s := NewSolver([]pkg.Package{A, B, C, D}, []pkg.Package{B, C, D}, db)
solution, err := s.Uninstall(A)
Expect(err).ToNot(HaveOccurred())
@@ -237,12 +264,14 @@ var _ = Describe("Solver", func() {
})
It("Uninstalls complex packages correctly, even if shared deps are required by system packages", func() {
db := pkg.NewInMemoryDatabase(false)
D := pkg.NewPackage("D", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{B}, []*pkg.DefaultPackage{})
C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{B}, []*pkg.DefaultPackage{})
s := NewSolver([]pkg.Package{A, B, C, D}, []pkg.Package{A, B, C, D})
s := NewSolver([]pkg.Package{A, B, C, D}, []pkg.Package{A, B, C, D}, db)
solution, err := s.Uninstall(A)
Expect(err).ToNot(HaveOccurred())
@@ -254,12 +283,14 @@ var _ = Describe("Solver", func() {
})
It("Uninstalls complex packages in world correctly", func() {
db := pkg.NewInMemoryDatabase(false)
C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
D := pkg.NewPackage("D", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{C}, []*pkg.DefaultPackage{})
s := NewSolver([]pkg.Package{A, C, D}, []pkg.Package{A, B, C, D})
s := NewSolver([]pkg.Package{A, C, D}, []pkg.Package{A, B, C, D}, db)
solution, err := s.Uninstall(A)
Expect(err).ToNot(HaveOccurred())
@@ -271,13 +302,15 @@ var _ = Describe("Solver", func() {
})
It("Uninstalls complex package correctly", func() {
db := pkg.NewInMemoryDatabase(false)
C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
D := pkg.NewPackage("D", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{D}, []*pkg.DefaultPackage{})
A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{B}, []*pkg.DefaultPackage{})
C.IsFlagged(true) // installed
s := NewSolver([]pkg.Package{A, B, C, D}, []pkg.Package{A, B, C, D})
s := NewSolver([]pkg.Package{A, B, C, D}, []pkg.Package{A, B, C, D}, db)
solution, err := s.Uninstall(A)
Expect(solution).To(ContainElement(A.IsFlagged(false)))
@@ -294,12 +327,14 @@ var _ = Describe("Solver", func() {
Context("Conflict set", func() {
It("is unsolvable - as we something we ask to install conflict with system stuff", func() {
db := pkg.NewInMemoryDatabase(false)
C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
// D := pkg.NewPackage("D", "", []pkg.Package{}, []pkg.Package{})
B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{C})
A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{B}, []*pkg.DefaultPackage{})
s := NewSolver([]pkg.Package{C}, []pkg.Package{A, B, C})
s := NewSolver([]pkg.Package{C}, []pkg.Package{A, B, C}, db)
solution, err := s.Install([]pkg.Package{A})
Expect(len(solution)).To(Equal(0))
@@ -310,6 +345,8 @@ var _ = Describe("Solver", func() {
Context("Complex data sets", func() {
It("Solves them correctly", func() {
db := pkg.NewInMemoryDatabase(false)
C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
E := pkg.NewPackage("E", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
F := pkg.NewPackage("F", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
@@ -319,7 +356,7 @@ var _ = Describe("Solver", func() {
B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{D}, []*pkg.DefaultPackage{})
A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{B}, []*pkg.DefaultPackage{})
s := NewSolver([]pkg.Package{C}, []pkg.Package{A, B, C, D, E, F, G})
s := NewSolver([]pkg.Package{C}, []pkg.Package{A, B, C, D, E, F, G}, db)
solution, err := s.Install([]pkg.Package{A})
Expect(solution).To(ContainElement(PackageAssert{Package: A.IsFlagged(true), Value: true}))

9
pkg/tree/recipes_test.go
View File

@@ -53,7 +53,7 @@ var _ = Describe("Recipe", func() {
Expect(len(tree.GetPackageSet().GetPackages())).To(Equal(10))
generalRecipe := NewGeneralRecipe()
generalRecipe := NewGeneralRecipe(tree.GetPackageSet())
generalRecipe.WithTree(tree)
err = generalRecipe.Save(tmpdir)
Expect(err).ToNot(HaveOccurred())
@@ -61,7 +61,7 @@ var _ = Describe("Recipe", func() {
})
Context("Reloading trees", func() {
It("writes and reads back the same tree", func() {
FIt("writes and reads back the same tree", func() {
tmpdir, err := ioutil.TempDir("", "tree")
Expect(err).ToNot(HaveOccurred())
defer os.RemoveAll(tmpdir) // clean up
@@ -75,11 +75,14 @@ var _ = Describe("Recipe", func() {
Expect(len(tree.GetPackageSet().GetPackages())).To(Equal(10))
generalRecipe := NewGeneralRecipe()
generalRecipe := NewGeneralRecipe(tree.GetPackageSet())
generalRecipe.WithTree(tree)
err = generalRecipe.Save(tmpdir)
Expect(err).ToNot(HaveOccurred())
db := pkg.NewInMemoryDatabase(false)
generalRecipe = NewGeneralRecipe(db)
generalRecipe.WithTree(nil)
Expect(generalRecipe.Tree()).To(BeNil())

6
pkg/tree/tree_test.go
View File

@@ -37,8 +37,8 @@ var _ = Describe("Tree", func() {
Context("Simple solving with the fixture tree", func() {
It("writes and reads back the same tree", func() {
for index := 0; index < 300; index++ { // Just to make sure we don't have false positives
generalRecipe := NewCompilerRecipe()
db := pkg.NewInMemoryDatabase(false)
generalRecipe := NewCompilerRecipe(db)
tmpdir, err := ioutil.TempDir("", "package")
Expect(err).ToNot(HaveOccurred())
defer os.RemoveAll(tmpdir) // clean up
@@ -62,7 +62,7 @@ var _ = Describe("Tree", func() {
w, err := generalRecipe.Tree().World()
Expect(err).ToNot(HaveOccurred())
s := solver.NewSolver([]pkg.Package{}, w)
s := solver.NewSolver([]pkg.Package{}, w, db)
pack, err := generalRecipe.Tree().FindPackage(&pkg.DefaultPackage{Name: "d", Category: "test", Version: "1.0"})
Expect(err).ToNot(HaveOccurred())