1 files changed, 173 insertions, 0 deletions
diff --git a/test/functionTest.go b/test/functionTest.go
new file mode 100644
index 0000000..e8d95ab
--- /dev/null
+++ b/test/functionTest.go
@@ -0,0 +1,173 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/go-ldap/ldap/v3"
+)
+
+const default_users, default_groups = 1000, 1000
+
+func Init() (*instance, error) {
+	inst, err := NewInstance(default_users, default_groups)
+	return inst, err
+}
+
+//Part to compare our datas
+func (inst *instance) CompareOurDataWithConsul() (bool, error) {
+	if ok, err := inst.VerifyOurData(inst.dataUsers); !ok {
+		return false, err
+	}
+	if ok, err := inst.VerifyOurData(inst.dataGroups); !ok {
+		return false, err
+	}
+	return true, nil
+}
+
+func (inst *instance) VerifyOurData(tabData []data_DN) (bool, error) {
+	for _, value := range tabData {
+		names := getNamesAtt(value)
+		cn := strings.Split(value.DN, ",")[0]
+		res, err := inst.Search_Request(value.DN, fmt.Sprintf("(&(%s))", cn), names)
+		if err != nil {
+			return false, err
+		}
+		if len(res.Entries) != 1 {
+			return false, fmt.Errorf("expected 1 entry, but found %d entry/ies", len(res.Entries))
+		}
+		if !Compare(value, res.Entries[0]) {
+			return false, fmt.Errorf("no match with the DN: %s", value.DN)
+		}
+	}
+	return true, nil
+}
+
+func Compare(dat data_DN, ent *ldap.Entry) bool {
+	for _, value := range dat.Attributes {
+		logging.Debugf("Attributes from %s is now: %s.", dat.DN, dat.Attributes)
+		entVal := GetAttributeValuesBottin(ent, value.Name)
+		logging.Debugf("Values of the Entry: attributName: %s, Values: %s.", value.Name, entVal)
+		if !CompareSliceString(entVal, value.Data) {
+			logging.Debugf("Values expected: %s, values found: %s.", value.Data, entVal)
+			return false
+		}
+	}
+	return true
+}
+
+//Part modify datas
+func (inst *instance) ModifyRandomAllData() error {
+	dg, err := inst.ModifyRandom(inst.dataGroups, []string{"description"})
+	if err != nil {
+		return err
+	} else {
+		inst.dataGroups = dg
+	}
+
+	dg, err = inst.ModifyRandom(inst.dataUsers, []string{"displayname"})
+	if err != nil {
+		return err
+	} else {
+		inst.dataUsers = dg
+	}
+	return nil
+}
+
+//Function which modify random way the attributes in attName of a data_DN's slice, it can delete, replace and delete
+//The function modify also in the dat object
+func (inst *instance) ModifyRandom(dat []data_DN, attName []string) ([]data_DN, error) {
+	for index, value := range dat {
+		del := make(map[string][]string)
+		add := make(map[string][]string)
+		replace := make(map[string][]string)
+
+		for _, att := range attName {
+
+			switch selNumber := R.Intn(3); selNumber {
+			case 0:
+				del[att] = []string{}
+				value = DelAtt(att, value)
+				logging.Debug(fmt.Sprintf("Delete the attribute %s of the DN %s.", att, value.DN))
+			case 1:
+				name := inst.GenerateName()
+				value = AddAtt(name, []string{name}, value)
+				add[name] = []string{name}
+				logging.Debug(fmt.Sprintf("Add the attribute %s with value %s of the DN %s.", name, name, value.DN))
+			case 2:
+				name := inst.GenerateName()
+				value = ReplaceAtt(att, []string{name}, value)
+				replace[att] = []string{name}
+				logging.Debug(fmt.Sprintf("Replace the attribute %s with value %s of the DN %s.", att, name, value.DN))
+			}
+
+		}
+
+		err := inst.Modify_Request(value.DN, add, del, replace)
+		if err != nil {
+			return dat, err
+		}
+		dat[index] = value
+	}
+	return dat, nil
+}
+
+//Add all users in a random group
+func (inst *instance) AddAllUsersInGroup() error {
+	for _, value := range inst.dataGroups {
+		valueRand := (len(inst.dataUsers) + 1) / 30
+		if valueRand == 0 {
+			valueRand = 1
+		}
+		numberOfMembers := R.Intn(valueRand) + 1
+		logging.Debugf("%s will be have %d members.", value.DN, numberOfMembers)
+
+		groupMemory := make(map[int]struct{})
+		users_cn := []string{}
+
+		for i := 0; i < numberOfMembers; i++ {
+			selectGroup := R.Intn(len(inst.dataUsers))
+			for _, ok := groupMemory[selectGroup]; ok; _, ok = groupMemory[selectGroup] {
+				selectGroup = R.Intn(len(inst.dataUsers))
+
+				logging.Debugf("Search an other member. The value is %d , and we have %d members available.", selectGroup, len(inst.dataUsers))
+			}
+			groupMemory[selectGroup] = struct{}{}
+
+			users_cn = append(users_cn, inst.dataGroups[selectGroup].DN)
+
+		}
+		err := inst.AddUserSliceInGroup(users_cn, value.DN)
+		if err != nil {
+			return err
+		}
+
+	}
+	return nil
+}
+
+//Check if the groups in memberOf exist in Consul
+func (inst *instance) CheckMemberOf() (bool, error) {
+	for _, value := range inst.dataUsers {
+		cn := strings.Split(value.DN, ",")[0]
+		res, err := inst.Search_Request(value.DN, fmt.Sprintf("(&(%s))", cn), []string{"memberOf"})
+		if err != nil {
+			return false, err
+		}
+		if len(res.Entries) != 1 {
+			return false, fmt.Errorf("expected 1 entry, but found %d entry/ies", len(res.Entries))
+		}
+		attValues := GetAttributeValuesBottin(res.Entries[0], "memberOf")
+		for _, dnGroup := range attValues {
+			logging.Debugf("Verify if the group %s exist...", dnGroup)
+			ok, err := inst.VerifyGroup(data_DN{DN: dnGroup})
+			if err != nil {
+				return false, err
+			}
+			if !ok {
+				return false, fmt.Errorf("don't found the group: %s", dnGroup)
+			}
+		}
+	}
+	return true, nil
+}