Adapt tests and fixup races in spinner

Signed-off-by: Ettore Di Giacinto <mudler@gentoo.org>

pkg/compiler/compiler_test.go

@@ -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())

pkg/logger/logger.go

@@ -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 s *spinner.Spinner = spinner.New(spinner.CharSets[22], 100*time.Millisecond)
-var m = &sync.Mutex{}
-var enabled = false
 
 func Spinner(i int) {
-	m.Lock()
+
-	defer m.Unlock()
 	if i > 43 {
 		i = 43
 	}
 
-	if s == nil {
+	if !s.Active() {
-		s = spinner.New(spinner.CharSets[i], 100*time.Millisecond) // Build our new spinner
+		//	s.UpdateCharSet(spinner.CharSets[i])
-	}
-	s.UpdateCharSet(spinner.CharSets[i])
-	enabled = true
 		s.Start() // Start the spinner
+	}
 }
 
 func SpinnerText(suffix, prefix string) {
-	m.Lock()
+	s.Lock()
-	defer m.Unlock()
+	defer s.Unlock()
-	if s == nil {
-		s = spinner.New(spinner.CharSets[22], 100*time.Millisecond) // Build our new spinner
-	}
 	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
 }
 
 func msg(level string, msg ...interface{}) {
@@ -67,17 +54,16 @@ func msg(level string, msg ...interface{}) {
 		levelMsg = Bold(Red("💣 " + message + "🔥")).BgBlack().String()
 	}
 
-	if enabled {
+	//if s.Active() {
-		SpinnerText(levelMsg, "")
+	//		SpinnerText(levelMsg, "")
-		return
+	//	return
-	}
+	//	}
 
 	cmd := []interface{}{}
 	for _, f := range msg {
 		cmd = append(cmd, f)
 	}
-	m.Lock()
+
-	defer m.Unlock()
 	fmt.Println(levelMsg)
 	//fmt.Println(cmd...)
 }

pkg/package/package_test.go

@@ -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)"))

pkg/solver/decoder_test.go

@@ -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())
 

pkg/solver/solver_test.go

@@ -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}))

pkg/tree/recipes_test.go

@@ -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())
 

pkg/tree/tree_test.go

@@ -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
-
+				db := pkg.NewInMemoryDatabase(false)
-				generalRecipe := NewCompilerRecipe()
+				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())