Use well defined structure for serializing, fixups to make test green

pkg/installer/repository.go

@@ -43,6 +43,14 @@ type LuetRepository struct {
 	Type     string                 `json:"type"`
 }
 
+type LuetRepositorySerialized struct {
+	Name     string                      `json:"name"`
+	Uri      string                      `json:"uri"`
+	Priority int                         `json:"priority"`
+	Index    []*compiler.PackageArtifact `json:"index"`
+	Type     string                      `json:"type"`
+}
+
 func GenerateRepository(name, uri, t string, priority int, src, treeDir string, db pkg.PackageDatabase) (Repository, error) {
 
 	art, err := buildPackageIndex(src)
@@ -62,13 +70,25 @@ func NewLuetRepository(name, uri, t string, priority int, art []compiler.Artifac
 	return &LuetRepository{Index: art, Type: t, Tree: builder, Name: name, Uri: uri, Priority: priority}
 }
 
-func NewLuetRepositoryFromYaml(data []byte) (Repository, error) {
-	var p LuetRepository
+func NewLuetRepositoryFromYaml(data []byte, db pkg.PackageDatabase) (Repository, error) {
+	var p *LuetRepositorySerialized
+	r := &LuetRepository{}
 	err := yaml.Unmarshal(data, &p)
 	if err != nil {
-		return &p, err
+		return nil, err
 	}
-	return &p, err
+	r.Name = p.Name
+	r.Uri = p.Uri
+	r.Priority = p.Priority
+	r.Type = p.Type
+	i := compiler.ArtifactIndex{}
+	for _, ii := range p.Index {
+		i = append(i, ii)
+	}
+	r.Index = i
+	r.Tree = tree.NewInstallerRecipe(db)
+
+	return r, err
 }
 
 func buildPackageIndex(path string) ([]compiler.Artifact, error) {
@@ -114,6 +134,10 @@ func (r *LuetRepository) SetTreePath(p string) {
 	r.TreePath = p
 }
 
+func (r *LuetRepository) SetTree(b tree.Builder) {
+	r.Tree = b
+}
+
 func (r *LuetRepository) GetType() string {
 	return r.Type
 }
@@ -141,6 +165,7 @@ func (r *LuetRepository) Write(dst string) error {
 	if err != nil {
 		return err
 	}
+	r.Index = r.Index.CleanPath()
 	err = ioutil.WriteFile(filepath.Join(dst, "repository.yaml"), data, os.ModePerm)
 	if err != nil {
 		return err
@@ -171,7 +196,9 @@ func (r *LuetRepository) Client() Client {
 }
 func (r *LuetRepository) Sync() (Repository, error) {
 	c := r.Client()
-
+	if c == nil {
+		return nil, errors.New("No client could be generated from repository.")
+	}
 	file, err := c.DownloadFile("repository.yaml")
 	if err != nil {
 		return nil, errors.Wrap(err, "While downloading repository.yaml from "+r.GetUri())
@@ -182,7 +209,8 @@ func (r *LuetRepository) Sync() (Repository, error) {
 	}
 	defer os.Remove(file)
 
-	repo, err := NewLuetRepositoryFromYaml(dat)
+	// TODO: make it swappable
+	repo, err := NewLuetRepositoryFromYaml(dat, pkg.NewInMemoryDatabase(false))
 	if err != nil {
 		return nil, errors.Wrap(err, "Error reading repository from file "+file)
 
@@ -212,11 +240,12 @@ func (r *LuetRepository) Sync() (Repository, error) {
 		return nil, errors.Wrap(err, "Error met while unpacking rootfs")
 	}
 
-	reciper := tree.NewInstallerRecipe(r.GetTree().Tree().GetPackageSet())
+	reciper := tree.NewInstallerRecipe(pkg.NewInMemoryDatabase(false))
 	err = reciper.Load(treefs)
 	if err != nil {
 		return nil, errors.Wrap(err, "Error met while unpacking rootfs")
 	}
+	repo.SetTree(reciper)
 	repo.SetTreePath(treefs)
 
 	return repo, nil