github.com/benoitkugler/goacve@v0.0.0-20201217100549-151ce6e55dc8/server/core/datamodel/base_hash_test.go

package datamodel

import (
	"bytes"
	"fmt"
	"log"
	"reflect"
	"testing"
	"time"

	"github.com/benoitkugler/goACVE/logs"
	rd "github.com/benoitkugler/goACVE/server/core/rawdata"
)

func TestHash(t *testing.T) {
	base := GetBase(true)
	ti := time.Now()
	h, err := base.Hash()
	if err != nil {
		t.Fatal(err)
	}
	fmt.Println("hashed in:", time.Since(ti))

	h2, err := base.Hash()
	if err != nil {
		t.Fatal(err)
	}
	if !reflect.DeepEqual(h, h2) {
		t.Error("hash non reproductible")
	}

	ti = time.Now()
	headerJSON, b, err := h.Compress()
	if err != nil {
		t.Fatal(err)
	}
	fmt.Println("compressé en:", time.Since(ti))
	fmt.Println("compact binary + gzip:", len(b))
	fmt.Println("header:", len(headerJSON))

	var out bytes.Buffer
	err = base.MarshalCompress(&out)
	if err != nil {
		t.Fatal(err)
	}
	fmt.Println("base entière compressée:", len(out.Bytes()))

	h3, err := NewBaseHash(headerJSON, b)
	if err != nil {
		t.Fatal(err)
	}
	if !reflect.DeepEqual(h, h3) {
		t.Error("cycle compression/décompression invalide")
		for n, m := range h {
			if !reflect.DeepEqual(m, h3[n]) {
				t.Errorf("différence pour la table %s %d %d", n, len(m), len(h3[n]))
			}
		}
	}
}

func TestCompareHash(t *testing.T) {
	base := GetBase(true)
	h, err := base.Hash()
	if err != nil {
		t.Fatal(err)
	}

	selfDiff := h.Compare(h)
	if m, d := selfDiff.Total(); m+d > 0 {
		t.Errorf("expected no differences, got %v", selfDiff)
	}

	totalDiff1 := h.Compare(nil)
	_, deleted := totalDiff1.Total()
	totalDiff2 := BaseHash{}.Compare(h)
	modified, _ := totalDiff2.Total()
	if deleted != modified {
		t.Errorf("expected same output, got %d and %d", deleted, modified)
	}

	// mutate and check the diff
	p := base.Personnes[base.Personnes.Ids()[0]]
	p.Adresse = "46446"
	p.EchoRocher = true
	base.Personnes[p.Id] = p

	a := base.Aides[base.Aides.Ids()[0]]
	a.NbJoursMax = 4
	base.Aides[a.Id] = a

	idDon := base.Dons.Ids()[0]
	delete(base.Dons, idDon)

	ti := time.Now()
	newHash, err := base.Hash()
	if err != nil {
		t.Fatal(err)
	}
	diffs := h.Compare(newHash)
	fmt.Println("hash + compare done in:", time.Since(ti))

	if !reflect.DeepEqual(diffs.Modified["Personnes"], []int64{p.Id}) {
		t.Error("got ", diffs.Modified["Personnes"])
	}
	if !reflect.DeepEqual(diffs.Modified["Aides"], []int64{a.Id}) {
		t.Error("got ", diffs.Modified["Aides"])
	}
	if !reflect.DeepEqual(diffs.Deleted["Dons"], []int64{idDon}) {
		t.Error("got ", diffs.Modified["Dons"])
	}

	if m, d := diffs.Total(); m != 2 && d != 1 {
		t.Errorf("unexpected number of differences: %v %v", m, d)
	}
}

func TestLoadPartiel(t *testing.T) {
	logsDB := logs.DBDev
	db, err := rd.ConnectDB(logsDB)
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()
	base, err := LoadRemoteBaseLocale(db)
	if err != nil {
		t.Fatal(err)
	}

	h, err := base.Hash()
	if err != nil {
		t.Fatal(err)
	}

	all := BaseHash{}.Compare(h)
	newB, err := LoadRemoteBaseLocalePartiel(db, all.Modified)
	if err != nil {
		t.Fatal(err)
	}

	newHash, err := newB.Hash()
	if err != nil {
		t.Fatal(err)
	}
	if m, d := newHash.Compare(h).Total(); m+d != 0 {
		t.Error("expected no difference")
	}
	total, _ := all.Total()

	for name, ids := range all.Modified {
		newB, err := LoadRemoteBaseLocalePartiel(db, map[string][]int64{name: ids})
		if err != nil {
			t.Fatal(err)
		}

		newHash, err := newB.Hash()
		if err != nil {
			t.Fatal(err)
		}
		// h has modified all the entries, except ids
		if m, _ := newHash.Compare(h).Total(); m != total-len(ids) {
			t.Errorf("table %s: expected %d differences, got %d", name, total-len(ids), m)
		}
		// newHash has deleted all the entries, except ids
		if _, d := h.Compare(newHash).Total(); d != total-len(ids) {
			t.Errorf("table %s: expected %d differences, got %d", name, total-len(ids), d)
		}
	}
}

func TestPatchDB(t *testing.T) {
	logsDB := logs.DBDev
	db, err := rd.ConnectDB(logsDB)
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()
	base, err := LoadRemoteBaseLocale(db)
	if err != nil {
		t.Fatal(err)
	}

	serverHash, err := base.Hash()
	if err != nil {
		t.Fatal(err)
	}

	p := base.Personnes[base.Personnes.Ids()[0]]
	p.Nom = "dmsqd"
	base.Personnes[p.Id] = p

	e := base.Equipiers[base.Equipiers.Ids()[0]]
	e.Diplome = rd.DAssSociale
	base.Equipiers[e.Id] = e

	clientHash, err := base.Hash()
	if err != nil {
		t.Fatal(err)
	}

	diffs := clientHash.Compare(serverHash)

	newDB, err := LoadRemoteBaseLocalePartiel(db, diffs.Modified)
	if err != nil {
		t.Fatal(err)
	}
	if len(newDB.Personnes) != 1 {
		t.Error("expected only one personne")
	}
	if len(newDB.Equipiers) != 1 {
		t.Error("expected only one equipier")
	}

	base.MergeFrom(*newDB, diffs.Deleted)
	d, err := base.Hash()
	if mo, de := d.Compare(serverHash).Total(); mo+de != 0 {
		t.Error("expect no differences")
	}
}