mirror of
https://github.com/mudler/luet.git
synced 2025-06-23 22:17:59 +00:00
632619fe91
Uninstall can be done in different ways - the most accurate would be to try find a minimum subset of packages that gives conflicts and try to reduce them gradually. E.g. this could be done with other SAT algorithms. For now we keep things simple and we compute the uninstalls as an indirect of an installation from an empty profile. Also take care of corner cases where world has no clauses, and fixes a typo in building the world formula
194 lines
9.2 KiB
Go
194 lines
9.2 KiB
Go
// Copyright © 2019 Ettore Di Giacinto <mudler@gentoo.org>
|
|
//
|
|
// This program is free software; you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation; either version 2 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License along
|
|
// with this program; if not, see <http://www.gnu.org/licenses/>.
|
|
|
|
package solver_test
|
|
|
|
import (
|
|
. "github.com/onsi/ginkgo"
|
|
. "github.com/onsi/gomega"
|
|
pkg "gitlab.com/mudler/luet/pkg/package"
|
|
|
|
. "gitlab.com/mudler/luet/pkg/solver"
|
|
)
|
|
|
|
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() {
|
|
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})
|
|
solution, err := s.Install([]pkg.Package{A})
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(solution).To(ContainElement(PackageAssert{Package: A.IsFlagged(true), Value: true}))
|
|
Expect(len(solution)).To(Equal(1))
|
|
})
|
|
|
|
It("Solves correctly if the selected package has no requirements or conflicts and we have installed one package", func() {
|
|
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})
|
|
solution, err := s.Install([]pkg.Package{B})
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(solution).To(ContainElement(PackageAssert{Package: B.IsFlagged(true), Value: true}))
|
|
Expect(solution).To(ContainElement(PackageAssert{Package: C.IsFlagged(true), Value: true}))
|
|
Expect(len(solution)).To(Equal(2))
|
|
})
|
|
|
|
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() {
|
|
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})
|
|
solution, err := s.Install([]pkg.Package{A})
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(solution).To(ContainElement(PackageAssert{Package: A.IsFlagged(true), Value: true}))
|
|
Expect(solution).To(ContainElement(PackageAssert{Package: C.IsFlagged(true), Value: true}))
|
|
Expect(solution).To(ContainElement(PackageAssert{Package: E.IsFlagged(true), Value: true}))
|
|
Expect(solution).To(ContainElement(PackageAssert{Package: B.IsFlagged(true), Value: false}))
|
|
Expect(solution).To(ContainElement(PackageAssert{Package: D.IsFlagged(true), Value: false}))
|
|
|
|
Expect(len(solution)).To(Equal(5))
|
|
})
|
|
|
|
It("Solves correctly if the selected package to install has requirements", func() {
|
|
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})
|
|
solution, err := s.Install([]pkg.Package{A})
|
|
Expect(err).ToNot(HaveOccurred())
|
|
Expect(solution).To(ContainElement(PackageAssert{Package: A.IsFlagged(true), Value: true}))
|
|
Expect(solution).To(ContainElement(PackageAssert{Package: C.IsFlagged(true), Value: true}))
|
|
Expect(solution).To(ContainElement(PackageAssert{Package: D.IsFlagged(true), Value: true}))
|
|
|
|
Expect(len(solution)).To(Equal(3))
|
|
})
|
|
|
|
It("Solves correctly", func() {
|
|
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})
|
|
solution, err := s.Install([]pkg.Package{A})
|
|
Expect(err).ToNot(HaveOccurred())
|
|
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: C.IsFlagged(true), Value: true}))
|
|
Expect(len(solution)).To(Equal(3))
|
|
})
|
|
It("Solves correctly more complex ones", func() {
|
|
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})
|
|
|
|
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(len(solution)).To(Equal(4))
|
|
Expect(err).ToNot(HaveOccurred())
|
|
})
|
|
|
|
It("Solves correctly more complex ones", func() {
|
|
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})
|
|
|
|
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(len(solution)).To(Equal(3))
|
|
Expect(err).ToNot(HaveOccurred())
|
|
})
|
|
|
|
It("Uninstalls simple package correctly", func() {
|
|
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})
|
|
|
|
solution, err := s.Uninstall(A)
|
|
Expect(err).ToNot(HaveOccurred())
|
|
|
|
Expect(solution).To(ContainElement(A.IsFlagged(false)))
|
|
|
|
// Expect(solution).To(ContainElement(PackageAssert{Package: C.IsFlagged(true), Value: true}))
|
|
Expect(len(solution)).To(Equal(1))
|
|
})
|
|
|
|
It("Uninstalls complex package correctly", func() {
|
|
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})
|
|
|
|
solution, err := s.Uninstall(A)
|
|
Expect(solution).To(ContainElement(A.IsFlagged(false)))
|
|
Expect(solution).To(ContainElement(B.IsFlagged(false)))
|
|
//Expect(solution).To(ContainElement(C.IsFlagged(true)))
|
|
Expect(solution).To(ContainElement(D.IsFlagged(false)))
|
|
|
|
// Expect(solution).To(ContainElement(PackageAssert{Package: C.IsFlagged(true), Value: true}))
|
|
Expect(len(solution)).To(Equal(3))
|
|
Expect(err).ToNot(HaveOccurred())
|
|
|
|
})
|
|
|
|
})
|
|
|
|
Context("Conflict set", func() {
|
|
|
|
It("is unsolvable - as we something we ask to install conflict with system stuff", func() {
|
|
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})
|
|
|
|
solution, err := s.Install([]pkg.Package{A})
|
|
Expect(len(solution)).To(Equal(0))
|
|
Expect(err).To(HaveOccurred())
|
|
})
|
|
|
|
})
|
|
|
|
})
|