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

Create a type for lists of PackageAssertion, and move Order() inside it

Browse Source
This commit is contained in:
Ettore Di Giacinto
2019-11-11 11:02:32 +01:00
parent ebd4cfc318
commit 2dd56e9e49
4 changed files with 183 additions and 154 deletions
Download Patch File Download Diff File Expand all files Collapse all files

104
pkg/solver/solver_test.go
View File

@@ -16,8 +16,6 @@
package solver_test
import (
"strconv"
pkg "github.com/mudler/luet/pkg/package"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
@@ -335,107 +333,5 @@ var _ = Describe("Solver", func() {
Expect(err).ToNot(HaveOccurred())
})
})
Context("Assertion ordering", 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() {
C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
E := pkg.NewPackage("E", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
F := pkg.NewPackage("F", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
G := pkg.NewPackage("G", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
H := pkg.NewPackage("H", "", []*pkg.DefaultPackage{G}, []*pkg.DefaultPackage{})
D := pkg.NewPackage("D", "", []*pkg.DefaultPackage{H}, []*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, E, F, G})
solution, err := s.Install([]pkg.Package{A})
Expect(solution).To(ContainElement(PackageAssert{Package: A.IsFlagged(true), Value: true}))
Expect(solution).To(ContainElement(PackageAssert{Package: B.IsFlagged(true), Value: true}))
Expect(solution).To(ContainElement(PackageAssert{Package: D.IsFlagged(true), Value: true}))
Expect(solution).To(ContainElement(PackageAssert{Package: C.IsFlagged(true), Value: true}))
Expect(solution).To(ContainElement(PackageAssert{Package: H.IsFlagged(true), Value: true}))
Expect(solution).To(ContainElement(PackageAssert{Package: G.IsFlagged(true), Value: true}))
Expect(len(solution)).To(Equal(6))
Expect(err).ToNot(HaveOccurred())
solution = s.Order(solution)
Expect(len(solution)).To(Equal(6))
Expect(solution[0].Package.GetName()).To(Equal("G"))
Expect(solution[1].Package.GetName()).To(Equal("H"))
Expect(solution[2].Package.GetName()).To(Equal("D"))
Expect(solution[3].Package.GetName()).To(Equal("B"))
eq += len(solution)
//Expect(solution[4].Package.GetName()).To(Equal("A"))
//Expect(solution[5].Package.GetName()).To(Equal("C")) As C doesn't have any dep it can be in both positions
})
}
It("Expects perfect equality when ordered", func() {
Expect(eq).To(Equal(300 * 6)) // assertions lenghts
})
disequality := 0
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() {
C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
E := pkg.NewPackage("E", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
F := pkg.NewPackage("F", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
G := pkg.NewPackage("G", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
H := pkg.NewPackage("H", "", []*pkg.DefaultPackage{G}, []*pkg.DefaultPackage{})
D := pkg.NewPackage("D", "", []*pkg.DefaultPackage{H}, []*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, E, F, G})
solution, err := s.Install([]pkg.Package{A})
Expect(solution).To(ContainElement(PackageAssert{Package: A.IsFlagged(true), Value: true}))
Expect(solution).To(ContainElement(PackageAssert{Package: B.IsFlagged(true), Value: true}))
Expect(solution).To(ContainElement(PackageAssert{Package: D.IsFlagged(true), Value: true}))
Expect(solution).To(ContainElement(PackageAssert{Package: C.IsFlagged(true), Value: true}))
Expect(solution).To(ContainElement(PackageAssert{Package: H.IsFlagged(true), Value: true}))
Expect(solution).To(ContainElement(PackageAssert{Package: G.IsFlagged(true), Value: true}))
Expect(len(solution)).To(Equal(6))
Expect(err).ToNot(HaveOccurred())
if solution[0].Package.GetName() != "G" {
disequality++
} else {
equality++
}
if solution[1].Package.GetName() != "H" {
disequality++
} else {
equality++
}
if solution[2].Package.GetName() != "D" {
disequality++
} else {
equality++
}
if solution[3].Package.GetName() != "B" {
disequality++
} else {
equality++
}
if solution[4].Package.GetName() != "A" {
disequality++
} else {
equality++
}
if solution[5].Package.GetName() != "C" {
disequality++
} else {
equality++
}
})
It("Expect disequality", func() {
Expect(disequality).ToNot(Equal(0))
Expect(equality).ToNot(Equal(300 * 6))
})
}
})
})