core/cron/sync/test/sync_test.go

package sync_test

import (
	"log"
	"testing"
	"time"

	"github.com/remogatto/prettytest"
	karmen_client "gogs.carducci-dante.gov.it/karmen/client"
	"gogs.carducci-dante.gov.it/karmen/core/config"
	"gogs.carducci-dante.gov.it/karmen/core/cron/sync"
	"gogs.carducci-dante.gov.it/karmen/core/orm"
	karmen_ldap "gogs.carducci-dante.gov.it/karmen/ldap"
)

type testSuite struct {
	prettytest.Suite
}

var (
	ldap   *karmen_ldap.Client
	karmen *karmen_client.Client
	conf   *config.ConfigT
)

func TestRunner(t *testing.T) {
	prettytest.Run(
		t,
		new(testSuite),
	)
}

func (t *testSuite) BeforeAll() {
	var err error

	time.Sleep(time.Second * 10) // Wait for the server to go up...

	conf = new(config.ConfigT)

	err = config.ReadFile("config.yaml", conf)
	if err != nil {
		panic(err)
	}

	ldap, err = karmen_ldap.NewClient("localhost:389", conf)
	if err != nil {
		panic(err)
	}

	karmen, err = karmen_client.Dial(conf.Url, conf.Admin.Username, conf.Admin.Password)
	if err != nil {
		log.Println(err)
	}

}

func (t *testSuite) AfterAll() {
	ldap.Close()
}

func (t *testSuite) TestSyncUsers() {
	syncJob := sync.NewSyncJob(conf)

	teachers, err := karmen.GetTeachers()
	t.Nil(err)

	entries, err := ldap.Users("ou=Teachers,ou=People,dc=foo,dc=org")
	t.Nil(err)

	users := make([]orm.User, 0)
	for _, teacher := range teachers {
		users = append(users, teacher)
	}

	result, err := syncJob.SyncUsers(ldap, karmen, entries, users)
	t.Nil(err)

	if !t.Failed() {
		t.Equal(len(result.Added), 11)
		t.Equal(len(result.Updated), 0)
		t.Equal(len(result.Removed), 1)

		t.Equal(result.Removed[0], "cn=John DOE,ou=Teachers,ou=People,dc=foo,dc=org")
	}

	// Run sync two times should result in no updating

	teachers, err = karmen.GetTeachers()
	t.Nil(err)

	entries, err = ldap.Users("ou=Teachers,ou=People,dc=foo,dc=org")
	t.Nil(err)

	users = make([]orm.User, 0)
	for _, teacher := range teachers {
		users = append(users, teacher)
	}

	result, err = syncJob.SyncUsers(ldap, karmen, entries, users)
	t.Nil(err)

	if !t.Failed() {
		t.Equal(len(result.Added), 0)
		t.Equal(len(result.Updated), 0)
		t.Equal(len(result.Removed), 0)
	}

	// Update user and test LDAP sync

	user := teachers[0]

	user.SetRegenerate(true)

	err = karmen.UpdateUser(user)
	t.Nil(err)

	teachers, err = karmen.GetTeachers()
	t.Nil(err)

	entries, err = ldap.Users("ou=Teachers,ou=People,dc=foo,dc=org")
	t.Nil(err)

	users = make([]orm.User, 0)
	for _, teacher := range teachers {
		users = append(users, teacher)
	}
	result, err = syncJob.SyncUsers(ldap, karmen, entries, users)
	t.Nil(err)

	if !t.Failed() {
		t.Equal(len(result.Added), 0)
		t.Equal(len(result.Updated), 1)
		t.Equal(len(result.Removed), 0)
	}

	// Sync administratives

	administratives, err := karmen.GetAdministratives()
	t.Nil(err)

	entries, err = ldap.Users("ou=Administratives,ou=People,dc=foo,dc=org")
	t.Nil(err)

	users = make([]orm.User, 0)
	for _, administrative := range administratives {
		users = append(users, administrative)
	}

	result, err = syncJob.SyncUsers(ldap, karmen, entries, users)
	t.Nil(err)

	if !t.Failed() {
		t.Equal(2, len(result.Added))
		t.Equal(0, len(result.Updated))
		t.Equal(0, len(result.Removed))
	}

}

func (t *testSuite) TestSyncGroup() {
	syncJob := sync.NewSyncJob(conf)

	teachers, err := karmen.GetTeachers()
	t.Nil(err)

	users := make([]orm.User, 0)
	for _, teacher := range teachers {
		users = append(users, teacher)
	}

	result, err := syncJob.SyncGroup(ldap, users, "cn=Teachers")
	t.Nil(err)

	if !t.Failed() {
		t.Equal(11, len(result.Added))
		t.Equal(0, len(result.Updated))
		t.Equal(1, len(result.Removed))
	}
}